SLIC_Superpixels.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "4T7DI5sBT2hc"
      },
      "source": [
        "Author: Sri Sai Charan Velisetti"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "fMVszVsJSWCC"
      },
      "outputs": [],
      "source": [
        "## Import necessary libraries here (You can add libraries you want to use here)\n",
        "from skimage.util import img_as_float\n",
        "from skimage import io, color\n",
        "from skimage import draw\n",
        "import matplotlib.pyplot as plt\n",
        "import argparse, time\n",
        "import math, copy\n",
        "import numpy as np\n",
        "import scipy.io\n",
        "import cv2\n",
        "from sklearn import mixture\n",
        "from PIL import Image, ImageDraw\n",
        "from google.colab.patches import cv2_imshow\n",
        "import os\n",
        "import timeit\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "-gqTCbLkag9B"
      },
      "outputs": [],
      "source": [
        "def show_image(img, scale=1.0):\n",
        "    plt.figure(figsize=scale* plt.figaspect(1))\n",
        "    plt.imshow(img, interpolation='nearest')\n",
        "    plt.gray() \n",
        "    plt.axis('off')\n",
        "    plt.show()\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "H2o_cqYRJYvh"
      },
      "source": [
        "# SLIC Superpixels"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "P7srjRyqJjgW"
      },
      "source": [
        "## Overview\n",
        "\n",
        "Superpixel algorithms group pixels into perceptually meaningful regions while respecting potential object contours, and thereby can replace the rigid pixel grid structure. Due to the reduced complexity, superpixels are becoming popular for various computer vision applications, e.g., multiclass object segmentation, depth estimation, human pose estimation, and object localization.\n",
        "\n",
        "In this problem, you will implement a simple superpixel algorithm called Simple Linear Iterative Clustering (SLIC) that clusters pixels in the five-dimensional color and pixel coordinate space (e.g., r, g, b, x, y). The algorithm starts with a collection of K cluster centers initialized at an equally sampled regular grid on the image of N pixels. For each cluster, you define for a localized window 2S x 2S centered at the cluster center, where S = sqrt(N/K) is the roughly the space between the seed cluster centers. Then, you check whether the pixel within the 2S x 2S local window should be assigned to the cluster center or not (by comparing the distance in 5D space to the cluster center). Once you loop through all the clusters, you can update the cluster center by averaging over the cluster members. Iterate the pixel-to-cluster assignment process till convergence or maximum iterations reached.\n",
        "\n",
        "Reference Paper: http://www.kev-smith.com/papers/SMITH_TPAMI12.pdf\n",
        "\n",
        "refer to the following slide covered in Lecture_17_Segmentation.pptx here: https://drive.google.com/file/d/1bRmNBXgK1_kWcY-nhw_As5fP10aRhuDC/view?usp=share_link\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UpME_VkbLEAc"
      },
      "source": [
        "## Data\n",
        "**WARNING: Colab deletes all files everytime runtime is disconnected. Make sure to re-download the inputs when it happens.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vva9KDmrLLLk"
      },
      "outputs": [],
      "source": [
        "# Download Data -- run this cell only one time per runtime\n",
        "!gdown 1jbg2VMZ9yAJMHQNRCTgqZM1PyQRtcPyV\n",
        "!unzip \"/content/Part1_SLIC.zip\" -d \"/content/\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bRGHHL1lLcWx"
      },
      "source": [
        "## Helper Functions:"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "EFnvOOmOd4ye"
      },
      "source": [
        "### Code "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "OSa4YF8WgfPf"
      },
      "outputs": [],
      "source": [
        "# A class to initialize the super pixels, of the form - [l,a,b,h,w].\n",
        "class SuperPixel(object):\n",
        "\n",
        "    def __init__(self, l=0, a=0, b=0, h=0, w=0):\n",
        "        self.update(l, a, b, h, w)\n",
        "        self.pixels = []\n",
        "\n",
        "    def update(self, l, a, b, h, w):\n",
        "        self.l = l\n",
        "        self.a = a\n",
        "        self.b = b\n",
        "        self.h = h\n",
        "        self.w = w\n",
        "\n",
        "# Function which returns an object of class SuperPixel\n",
        "def make_SuperPixel(h, w,img):\n",
        "    return SuperPixel(img[h,w][0],img[h,w][1],img[h,w][2], h, w)\n",
        "\n",
        "def display_clusters(img, clusters):\n",
        "    image = np.copy(img)\n",
        "    for c in clusters:\n",
        "        for p in c.pixels:\n",
        "            image[p[0],p[1]][0] = c.l\n",
        "            image[p[0],p[1]][1] = c.a\n",
        "            image[p[0],p[1]][2] = c.b\n",
        "        image[c.h, c.w][0] = 0\n",
        "        image[c.h, c.w][1] = 0\n",
        "        image[c.h, c.w][2] = 0\n",
        "    rgb_arr = color.lab2rgb(image) \n",
        "    show_image(rgb_arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "y9DUNTwkgrMP"
      },
      "outputs": [],
      "source": [
        "def initialize_cluster_centers(S, image, img_h, img_w, clusters):\n",
        "    #### Write your code here ####\n",
        "    # To Do: Initialize \"clusters\" by sampling pixels at an equally sampled regular grid (distanced by S)\n",
        "    # on the image of N pixels. N = img_h X img_w. Hint: clusters.append(make_superPixel(h, w, image)) to create each cluster/super-pixel.\n",
        "    for h in range(int(S/2),img_h,S):\n",
        "      for w in range(int(S/2),img_w,S):\n",
        "        clusters.append(make_SuperPixel(h,w,image))\n",
        "    return clusters\n",
        "\n",
        "def get_gradient(h, w,image):\n",
        "    if w + 1 >= image.shape[1]:\n",
        "        w = image.shape[1] - 2\n",
        "    if h + 1 >= image.shape[0]:\n",
        "        h = image.shape[0] - 2\n",
        "    gradientx = np.sqrt((image[h][w+1][0] - image[h][w-1][0])**2 + (image[h][w+1][1] - image[h][w-1][1])**2 + (image[h][w+1][2] - image[h][w-1][2])**2)\n",
        "    gradienty = np.sqrt((image[h+1][w][0] - image[h-1][w][0])**2 + (image[h+1][w][1] - image[h-1][w][1])**2 + (image[h+1][w][2] - image[h-1][w][2])**2)\n",
        "    gradient = gradientx + gradienty\n",
        "    return gradient\n",
        "\n",
        "def relocate_cluster_center_at_lowgrad(clusters, image):\n",
        "    #### Write your code here ####\n",
        "    # To Do:\n",
        "    # for each cluster c, reassign cluster to the pixel having smallest gradient value.\n",
        "    # Step 1: compute gradient wrt cluster-center c.h, c.w in 3X3 neighborhood of cluster center.\n",
        "    # Step 2: Similarly, compute gradient for each pixel in 3X3 spatial neighborhood of cluster c.\n",
        "    # Step 3. Reassign cluster-center to the pixel (x,y) having the lowest gradient. \n",
        "    # Hint: c.update(img[x,y][0], img[h,w][1], img[x,y][2], x, y)\n",
        "    # print(image.shape)\n",
        "    for c in clusters:\n",
        "      gradient = get_gradient(c.h,c.w,image)\n",
        "      for h in range(-1, 2):\n",
        "          for w in range(-1, 2):\n",
        "              x = c.h + h\n",
        "              y = c.w + w\n",
        "              new_gradient = get_gradient(x, y,image)\n",
        "              if new_gradient < gradient:\n",
        "                  c.update(image[x][y][0], image[x][y][1], image[x][y][2],x,y)\n",
        "                  gradient = new_gradient\n",
        "\n",
        "    return None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "a3U_8h_fhj7F"
      },
      "outputs": [],
      "source": [
        "def assign_cluster(clusters, S, image, img_h, img_w, cluster_tag, dis,M):\n",
        "    #### Write your code here ####\n",
        "    # To Do: Compare each pixel to cluster center within 2S pixel distance and assign to nearest cluster using the \"distance metric\"\n",
        "    # (involving both color and spatial dimensions of pixel and cluster, \n",
        "    # Hints: \n",
        "    # 1. use \"dis\" matrix for comparing distances.\n",
        "    # 2. You can use c.pixels.append((h, w)) to keep track of cluster-assignments.\n",
        "    # iter_list = itertools.product(range(0,img_h),range(0,img_w),clusters)\n",
        "    # for h,w,c in itertools.product(range(0,img_h),range(0,img_w),clusters):\n",
        "    for c in clusters:\n",
        "      for h in range(c.h - 2 * S, c.h + 2 * S):\n",
        "          if h < 0 or h >= img_h: continue\n",
        "          for w in range(c.w - 2 * S, c.w + 2 * S):\n",
        "              if w < 0 or w >= img_w: continue\n",
        "              l, a, b = image[h,w]\n",
        "              Dc = np.sqrt((l - c.l)**2 + (a - c.a)**2 + (b - c.b)**2)\n",
        "              Ds = np.sqrt((h - c.h)**2 + (w - c.w)**2)\n",
        "              D = np.sqrt((Dc / M)**2 + (Ds /S)**2)\n",
        "              if D < dis[h,w]:\n",
        "                  if (h, w) not in cluster_tag:\n",
        "                      cluster_tag[(h, w)] = c\n",
        "                      c.pixels.append((h, w))\n",
        "                  else:\n",
        "                      cluster_tag[(h, w)].pixels.remove((h, w))\n",
        "                      cluster_tag[(h, w)] = c\n",
        "                      c.pixels.append((h, w))\n",
        "                  dis[h, w] = D\n",
        "\n",
        "            \n",
        "    return None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "NX63rPd8itIr"
      },
      "outputs": [],
      "source": [
        "def update_clusters(clusters,image):\n",
        "    # To Do: For each cluster, update the cluster center with mean of the pixels assigned (c.pixels)\n",
        "    # for cluster in clusters:\n",
        "    for c in clusters:\n",
        "      sum_h,sum_w = 0,0\n",
        "      for pixel in c.pixels:\n",
        "        sum_h += pixel[0]\n",
        "        sum_w += pixel[1]\n",
        "      mean_h = sum_h // len(c.pixels)\n",
        "      mean_w = sum_w // len(c.pixels)\n",
        "      c.update(image[mean_h, mean_w][0],image[mean_h, mean_w][1],image[mean_h, mean_w][2], mean_h, mean_w)\n",
        "    return None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "RZ3E4VLNixsf"
      },
      "outputs": [],
      "source": [
        "def compute_res_error(old_clusters, new_clusters):\n",
        "    error = 0.0\n",
        "    # error = Compute L1 distance between previous cluster-centres and new cluster centers.\n",
        "    for new_c,old_c in zip(new_clusters,old_clusters):\n",
        "        error_lab = np.abs(new_c.l - old_c.l) + np.abs(new_c.a - old_c.a) + np.abs(new_c.b - old_c.b)\n",
        "        error_hw = np.abs(new_c.h - old_c.h) + np.abs(new_c.w - old_c.w)\n",
        "        error += error_lab + error_hw\n",
        "    return error"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "ZTKsxNJIdy4_"
      },
      "outputs": [],
      "source": [
        "def slic_algorithm(S, image, img_h, img_w, clusters, cluster_tag, dis,M):\n",
        "\n",
        "    # Initialize cluster centers on pixel grid in steps S\n",
        "    clusters = initialize_cluster_centers(S, image, img_h, img_w, clusters)\n",
        "\n",
        "    # Move centers to position in 3x3 window with smallest gradient.\n",
        "    relocate_cluster_center_at_lowgrad(clusters, image)\n",
        "\n",
        "    # You can play around with these hyper-params.\n",
        "    res_err = 123456789.0 # init residual_error with a very large value (choose as per your understanding.)\n",
        "    threshold = 0.01 # tune this\n",
        "\n",
        "    while(res_err >= threshold):\n",
        "\n",
        "      assign_cluster(clusters, S, image, img_h, img_w, cluster_tag, dis, M)\n",
        "      old_clusters = copy.deepcopy(clusters)\n",
        "      update_clusters(clusters,image)\n",
        "\n",
        "      res_err = compute_res_error(old_clusters, clusters)\n",
        "      if res_err<threshold:\n",
        "        break\n",
        "    \n",
        "    return clusters    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "6-nHiGIttAxv",
        "outputId": "f5d3f6ce-2b92-444c-ad9e-76277e9665b1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "time: 5min 58s (started: 2022-11-24 03:22:17 +00:00)\n"
          ]
        }
      ],
      "source": [
        "# Main Block:\n",
        "\n",
        "img_path = \"/content/Part1_SLIC/BSD_data/images/10081.jpg\"\n",
        "\n",
        "# Load image and convert it from an unsigned 8-bit integer to a floating point data type.\n",
        "image = img_as_float(io.imread(img_path))\n",
        "\n",
        "# convert RGB to LAB\n",
        "image = color.rgb2lab(image)\n",
        "img_h = image.shape[0] #  Height\n",
        "img_w = image.shape[1] #  Width\n",
        "\n",
        "# k: Number of clusters/superpixels.\n",
        "k = 1024\n",
        "N = img_h * img_w  # Total pixels in the image\n",
        "S = int(math.sqrt(N /k)) # Average size of each superpixel\n",
        "M = 2\n",
        "clusters = []\n",
        "cluster_tag = {} # cluster_tag should contain cluster-assignment for pixel h,w. For example, cluster_tag[(h, w)] = c\n",
        "dis = np.full((img_h, img_w), np.inf) # Distance bwteen pixels and cluster is initialized as infinity at the beginning.\n",
        "\n",
        "clusters = slic_algorithm(S, image, img_h, img_w, clusters, cluster_tag, dis,M)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 215
        },
        "id": "4kPdHh5HxU0F",
        "outputId": "30dfd226-5ab2-4fb2-e39b-49fc6c9b74af"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO0AAACjCAYAAABmH5mTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9d5wdVf3//5p2y97duyVb0ja9QCAE0ggkgZCEkiCCNBUEFIEPRoogTfggKoKCCIiKKAJCJAoKCEiogUBCEkIaaaS3Tdle7u7eNu33x5lz7pl6726Cn6+/B6/HYx53+py5c57zfp/3KSOYpokv9aW+1H+PxP/rBHypL/WleqYvof1SX+q/TF9C+6W+1H+ZvoT2S32p/zJ9Ce2X+lL/ZfoS2i/1pf7LJAdtvPepj/PWBwlibhdRJO8A0ZTYOkPQXevICq9zeVzAMPIlgSmo+kqQJN9thVzP0AtOBgTPG4HvK1ISvNNG/zsA0HT/e5NF+/GiQO7BMEXbMgAU/m8CErzT5fc3G8hffagoonUO7z9D07TA40UIea8heOyieTxAv+dUyDVs+4vu/b3+I9EjDxoB+fuWS8d7JuSIWVoKLGDPbP9/kVgg8wBgmj1B4/DllSEBAisP7JHWbZdP6tH+FNjeKnSYx/dUPb2//5R6/S8Iommzsl5vDB5eQeS2f0H/veD1ikUPrGweKRHZdzocSYp3ukVTYpMs9eztfyR162XemffB5z4t6HhFEW3A8lb2lkvGs/l8VtZLTrB8skCg7rh8suf6Qu7Py8ryuvWyiWS/I5QHAUAIcimD3GMeWCre2vKSrH/SNKzt3G68h0INlMtrOUwXucfQelxPUoLBVNO5DNcT9zgUsp9XV+3ppy++Oy6bgl/OX8HWO91l3kUOsq7OLaKVVsPDOzgS7rGXde2ta0wtraYGu+H/SffYD9reusdSKAI9m4YUiuCmi8Z4njwwJ8qi+0HqPbghKc9rT5I4l/oIuZSSrAAAdE0FcOSsbD7ls7ZahtyfIslQdZI5ncACxOo6wQVgAxYAQrL/fRmGuywLBJdnRUGEKMrQ9CxJByToyGX0UCgEANCzuq9nIEGAquZ/joJgeIIry3KvrG1PxT8DL/HZ1jTJ8uG29g2ytBRUfjlIgTlNM0QXuBJM6BCgSBJU3f72UqyEqbreI2DJeSWbJdKhsze9ae1r6BpESWbzftI1lcELeL8QFNl966qmkXQ50qarh5+R5LAIwYJJkWT4xJ4A+IN7uBIBn2ifW4IkAdbzpcAWIkURGbhBZVhRMFigDABMaPB7pCH2rLxfCLL1AtM0nc0DgK7rkCQJhmFAkezPmy47vUPdkadpNqbgyiEFWpYYBDmkwNA0iFb6+Hl2vjx5Rw4r7IWQD1aqwCdIgb3zylNs6ymciiSxKawotu1errIgGpAUEYqSPxN4uWYi98eLkgwlFIJiZSglFGLbeWABy4pwmdUL2KD1kiJDksh0ODJFA6ZoBAKbu6YASRGgyDKbaBr90kklitYkyO6Je+S3fWsyd4yViR1Q5wP2h9+c6FoXUkSEFOJk0okXXaaBMuoRSLL3BMEgkyVZlmwTv56X1AsvK+gYOaSwXzrPQ+oEFiB5x8vKiooEUcmtLxRYoMCQ0P1Pf5Q74DAzLgAYhv3tI5j+VtkUvC0Ob6kVj4zFZ0iqkBJBSIlAEGQIArkPr0wHALdekjueWkhyXdk2CYZomwqRqftPQZKlEExThGkSV5ZOfjLyVPA8+NeVAGA7hyjKkKUQRMkbWClkz4C//tsq93U9XF8/gNl5BRGS4PS+ZEiQAVO0TxRiB8x+8ou1+K3vrW7+xvHulVb6KKBOWHujHqX6cIE9EsADBFhd9wiccCDTDJlPXpkOAH61IHe86VG2BwCjgPJbPgmSffISfbEIHhlUFAzIkug79aSq6kiJjwj3RPp/uKqsEEmKwqZ8evjv6zzXCxIxPDysN110XK/TlBdaJRKBEiGmO18E1XVy7k0WCoVs1oF/u/c0WKTrhqtM/EXKaUEN1cDNX3dnTFkRoUiyq/x0uOJfLIJgMHh7Uwebz/oergQADy1Y06tjnZb2cMS7pEENGHzTUiCo+ap8SFoUV3XkI/9Y3+M0UQXmLgqrmk6zedc+oRB0j4ifZPn39ALZbBayYj+HE1zTCgIonAvG/92aVagvFNhoJIJUOo2wVf7wMM72NIsKJOiuyKIpGjBU+74P/dVuoWVH0IWCy58rpISQVbN50y1LEjQ92FdWZAF5dmFiZS3DsJVpNauYIssSNK33DWJo1FeWJOi63qO0HWnxsNJ5UZKgqarfIS7lg1UUBRiGyX4997HK10a+TAdAVgRbNZZz2XXuvGcEbMDy1lYJhaBmswxQSZbZ5JSzfOR0oWSJwKqEAgIBigw5j7WXJBFRK72pdNq+TTQdk2KbAALZkbKW7FxyGIochmkKZD4sswkgkPITXcf/8vsB7ihnQXKU4WRRhsy9OJ2BHD/JsswmPm1ALpDjDOjwecKZP/j8A5CXW4gPVrLImui6B7aLLDFQPNOsKCyARCd6jO3YgHKuKArMsvK/oijYAmN8OkQp9wLwavzDjJsisIku+6bDd0uAnFFb/uKFqrcuFAAIoug70YcdjUQQjUSYlS1UPKwUXkWSIXnUqQLEwlIr+wOHy6xIMoQ8wQ454H/jwXXC25vIaHA6JPbrisJa9yCJIpvPHRcQCLMCUl55g3/B65pmA5bJD1IriChKCpkKedkU0LxAlCWbu+sZWDpMCYIAWZLZ1Bv9Rxtz+rWFLfAF37trHsFIjBSSXROvR19wvIgECWZAZLw3EiCzSZbCR/TcP7h4HJsXBYlNpimw357cjyILLgvrB3CPJRzZuIGX/AJLTjmj0EFQSY786FM5Eny9Hh9wBIMF/00SehjZlOUCLXwPmtoIHiEIWQrbJrKjzDJ1KMKBnScg8+iLnxWclp7qxouOrNWiFlHm4huyIua1qPyL6YuUFyVOYHurwLbHj7y41tQdQZlCoKWBCb//z9m4wnkNqt7EOf3Kooaj7akkydB1zdZgQtP4K9r3N/PcNw+1E1iNC0YIXq/WXraRoxDLYSCdzCBSFEY6mWGgZjPcPQQA6+Ve8oE1aknUrHcwR1FkqKrmfR+9acHvIfr3a1wSPCO3JiCHrDbKWdqY3fuczuChphqQFRHZjI4wl0czVvAwrISg6rkE5KvnNQAoVvHM0Pz/fz/n5frzju5522MqW0uggIfPuzm0rMNHlv1aQtHzG6YB0zBYOZBlJZ9MLVk9X7Jarl2vlxiwImxvAmcLJ1kWoXG5wga0z31TWGVZ5FNsP68kQvdosC55wKKrGiRFZs3flJDiCYsckqFzgWgKbKQo3JP+FQXJMAyIouhKi2IFBSmwfmkNErU+Xv8PFf++lBUCrl9VCwWWzjNw84gCKxgSwo7GDzzAITk3rxnBTRQVLp4iymIguAAQUnJeUVbN+O6XF9pCm+75lUskWe6RS50vcNMrifZ5KaA85He/sih6gmu3wDr8wCWZM3/El0bn+QfOz/NQSI53YKTIXsYNhfm0cPNeecevY5LjeTjBVFWNWNqsytYrjuCfyrW/9XMRJVGCbujsReCUZqs6k5BVdYQUCZpOGpdoAVUrsiJCC2gIo6kGFEnJ69o5o7+yKEMzNMiywl72/LxTouyo79cMKCHvuAQPsOs8wck8MjpSPXh4SVz/0pAsIiSLEAQDoiywCQAMD1B0s+cdAASJgMtLkXITd3aPo3Wf9T2XElIgcwGwHnufPQA2MB305cK9ZJyw8vvSSQzoF+wHrJdCCo2sO8q0DlHLy2/jI/6HK1plJssKKxbJsgLJ+i++/9WjfI91Qlyoen5ULyxhoZb2SAe5RFkIrJLwkl9HeoCASzt0B4/CUACg/xftC/3Uw3eqH5z5tvEKgjfwuIAiSL778IP1BxePgynqbPISzRfzzj/akSCfgRestPz+tS3BieqFekyJLIvsTS+HZDZ5tYoCCIhH2tJKR2AUh95Y2yOmIwjs/2tfdSkURiNgzKsvUtd9baxr3e9e2WBbNkUdoYiEUMT9nB5/+fO816D9Gr4o9bqyS3bUUTKQLRdBzarMch4JCxqyXKdsQP9EUVZ8x2eiFrcnnawVRfIdf4lcUPQNzPERTNqNi/TDDAZWkSWomm7L/F9UBqetzwSfpngAYHKWRA/YDyDA8mml92Dopm1boWDT+IZZQGRNUiToan4Pxwmol8Jc671QRIKa+eLaa8sCoPXw8QZC6xxZIV/Da1kmQQpavvEDyMiTynBEQSatIhxRYDoibjy8Stg7Gu0caUD2iGp7ecE0GKgoElRVh+rIBF69cGSHO0ijlV5RS6+6W0EUYBomBA4O2VHW4TO56BNEM3QNBkjbYr5TAH0J8FJCEtSsDjWrI1RAuUo3TEiiAMlKo8D9EXwAxjA1TyDpOifUXvILRCpKCKpV9UIBlaxyLQ+rJEmekBtWhiA1BF9sp4mIM0LIyeSG5MnoKjSz53GJHllaURR9waUZspAyjSgLngkVRRGZNDl/OELOI8iiC1xTFAOB5X974j6Ksh1c+8bCzsFXORQqoYCeIkGio3jQzgA00q1YVUqKR9UStbImgi0tAAarlwpuRGKpEHCdoiCHrGuZAAMW3LwU0E9VFAQYpmkD1glw2KfDvxIWfa2tKJkw9Nz/Ey5ggAe2r6T0KjzZ8xZReQJR8849Ju85gt4sFNYjJf5a3z8vV57xg9lp5agOpxdMTyUUOA6XoWu+w+54geon029wMt9By4L/i2vPyZ8HeirhCBTeRUEgMRlrAsjzDiuKL7BUSliEqMA1kXMIkOX8z8wsYFzoQnTEi8uPv7oJwOGN/ftFPHQA+P2/8pdn/EQb0R/ptJl5rNx/6rx+gALA/5wzxrYs5Bkv54nXNwVu723kmF2/QIDnnXds4dc1zdzUS8myAN3M37jkqrOH9/oaQJ5mjL//1wbPjbQ1CrU+sixZZSm7eHD5PqJ+rrGfvNxjf1nudTiCTCZtpcO9l5+1F31bGQRcslB5vMf8XGO/tzJfpg0a3C7o3L77W6AHAQzYoZUcgSqjgKi8xHUHVB39XPkyLQ/ntecegydetb8MTJ+H6Be48oKWft3h6q8chSf/zVXPeJxb9zhvUJBVlEgLK5YuxzPV5SJAS/oef83cYb1vxmhLiC1g4vgchWNffkQKTdcL6tzteU3uOkaBbmomk2bg+nWazxdYkw6n7yonr+abasbeGV6WZFurH6ogV1lRFFemZ8f1EFi+qaVgmL7gypLMosheZV1BSME0o77XkRxjWikeHc41XXdZUyewQigEAYDRg87tABkfWjN0yKIEE7nABw+sIEgwYUCAyH7JsWLepotUkqDAPEINapzKC61zeEqvjO5rnfjzODp10wxCm695ZU4Tpmu9KEvQDZON/pixHlpuOYNwONdpP8iCK54wu10/SZKg5xt1zUOyHIKmZaGqWRe4LJDGubE8uIWUa3XDZJmewksDaDokmLo9Q/Oth2jzP36ZjZIYVljbZ0kUoRsG60drmoarTy2ViU6SdiEFAAiLfZDWk4hIRUjr/hbFqZBEoFc9rJDgKHuKigLB8cy0TBKSFIauZxBSZGRVjdU6FCoKquDI27LjpWOYBkRJZCNUOK1rXslFCEk9e/EED6EaMDzlvHPdldRBcpaLJFFi7VD92qP6ZVz+DR9WFNvwrby8YPkiFJIlNnh4SJYgyyHIXMPynqQhX+doWvXCV8GQayi2iLcEHYKk2CYdEptkjxeWpEgQw4o1L9s6v3vpu3NH5b2fiFTEfuk81dVnj7YtiwhBhOPlJpNjhFDIBSwvU9NhWl4YBVayuio6gbVZWad6WP/Cu8cUWL5lFZ3X5Chxh0HcYjrfG/W6pPb4qz0L6vzx9c29vVSPxFvZngMbMAp8AYMVe436L8uhguIbhQDgt78kyIGdINh+HLaubYqcJ1bg1lMLt0EzEmzqqZ58Y2vgdh5YLwmQAMtblUIqpFDOYoWiIqSQCt2QoHOW76qzj7KONSHQMqYg5KaeSAQjSLRegn7NICWjC5LRBThG9uyplaWX7dkBX0QvnP8C+bnHFNQr5/g3DC9ETy3clncf3gKT/Q0rbRp00z1gXMjxotEDXkqCVey56izu5eETC3DWDMhi3LVPWOzje62eSjZkyIb9pURdYoEOoGZEYBgRZm2vOnMM9KzbA/vzG0e+LXAh0sViDK0mk2R0Hda5AqPHf/z3Zs+N5DMLuT/EL1AjiAIrE/HyWtdTebqQPsETlRsBkY8qU6usse+oSJAtF1NztIai6zPZLKvTy2SzCIcjrOwoSApMXYUohzzrdT1f5I6qGdqXlg9KRaIknelUmt23HJKhZTVPC0sB1oU0YMasO9Nt0IrWB9QorIFW1qPbG//xKi8rGwSt6vGCAeByjXlponcAiMLLXGPL2lJgmfXV7PfH92V2tpCSZdH2iRJJhvcnS3pgv44dWm5b3ri7DbpYHGhpvz2r9shEjyWBDCqm6ioDV7KGznTt61MmCgI2FJKQzers13OfcBiGpkOUJfuvR8YzDMPmMgNwLcsebrTs07qGr4Sn8wI/4p5Eu2cVOCypKNgGaaOd4DVdY7BS0WUtS3OQYbOwkhCyL5sR6EI3rplzPP60cDtZR11jo3BQx4pLAABLDvRl65rbmgNva9zIPvhsewuGHj3WBbAiWB/zMgEDJL1BwALE2jrB5QNQgixBFMnL96ozx+DPb+6EzsEoyRJ0TfcceIBvxWfSAKmDDBe4jr9OCSsYWp7rA7utnlhTJ6xUQ6uLsSP4L/RVoKV96s0tro2mEdB1zePzl+Qg72MovIrVOkUQBQYsLx7eUJj+wUfQTT+cXkge9XTO7n0UXr8ik9fIij0tXmlZt/XShbQFLvdFNpOA/9yjl+Gci38MID+AvH5563dwx6+eybvfuJF9MHrMCTAMC0rRH8q12zWoWpKVYf1EoWXWFTokUQUMrsO4mGHLPLRBDZ40zWDgmgEdRERFgZpSGdCiFQDlYfVSKOp20zfuboMU0NEd8Le0RwxaX2ABT2g9R8b0q1v0rMA+stAKkGFaUY3vnDkSz7y93XNX17YCoKXy9EZ8hkKlp7hi9jA8+94u72RbnpWg5ObpspbN5qCFhL5iPZ55+sdobbeXpyrKijF60uWoLK90wVtZXul5Xed+1KoCQDi7EUcdcypGjznB81geYsPIYvuWTRh5lLuVGb2fRJK43rtbSblZt8rxNlhFa2gWDl5dM3KusRGGxAWA+GcoeNRceIErKgqrE/aDdcigGuzZ18DmAeBgUyv6V1XgYFOrbd/ubm+3eF+bikHl5Pwzx/f9fwdaP6+MQvudM0fjmbe38hv4o/2v0wsJpohvnzkUf3l7N4O2Zyf4YqEtVFp7J5uf/+SVAICbb3qUrVu57FVs2rIaAJBJHES3EUdFWTHaOhL4ykU/cZ1v+oB6LDnQF9MH1NvW03UbzVNxrPAhFq4hgZ1M6FiMG9kH4R0PYchXn0dnJoGSsDtAxYsCXLeHDFXaeLADRcVhFMftxYKBA7xHcmxqOYC6XTtQO2wEDqYG2KwsAPSPNuNgqhIQM5DgXS1YKLRUhVjXIGDpcne3ilgslyYe4lhMwef7k76W9ogR4Pupjl6M+2sD1iWDm6xrC2TqjUzBwPxFBFivIUp7dU7Hi1CRBQiSDDkUhmyNCcTPA4AgyRAKHI8r3dGEZHMdks116Nj+J6Q7mqAJaWiWG3zzTY/ihNH2Dzylm3MtisLx/lxaRYwaWIbXX/wZpg+oZ5Ae2DQfw9p/BQA4cc7VSJdPwTo9Zz01I8GAZefd8RAAoDOTYL/8vGFkbRPvMg8eNhnV/Us973f/Ae/xh6v6DMD4Saeiqs8AjBsIDC1OsW36oQ8BZNA/egD9w83QDRG645tM+YAVFYVNdBmwA0sBdS4fbGqFobYDAPul6wECZne3yiY/gL3U41wqiCYURUQ2Y/VP5D5fUOg3dnrUmD2gbacTVEkgwQ0/0QYFzkHAaMd4E1ruuzQ+v7xCERlZjy5bpq4C3EeXVM209cV1wkqO0diy6RGqTHc0wVDTrvWxqm+ikM4joZqxaN3xASrKinHMUROY1Z0+5VQAwIM3XYMlB/ri9Rd/xtaPj6/EgU3z8cmbTwJtK3C8BKzrewKAehwvrUVdRoAUNiHJZQhnNwJhoM+03wPdBhDLPTcKrlNbN6+FliUeArW6yS7i6jqtLQ+un+WNx8swjhr3gaeiqeUA29Y/egBAGA2ZCk9YeQmiBMEjLxuqClFRsLstw8Cl7jAVvzxk0DAcbGqFqJQFXg+wg7qv7TCgVcIkYWomw+YBIJsif3DQ90aCJIiCN4ymwaoSTG6+NyNfUIC9QHa3BnI0VaPfV+F+NU2zRY79Pn8JkAhyyBqLiACb/93IYDU0ZBLegPIKyWXQhDS+e8E4PPXP3CDjVcUJfLDwadu+Kz55HcuWLcLUqbPw8ccfYMmKD9mX99asfB2btqzG0cdMwrJlT7B9AOCdDQSoMzAfAPBZZhJqj5+ODcZ01K17EoCAui0fY089aW447swyHKzfza77zfO+ir/96zVX2imovD5fvwIAUFRM8llXgtx/n+patk9ZKYlCUxiLSysRld1ualPLAYSVGMJKDPE4AUa3Xgpoa8XBVCVkWXBZVQAuWCmooqPVHbWoe/Y12OYBQJa7MbD/MO4c7bZjKcTRULdrHQAMAhCLpuCnwNxEYWXAGiogKgiFrWFEjMARV/zlAyFf9yf0coga3vrSea8mez2Vc4A4wRBhigZCYZ9zW/+JIgsAdGimz4BkAtmWbjsUCKro+OIgTEA2IzZgqU6be6UN3CknnoNlyxbh802f4oc3P4x6swTPP3K1dSOkjAsARUIXJsZWYJ1ILGPl4FkYH1+JAcdchgOb5mPu+KMAkOqfZRysQ/oWYU99EpkRt9jS4QVsT9XSWIdkV4bBzKuroxldAObOOAULF38EAAzWjEqAaGqxey0V5XEAuUBaQ6YCNeFWNBk16Kc0Ix6PsW1ZowxAGJLg9hTq6rZDt+p+9+wmwT05LEDLmNB0YM/unZDDPu0Gks3WF+JFpBIkndF4Lh/F/PtbkOsEbeSt6xWzhuHZRfYoJg0o9Qrc/yNdNmso5i/anX/HAkTBdcljFYWTX0407PM9twtSAIaaRkjOvZGpVV2zZSMmjajEpzuaES8hz6yzK4XT5rrP++uHb2bz51z8Y3z8zsPIJA5i3fJXAQB/fi/n3i1b/g6kGacDm+azdbsyllWpzzXm31OfxPQZp/veC68tmz7FiJGk9diO7VvYPL+c7Mrg4CHyjPr3GwqAuM3Jrh1s39phI9g8BRYAMtwYYmElxtbNnXEiFi7+BK1tCVSUx9HaRkA8uq8GII4KpACQ/XXaJt4MbpopyQYDFwC0jMnA9QJW59Kmqxp0FYhyL4lCFRg9fu69bfQT1vYNzo+1omfQhkIyso7Bo/lb/PYZI/GXd3LVKoc7MNzhDoDu12Ae8HGTff4LzZTw0m8vwUEuIDthbDlWb2gDAHz3xvt8r0Mhls0INCGNfrEss6ZDj65BQ7OO9euWQ5YUDK+MYNXORtx806NY8cnrAIBswwZ0dddjxPSfIT6gNmdpAcREd+YcP/kcAMDB3Utt6ymsJ590BpYtf4et56GV5PxlOADQtfzf6gVy4PLioa3qM4C5xH7iYSbW1idNXuVdn0CJrvnniyB4gRzASsS/AvnEo4f2vMpn055Gk36dYP2BnP/tBa0QECXWuWvwg8Xx4AoA+16rmun594OCdLjQKooJQ/cPXrjA9YE20bAPy1++HtGywQDAYJ0wthzHnHAMnntuKQP3qd/chcsvn2ZPR/kciEoEhprGtmV/wdCja7D78wYUVVUi2dSMROMG7GgVMGlEJdpam1Bz9Ezb8cuWLcLit1fj1DMmYerU03Du5JF4deV2ZmWPP+lctm/9jo+wq1HFsGoFe+qTzAUe0pc0gOAtLVA4tIWCStW/31BU9y9FOFLFyrTOr0R1dTSjuDRXp6wmc+VBIRRCupukNRIrQro7iUisCEUhGcmshiIrP+qiBMnQC4LW1HUIkgRdEyEKKgzTbtT8gNV9RhLlwX394bsAAOHGPbj71WU9h1YzYW7d2wg1A6yva89ZXAe0QcACZECulNX+1znCIwU3H7S+7T8LUIgrJKgp8hZSomE27yVFIf/LRdMG4x9L9x4RaB+58zJMPaEUH6/tAABcfvk0lI6eh2TjbgYpBVdte9M7XeVzAADblv0FOw7kvJHOrhRKisl9VitpNKoRdHalMHF4te34VTsbUSR0IWkWY9qJp2HNyteRNIsBAIvfXo1rr3A3itjXkMSgmiJsO0gCN6P6S6gZNdO1Hy8nuPlgHTHyKFfEOF4+DFEu+JfKZhENhVzQ8urqIOXVsBKzAUtVUR63wZpIdLNyLAW2uz1hpVlFvNJqgqmbMD3q2dU89yV7FHOc4qF9545LMen6B/Hpb2/rPbQAsHVvIwBg9Y521z5BwIY8RurTPb5PCyBXMKZfaMtoBGLL79Y1d3tQwdEwgd6LnjUghUTo1jCmntAq/vctZusx5+QJKIrkLiiaAgzBxEvvfwJV6edZnjW4t7RoNV00ZAldB3Zj995P0LFzCSKygeJ+Y9B1aDM+XtuBPrFGtHRXM2DPnHsS3l64HP36A6+/tBSP/eEOAECs5Dh0d66HUj4H25b9BY889gzOucBuiYEcsKNrSti6VTsbcfLJs5iLDABb6sn/fFRfA1vqRUw78TQ0713kOl/l4FkuF7n2qKm+/x3VksXvsvnpM07HiJHj0XcAGZ0/FA4jm8mweapsJoNQOAxNd4MQ9WiHyMNLYaWi0PpJS2cgW18X1NLeL+9YGXGjzay3taDAKnIIqpaFJLndc8Gnqx5AYE0luiGHFCiREAO2fMAAAL10jzVuUBsKLgCoGWDbgQ62nDZMREQB/JcVvYAFAqClEsUcsEBgYZmHNug+qDzbemruiO1F0wZDMwA6MKNovZgM6zOVybSGf61ucB132fRBeP7DXJBL0yVs+vTvAID61X91ucWrli/FH/7+IZ76DbpkDmoAACAASURBVHGJKLhUD/z8p/jHn65ny2NmfJVBCwCSVo9BY8fh3feWolrJ3Ud5RRUeevxN3DKPWOVQTW7AgtZd76JimD1otGzZIpx88iy07sqBRmHtP5S8GCi4/YdOgxS2Xo4ZwVauBYCrv/9zVFYNRJ+qKgBAZ2s7slYvqJCkALLI4KQ6uG8r+g8ajYP7tqJ6gLv8SpUPXADo7vLocRRxw+QHKpXu8RGtkri78UeQpdWSWchReyjYPnA9oKVSiJTGoWVVLLn/GmSqhyDcuAcADs/SAkCyM4W61k6oGUAJE3CpeIC9wP3GzKH4+/u7CwLWJQvaS08bjuc/2JlLuI+VpYoYGmZNqMWi1XUAAF1vwhmTx+OdlWtghPoCMue2WOCKWWKF5pw8gbnxIcEOrMh5Fl0Z1QYvb103LCOwDh18Ip76zV0YU5vAiGNPw46NH2BzHXmD84EnJ7j9rEZL1Uoaiplz8aI1J7L5RKN9IILyiirbcqhmLLING9i8n0TdYFa2cvAsz30MSWRl37QexvQZp0PPCDj1zEvI+SUFuxrrMay6r+24rGPIGx5WP2l6FrIUQsAwxjZ1dLnrfb3Ew9sbaHlFioLrZbSkN8xOiHlF4zG8c8elyFQPwbSvz8NZs6f1DlpFFKBaLZiSnaSAT+Gl8oMWyIGbF1jAv1Gyw9o6gaUyTRMRa+CtWRNqbduiRXbLn0qqntuzlivEu8Z0HCvRFCBIIkzdgCGYSKY1FEVkLPj4AERDhyFK+Mv/Ho8Jc4lL+/6/XsP19y2A0LQMHy96HgAQkQ1Wpr36ll8jUt4PAFi59sy5J2HY0BPw4Wu/RJGgIVpzIlINnwAAVIEEgcadOhv7NnyGcD/7EKHOduEUWCA/tIZVl03BBEhgSpF1jAt/ijWJyQCAY46fhmiMZP7yUgLo+4v+AgCYOevbOHXKWHy4wv4yCQKXWlne+h7c592MdfBQ+/A0hcLqlBRQ05kPVi/JHoMLnH7aZLz7wUrv/S1w053tiJSU4bQpY/Hmu0sQKSlj69Kd7b2H1rmOt7hUPLSAt7UFCnONbfL7kLMPtAAQ1lUXsFROcAEgLEvIOPq9+n0pg5ZrRUc5nlpcal1XL/wlAODye9Zhwf2zMWQYyWwDBg5DS/0OpDURAwYOQ1lV7q276oOFKK+sRVtzHaJlgxGRDYhyNYqqSFS0bsPbqB17pu99Zw5tdK3jQeXBpPPrlr+K4086F+uWv4rxk8/BwMGjsH9vbgSN8fGVDNb+g0eh/8ChSHV3Y8vnpIHFCRPPwtpVbwEgwOYTc5Md0BaiRHs74mVlGDx0dK9h9ZIEuVegUnkB67uvj5VNd5JYEYV17z7Spvt/rryq553gTU2FwEFHLS1gd5FHDShl4H591ii8sCj34HnqJVOELhiQDR2jBrlHNhhYVYL9TZ3Ys+9Q7pqi+0ZpyB0gkFKJRgaG6Ha/okUKUkmVWVce3s6k3U3KZjUExQN5C9yVIecrDis2YK/8GWnXu/PDXyNcUo2TZ12KBU/+GAMGDkOfviPQUr/DmoC2ZuK+l1fWYsu27Zh46rmo2/A2KseeiWRTLrgSBCwAZnVNQ8CG9ctYIIqCyQO79JMP8I2L/wfH/c8vsH79CrIdwL79OyACbN9V3VOwbuWr+MpFP0T/gaSsSa3szFnfZtfm5wECZ4gbGMBpaalVpcEop755/vn428sv29bFy0g0eu/urSir6u91WK+kayrq9m9F7cDR+Xf20M5duRZpg5QMVv3zebacqR4CAJh+MgncLf/X87Zj6XZfXXmV5+pAS5tIpMyiEgINtbAAcOzQGqzd4g7EOC3uqAFWwd0K+27b1+IJK9XAKpLRlq52j5fkBaNTopHBaZNG+G6n8NJ5qmxWIw0+fKKEAIE1mSbbi8MKujIqisMKZs+sxIS5d+CYIYPw3OPzcOXPVuO5e8/EuNOvwvtcM74JY8kIBhGZeA9tzXUMxLoNbwMAJp42Fw3NOmoqJTQ0260/b2lrKiUWfOp7zGm2/ajF3drQiREDRmL0uJMwcshwNCU6sH79CsyadiYWLX3b+/+zLLDo6FBxzPEkGEWBBYBUdzf69/ceKX9XY671SIXk7S0VlVVh0cPXY9ylP/Tcnk/r/ng3ZvzvU1j88+8CAGb871Oe+y370/225VO+cRkAYMNiUoY/amyuiLFlg9tbGTuDlPGF9hbXNi2jQQ7LWPbCs5h83qW+aTVrx7H5T397GwC49l+y7GPXcT9/ckHP3eN1WxtNJQzUVpS4tjldZCoK7qgBpe46Gkt79h1CNpNBc7t3M7GL55I3E4V32gT7SIUfrd3rm2andL3Jte6MyeM995V8vsdCIaVWNpnWcN6cfhgxeipKh09nwMpKJcadfhW2rMjB2q+qHHt2bcWQYaOxZ9dWTD1lDg7s34VU+17mDlPVjj0TzXVbMGDgMGQE/+qK9euWY8SAkQCAES2ky91RV/7Cc9/2rixUw934fP36FTjuuClYbzXUp1FlP2Cd4gGmassQSFt10RdWgADb3LDHc9tnz/+azcdK7N3evjXveufugXr6t48AAK68/iY271R5X2K1b/7VE3j41msB5ECee/l1WPjc71zHhLh8nbUaD/AW1g/glT20tL2C9uePvWTe/r2vAgBSKZK4aFRGKqVh1yGuXOFs+UCXPaDdtn0PAHgC27+GRD+dkDq1dPU2ZnkbDu5ln4FIpjKIWXWypmHYWkJV1hShucE9+HVljXuIk+aGpOd6qj/e+xWMGD0VJ8+6FM89Pg8AEKsYg35V5TjU1IZMZyPCJdXIdOaqyaqLgYr+I9F6cDsau8Agnnjqua7zh80sMkKI1deOGDASRVWVGDb0BAzpl8vIW57+EQACbHlZHG3Wf9relUVZMYG+KUFeou2tLQBMlFW4R6PYuHaZbbl6QC0aD9ShekAtqqpINdU3zz8Pf3v5XwCAtBwD3we8jXt5U2g/+91diJQQb2bHTtLGemB1P7bOS1fefA+efvinbNkJrVN+ENcM9q82+njVp9iweBHGzpgFtcXtLW7ZsBFt9Qdt6049y6MRd4Fa9sKzAHIg8xa15LiJbL4sZm9amU624sbrbus5tKqqmhRWgADLa9uBNqgZ4N9vk8DEqJHuP6u5PYFKq5KagppoJx2B42UVvtcG3BAvXb0N0yaMYhb44EHy5yZ9WjYVRXM5SzM03HjFXDz+/Hu2fZxwGqG+aNi9Bf0GkDLU1m37MHrUILZ91eql6Ni5BIeaSF3ra68sxZmzRyFckmt5lOlsRHUxMHL8HGxf8yYarRFepp4yBx9/RFo6OWFd9eGrGDJsNIoilWipX41jp30LANCnYiCG9KvBnkMNOOHokWhrT+BPf16AU8RchJa3su1dpEROoQVy4Ppp49plLre4ekAtupMpDBnsHhp2y+dLoGcEdK34yLXNTxTWdKfqWnflzfe49uc/F/LXx38LAPj61dey9XQdFbV4V15/E1v3xN3XAQCuvfd3eOUfLxSUzrb6g8yF5kXd6faSYkwZMgQAsE/NX2SjSvp8vqTIZ6B9wD8QlRfafInZdoBkXuoqb9u1H6OGDcS2Xftd+za3JwoGNtXV5WqnXVIShqn7Q8qrKBr2bHPMt2JxrgtSojuBzs59NteXires1cX2bY3ckExTT5nDoscAkGrfi1POI2WckIdXoqoGFEWEqhooKylnIPLQOt1iJ7R+wLa3tqCsgsQXNq5dhua9i1A5eBb7blLfAaS8Wl5e7Tr2pZ9dj4HVpKpqf+MhNg8AZ9/zBJsfDP8B47wsanen3fJRmF948gnb+q5D9ojztffmXFjqBmcbSZ3+Pc+9AQD43QsvAgAiRXFEwv5NC9OZXCMV57jRtmt+92o88dSTvtuDIJWsj5TpeQaYP6LQPvXCIkyfNp6BWlVGzt3Uzu3OBZ+QybnSXm6xE+RUl33wsWhxMbo67ev4MeBuveYc/OpPr7NlamGd0PrBeeMVc/GbZxeStHQncPe8b7Blus4P2FKzEY1dcMHKi4I7ZNhoTJ11KZ5/koyCePYF5+ONl17GpVf/zPdY1WqbzbvFXqKwsuOMFBQxiqbm/QxOHtT161dg0MCRAExkNVLmDclRlFVUwjRFtLXlXHsKbltbI5t/6zFSF/2t+xbgsxXvYsPrZITG8hDxqiIlis2qUu1vPIT7f0+CRjy4AGB22ZvJCsVlqJg2Fy1vLQi8d17Dv3Vr3n3SmTQi4YgN0CCpmSRiEXdcx0/t3SSPh0JRZLMphEK5GpCbr52Hh5943HWMl8U9otA+8AeSeb9y5nT8++0lqKyI4btfJ1G2xlbyxze1m4AkY9v2Pfj63AmkGsgHXgotYLeAVLzFNXXyppA8RiwA7C6xlwRRhKplWXtRgEAJAPFY3DU/qA/w0t/twYhSsxFOzf/XNsw6tQL9rREMi6pHY8fWjyErldBUYnFkxV2e9AOWt7IAsGPpIuyyjCa1sh8ZY3HNVZegvCyO5Q9/H0dd+QsGr2qkrHIsLxO5TpDuR1to78pkexuKysqx7YU/oy2bwLfuW4A3fnotqmechTUvPoOB1f2wv/EQYmUxDDj1bBgbV6ByxrkIReydCA6+9axtufbMyz2vt++lxwLTM/C8/wEAhIuDB5LjFQSsmiGxDwpqd7rTE9qGRrc3CQBhrnx6xw0/xC8fywXXeIB5HTFoE4mUueC1DxmQVE+9sAjNraSrXmVFDFMmjYcSBsx0FktXbcSUSeNRVSagzYpQbN6dy+TOMq4fsLdccw4esqynbhLXuLMz5xZ7wVsIsIDd4tKyKwBoiRbQNv9PPnwFWrpzTfLGDnRXB23YT7yJMy76NmtQAXjDSTX1lDm25SGjT7Itq6obnXfeWITbb7nW95wPPPQErrnqEpu1bWqug72XMnnO1373Gjzx1J88z0MtLpUsBzfVS7a3Yf/bLwEAvvazp/DKj0n1i3TcsejnURYORcpw8K1nUTnjXDQvfhWVM0i5Phr2HtDNKUPPYP+//gggB6qfnAC3tzXCNAQ2amikiGyngOZTV564ALtuLI5Md8IGrpfF9ZIT3MO2tDTotOLTNQCAij7VGDVsIP799hJ85czpWPHpGkyZNJ78TpmMFStWoqJPNcYMrWbQKqIO1foYkhNYqiBLa+oZCFIYogDomrtcK8lhX3Cr+hXD6G7BgV078e57L+KSK27DgmcfxMGGFog9aNUCACeOH26LHHvpqhtJB/XudBdikWJs3/iBbTuFNatrrvKsqhrYsZQEPnZ1AMNKgYuudkPb1p5AeVkc/3jyCQyeNIXcZ+VANDXvR0GjvTnkhLY7mUJp3B170LQUsl1pJFUBRYqJbKYbjYvfwrjr7sNnvyNtqAeecyGQNYGQ4LKw2XTODabbpAI6fBh6/lhGMpNBUTiMZCaD8j5VaGshVX6BQ/wCkCQZuq5BcjyLrkQHOrvaUFKc+1JAdyeJ48RKvL8eQCVLAN/YjgLdv6ovWpJJ6OkEYtEixKL2F0x3inh7vYoeb9rTaL7y2hJWc+Psz6oL/t2OasrjaO8kb7FhVrSN1649ewAAP5p3AX7x+Eu2bTy4mgecVJIcdsEbM5sw6qhRaGjpxEMP3m5Pb0qHFOW6zzlgNaxPZjjXD6qtwLRhR+PtVbl0Xj7vcTz3+DxcPs9ePgk5+k9SaAEwcPuPmOS6l9bmg6io7I+dH32A8jGkdU7b5q1QN3+EugGnMDcYAKvaAYDysjgeeOgJnDZ7iuOM7ufa0LIfNX0GutY7YQUIsDGfRvHZrjSKysrRkWiFYghYMf93GFjdz+Yqt2UTGHvBleyYW66/DQ/99kGEImWo378VFZWkjM4D7QS3u7sZsRjxWiiwqXQnoj7ly6RPCysgGNo3X1uACSeeYlv30H2P4Za7brCt48ENEoWTwl1aVo7qir6u/SicfuoVtE/89S2zLdHt2fk8CFinwnJwlMxLhYJLdcLoctx6+zzoKf908cBS+VnZQbUVuOAb1zFr+t0bc+UvVe32PIbKCS6v7rT3F9Namw96rl+9nERK/dzjBx4ikdUxJ5HGFjUx2uKMPNeG7lbUxCpcwDa07IfO9XSprOmP7qT/CICl8Qp0JHKekZoRUcT1Sd7w+jMoD8WR6SQjJTalRAyefbqnm9zaTKLEFFy6rixPjYKfzICGKLyCwG1s2I/Vn3zE4HXNj58KKJIvuLz1pfMAEImEPLsGxqJF1m/Oyjoh7hW0v3j8JRMA7vz+hbj/9/8EkLO2Tmh/csPX8ZPH/OvCegOu0AMXb8HTdwUCC8DTyhrct1qvuPR7GDH6aHSn3VHmS84/BwteJmXsp35zhcvCAv6weoFKLasfrFRqqgNtb7wIZYzdEuzqIKBuXr4dtQc+QsmFpDxZE8tl/IYWe6Ckps9ABqsUCdugjfq4ej+66Q784pFfutarGRIfKFJMqKIJxRCw85+5gFG4ZAALRvEWlwLrpeJ4KWRuIAHNcHbk8H7Bpg0DYSl4hIggYAXLKDS0NKGmTxUaWrhWdKqOouIoRFGGYWhY8tF7mH7KbCz5KFffP/2U2Z7ndcLqZ20puEcE2if++pYJAG2JnGXRtcKsbFgOIaNlEZZDCFvjI2esz0d+5bTJeHfpakQjEbR35s5dVhJDe2e3zco6h86kwSjTWb5Jrcf8p91VA17WVU/pUKIh9K0pw7ev+RGiSogNh0MV8GUIJj+Ly8PrZ1kBf+vKq20zsbS7OoD+h+xD0JSdT9y3zn8+xaDlJXa3w5C8rZDu05+UhzfV2eYJs5lKIhSOsTItAOz852MYfuENzFXOdB5AuGQAcZPP+Q4QInmAh/b+n/4ad96Ta3tc7NHJnFch0Gb0tCfAgmgyOHktXPgSxhxzHDZvWo8JJ56CVFc7Nm9az7bTbfQXACaMn4qiYnvRIe140ZeW2f83L2CpvNzk7lQSd976k94Fop56ITcESUNbAjXcSHbfu2wO/jD/Tdd6p6ZNJG05t+89hJGD+7F5Xg1NraipqkBHwu6ipQpwjQEgcWgpFr//Hur2kKDX7fc8hAd+SsbhpeDectsDAIDSYndZjYc2mXAHyCIxt+uWz01WfQa1am0+iLfeeAlnnX2B77H89kMvP4qD/XJRZx5eCi5TurBoaKStEd1Rf0j8LC+1sErYYC5yUhWw8y0SeBt+1pVY//ffIlYWQ1GmE00pkVX9VFTW5LW0TvmBSpX26L7phJZaWR7ahQvtcRSAAArABi0vamF5y+qE1SkK7123/RT3PWhv+cWD7AVury1tc2s3Kit6NjYrhdQpJ6i8GppaEQn7h8S94B1eI6GhpZPBSUGtHVKNS664zRNOAC6r6iUvcHlJocKbsDX4jG/81hvujMOD/NYbL2Fcpg4H+83BGWfPwpB+NfjTnxeg9gBpPqiL5KVRdv4NzKqK1vhKKaseMmq1/mnv7EA4FEapT/1kd7QUEav6TLLaTDcKAvRVq7G/0f7cYmUxdLd3s3kvPbt4Cy48vhZVUQOl/Ydgx859GDw7N8xNOOYf1BE8PqNRGhNd7jKVJLmf8+qVuQ7o53ztfLz+Sq6r36SJx+HWm+/Grx6+l63rTlqDmzcdRBXX9a8rEdx312lxATvITovLi5Zr/dQraH/+GCnT9gRaP2ABb2gbHJ8A5MH1AjUqh5HSMki0JzD/93fg9nsewsE6Ug3Vv3Y8avqUIJ3R0NGVQmlx1PYLAKGw/5ubB7WtuQ3lleQPl0JhNFuDFVf293dznHr2aXvPEgokhXXWTPLGXvT+e5g1c7bt96yzL8Chl8lX7yQjhroBp2BYKZDe8iazutTilp1/A5BOMmCdSmXSiIYjaO/sQLXP8x424mjs2vE5W9ZL3M0XnWpc/Babr55xFgBg6zukuWB3ezemfPd6NC9+FelOFW1Z66sFE09GOFaOTHcbC1I1LyajZUgnnIXRI0jXysmTj8fKlesweTL5bs/8Bf9EqfV9IM3Q0Z3K5eftm3OWceSY47B983pMmEw67/Pw8po08TgG6ofcfUwYPxWpTCcDl4e2OF7iCbHo8aFqHtaO9lwUOR+ovP5j0Hpp2sRjsXTVRtRU5frSUnfYCS1AwE1nCGSm1SE7KofR1bQZzz73GO67/3doaOlER9MhjDqKdCZoaOlETZ8S2y8VhTYUlnBg107X9QpVPmAppJfNORvz33wDJ02dCY372Fg8KmHR+ySAMWvmbNx1+32474G7PM+lREsZtMde9RDqD2xC2xsECGXMKbYyLrW0XkpxljUajiCVSXta20GDCSzfvPYW/O2JhyArCjSf9rMfPevdzW34hTew5oxUtFkjAGaxf/7yO3jy8V+5jp85+0oMH9UHapI887/85QFcPe9WrFy5DooSwcbPN+LYo4lRGDliOLbvsD9LzSD3JaMYGuyxBN7STpwyybN8C+QsrlMU1oce/D1uue37bL0XsLwovNQVzlfNw+uwAlFULVxAih6mG7qrPJvPPd5TdxBDasmbzAtadg1JRN+KMsSUTtx1J+mxccXlpAzHw8qro+kQSqv62dY98NNbcPs95DOMTQf2AAAGDBtuA9i5DAD6/k1wqqrWeyibQjT/TdJ4/aSpM7H84/cxa+ZsJDpaES91l5fXr6tH/0PEqlILS0Utr83SAgxc3jUOJdqRjZfBkEJItDcxF3nYCDKcKW9dnTq0eg2qZ5yFre+8iNFnXBx4b2tefIa5zbzLXJSxPx9aFeSlq+fdyoBdu3ENPlv1Lq6edyvWrt0CVU1DsQJ8qvXNI8URrafQAsBlF30T8//xNwB2YAECbTLRilhRjEHKz/MuMoU1yMoaXAsKHuLSsnJ0tLexr8yfOvs8fPjev9j2qj7VaGppRFUfu1dD1/UK2vusKh+n/A7hgwbhgC/qRSMRZmWbO9x1g5WlUUTCUWZZAeDCiy/CCcefinffeQGnn/F1tu+2LdvQnT6E/rWkY3tH0yG8sXA+a/EEAJdccRuaDuzBgXX3Y8DxdwLIQfruey/i9Nm5DHlg3f3oW2nvNseD2lRX57uttKoaUp6mf7952l5VNHniJNvQnJ1Wc7ndu1Lof+hN9Dv/B6yRBS3DUmgBYm3Lzr8BmY4WRK0MQ91hAEimUuxj3VSZbAYTB5FePPv27mAAO8UDvXn5YlaOpRo6l3w6RLI+xxEPR5l7zIsHt2iq97A5V88jDf3VpAilyGCWeObsK9HSXsfcZad4cHlonZJBGri88spzAIAxY4YzOJuaSBSfRol5ea2LhnONO0RZQmlZOYYNHQclEka8PI5onua0LL3ZMCTu6xmnTBmLj7hB8aafeGzPx4gqVLIoeQYJTp82Ae8uXe15jB+wANDckcKr82+yrXvyDw/iBzf1QyU3ROcjD9/N5m+6+VRs27LNZmXr9jSidkg1gxcYgQEA3n2PZKwxlTsAjLBZVApsVW0tSqvc5brSqmrsWLOawcpD3FRXh5aIgqOqvN3og5kMJk+chJWrPsWkCeMRL61gkHYmOlASL4Vp6oiXVqCp9VP0B2lcUXvgI1JPu5kEoJQxp2DMmJFof5m80LSONkBXSbs5SxTcImswsZTDJd63l3zMqjtayuBsFATEIladYToBCAJCoQgiYjGGzbzI8554daQz6HvKuaj/iJRRizKdSIZLUDLzfDR8/C5qphILq2e8XVBqZSmc1DUGgLVrt6BPGfnPl636gLnJvF5/5WV87QIypCsPMLW0kyYeh0kTCYB79m63osTrUVU9ElVVUYw55jhmYceNJ8P4jJt4JoYPG4NERyPipfnL+daduNZoWTfI7739nG35rp/8EG+/9Re2PP3EhzzP3itLC3hbW2d43s/adme8Tzv56DjuuvM6tLYRN6+iPBdFrKwsx9lzc52T31g4HzNmzsYJx5+Ktes+BADEIv3wxsLcF97q9jTi2nk/RGlVPxZVplaVggsAx02Zgppi0tG9oYtEevWOZlTr76KhlbyMeJid1hYAWkrcY1/JDgunWxbHNMk5Ba6/5spVn9rc5Uw2i05r2FXJIJYsevr5SL37Mkou/C4DtngW+U90GIjKErKaNZC4ox7b5J6NYOgwRQnZdBIxJYJuNY1wKIxMNoMYZ7nUgK+9mKbsWPYewtLU3VVQTmh5t5ha2avn3Yr5C/7JAlMnHDseazeSgCPvJv/7tZdZ8InXhMmTWRCKjx5ffsUN6Ey0ozNNypZVfSrR1NLM5oPkBW1bq72uPe4oKibaEoiXx3HGtOl4ZykZLGLz2mVoarH3FHO6yEAvy7SFuMepZBrRIuuLbpbFpfAmUt6WtCgcRTKTsv2+Op+4ras++RwTT8y5a1dcfgMe+Q3pvvaHP/wV27Zsw959a5nFXfz+e3jrjWX45a9/zI6Z//QC1A6pxoyZs7H4/fcwY+ZszH96Aa686jocqt+CjRvJAz722JzbY9S/DLHv+Whu2Ymxx5yNgwfWwGwiUUW1Zi6iJaTcKejejRUe+MkvcftP7rCtUwQdpiBDy3RAsD5cLVmulZ7xrkowTR2CICEUiWLp0o9YlQ8AjB5TgWw6xVzn6IyLAcneM0SCCB0GTNOALMjQ1DTAtUbLppMIRYqQ5epzY0oEsWwK3VwvlG41jVAoB3BEzHUYThtdVlqDwfUClty7HdpvfzvXRtwJbbp9NyJlZESUkyeehpb2OmzdQbyE+/73bqz6LAfrgw/ci9tuvxufb9sEGcUoiede+gcb96F/9SB0JnIBOy9w6bKX0t1uD0GJBLvC8fI4Pl32HpJJ/0Y2uevawT1i0Ca7idtx/23fwp0P/pWt58Ftbid/jHM0+V/88BL86Nf2Vks8sACYlXUl1CBh86u/dxtiEeICd6cPIRbpx8q0tOpn/tMLcNmVlzB4qZt87LHHwah/2fP8Dz/biAduIuel1rWmgrx89itnMmhtafIAWPFpLWb6jFLghNc0dYSjOUCotfVSdNaluP/uX+HOe2+F5PiavWaN6sx97AAAIABJREFUjiALMpuHpiEbMErHr+//A358DymW0C8dGqKAX/zkEfzoJzdZ6ZMhCJoLWLItP7RapguC1WXQhIlr5t3GrKyXMnoGYSmMjJ5BwyF75LWmX86q1dd3oLOrGTBIunhgqXhgX3nlOcyec57nNZ3Q9gZWqpXL32aBKO9rVSMWjaM7lXBZ35/f81DvoG1sbUVx2F23lNFUhK0xkZ3zfnJC7AQW8If2pht/jEcfuQlXf48Mz/KnPz6Jm278MbrTJCIdi/TDE4+TzsaXXUnKNYvft48HRcqwwaqpkLCt63iUZu1lcXnEt3yPEdJWNDPkXzVWCLShSBTZdAqhiD2YRS0uVeWc76A7m3WBystpYV1ptmIQcsAH1PzcYy9gyfpcevysLEDABQABAiJlQ/GN8y7Gvv2kve+yVaQn1MkTT3MdR8uyGz/fiJMnnoZlqz7A184hxZb6+g707VuK7dvISJ0U2s5EOws+fe1rl9tgLYnEmbUFgi1sJBZj8BYCbLw8bosUUw0ZOALdqQTGnHAyOjvtMF8wZwpeenMFWz7/rBN7Du2NP3+SbXzs7mtww725ztOKpCAsK+jKJKFI/m8SqrJ4GZKZnLvsB6xgtMEU3a1IeEsLAM2N9Rg86AQGLS8Ka+2Avqg7UI8xx4wGGkh1C3WB93623DOdx552IYb0Ox4H1t2f19La0mdZ3Z5YWqeVdcLKK5sm/50SiUG3xpgIgpaKWVlnejIpqNyzjzmqT3TThCF6U9tbK8vSxEF79bxbsXNbboSNlvbcy4kGnlra69CnrNa2bczRx2D7jp2sXEuB9NPXvpYbFaMkXsasbiQWsrnGVDzAXpbWKQqyms5AiYSxYslCnPHVbwAgZdiBQ47F2tXvAwBOmDATa1e/71mO5dUr95iH1pVISUHdEgJd35N/agO3bsmdqJ1+P5ufPl7BkjUqhs8mljAejeKlZ/NbWAoqAJQVRaGbBr7x7RvR3FiPyuq+aLYGxablW345FumH3XtXorO9AyVlpQxaAOgMT8OOtfavvVFNmPktiMVFSHW2QmlYiGZhDEqrh7igFdJpmJEIs7K2/4azuGq2my07wdUznbaglNM1diqbTkF0gG1aUWHBquKRIBIry0uWAS0Hr9NF9gKWygluIVbWtt4BLwWWJS1cjFOnkyo8amUBMEsapO2b12PkmONcy86g1KSJx+HTVWSd09o6xZdvS3xeohGPMZ8/XvwagxQA3nmNfHEibBUbly9yN1n1Ex0Ubvny/T2H9oHr+9s2xkrtFtXU9qG9qwQbd9kzWqI+gXhfdweCsWc/zqzrsIp27DyQy1ztAX05qcqKojhtTv6qBwAwTLubLgo5l8bUk0gkuqAaxNIZnEtfaW6GWuMe57ZICWh+pnD3qrpbvAg+FpECa9vXgpcGo6iFBQAlpEC1PpGohBRoPl8W9/2QGb2u9ZkO1TQRkcOQBMEGKi/d70veXH20rnZDUmLQrQ4UQsAohoAd3Gvm3Ra4L0CaMALAZZdcyOapMl11yKoqQoqCrE8LLravRzBIzjMEDADs2v4pm1eTwR1YDL3Qkbbs4kdv1DJpyOFI76D97R2Ca6MgD7ItL1lj/6MS9QmcPbcPrr9vH357l31fXk+92A5EBFvlsm4atmUnyPmgdYLqJcHQIUj+AGZMu5UqUoqQVJOIeHz0S+Q/VaLEPYG1XdsDXlove9ft9+H2O7+X29cj42f1FGLRONSsCkEIqI8hifNcbeoqRCUEg+s0IXHd9+772aO468c/QNpq5qf4AKib/pnThAFRsL/geVAffugZ3HzLdwAAqXQXopHcS1/0+a6xU/kABbwhpWpus3fiaGt2f/aDpUkrDMRkMhk4PCvbzyftmqMu/dM1zYcPbXtXCcqK3VUVgjwIprbPNu+E209L1qjYtj9pg5VKNw10pjIo4VqYdKYy+NoF7lH7CgEWyFlcU0/a4OWXewIuwMHrAa6upiAp0R5ZW8DfWikhBaFQGN1dXYHWNmtoCImyC14vaAE7uFRptQuKSDLhL+/7He6467rcfVnQ/ur+x3HrnfaxskwYECDC5MZ3NLJuC5Wy+hpTaFPpLsQKGNLFC9hMsgvhomLbLy8npFTJhP15ZbLe+agQcJNJUhSgw7M6Ac4H66q1LZh4AqnvN00dq9a29Rzae6+L+24sK+5kEHe3AbFysF8AePYfwPDRudZJqYyBTTu6ccyIGKJhEWNH5AJIL70Vx6gRMew8kLZZW900sG5DB44fm2vmJwmip7UtBNrO9g6UWuP2+kGbMdMIGQayooiwYHWsNtO+wDol+nwo7EhCe+89j+Dun5IqGF8XmTu/wMUbTN37f/KCFvB3j/NZWqe8oAVy4ALIC+zubaSxxIChJ+DA7rUYMPQEX0h5OYFNJhIoisddwFJ5gesFLYW0qKjIthxkbQuxsjRP9AraB67vb2ZN95+hqMTaqkoJm3dq2Y4anHFSmLnPNBgFAKs2deI759rPS8FdvfkQykrJw/PKGJIgYtIp01Ac6+faRsEVBcUFMQWWBkYEqcgWJKHLWVFEyOpYneWsVD5oRTEMw8jADCjTyIo7gEEfkK6lIVlfpw8qEzrr/IKgZUGuHkKbVsmziSjFntAGAQsEQ5vVNISsqqiUY1SPWHE5A7PH6kH/ZgBo2nsAVYMHAAh2jQE7sBRMXstW1uPkyf49wAyfjvxOd5gqH7S9anucsTJVWO1ERpAQNnX221NJBqCLwMVnJAAksG1HHHpKR2c2gbLScpZBJEGEbhrQTQOffrQUk06ZBj1LMqMUIhlRzypsnoruE48Xo6OtEarRiT5l/VxRTbrsBWyhEsUwdN1eDpeUKHTV6mYIg80DYJA6553WVzWIK2uoWWS5Bh10bKFUqh3RqL0xQSrVjog1amGquxWRSAlU04RilYXT6U4YhgbFGsdINbJQ090oKalBRClGWu1i8OoZDZFoMdIpf2smRyLQ0mnIEXIfmtXqiR9CNJRnnLBeAwsA2Qw62hIwNAOiLMLQDJQPqEHbATJShqa5Xz4Nu+uQ8WlsUlJehs62dpSW5IKMLa2t6FNRYQM3nU3j5Ml9kc76d1ZwDstKRTtyGNaLkQYh86kgS2toSYhyEQyNJJafp8DSeaplO2oQDbsz/s4DafSvDGHyMQ24+7fA/d8n0Dq/jPjiO7k/q9PM/bG0fNuZyuD0s7y7ePGi0FKpRicUsYTB66X2jiaUlVax5awoItnWgIpK+8eMqXXll3koqR568Bncctt3XOt5UAFibel6XUtDVmLQ1G4YHi8Q51i5fha3kExARV8OTtFyLUCsrOoxpA0PqxyOueaNbAZZBzj0fqkaD24vKJ0dbW631vBwXzVNg+ExHA2VF7CGYcDQDYiS90vb0A14hF8C5Qdt7pzez67X7nFaJU2r/KAF4LK0GUHCipURNHV0Q5dI5qqtjaKujmToGeMTqLbqrnXrDwj4nCmTLAo4thZoEmrwyJ+SOGryUSgrJ8NwellZKie4VLTKxykpz4eRbGkK5fbV0hnIkTBKYsENz3uijz98E6omYs5Xvx7YgZoGlqLRMrQ0kUYIzpeMn1Qji5ZDewAAZdW1kDyKAooYQTrVVZjF5doWy+EY0j4dy53QUve4oy2BISNIL549O9wfeublBSuVl3UFYAM5o2V9wQ6qvukJuEca2sCzLf44gRlTq/GPhYcAkAweVsDm40UxJKwHMnAYCfAk6hOYMjmNeN84q6vtHz8EIIHhVcDiNXEGLLWmF5+RQKPVKGXxmtw6p2oG1YAObnnJWZ0AcvVny5tOQM2AAZ7w8u4zb2m95ARW9bCcNhnuAE5nt7uFzeGCXAiwAHGLi4qJW5xO2+/RMPzLv+FYFCWRCKB3wZTsA6zpGQ0IpyGF5UBgIeg2YAH4AgvkPAqq7q42VPcfiY62XBPSIHgLAfaj5ftxykm58Z69ABUtT8YwDIiiyPZxWlsviCOhSKBrXIhESfYF10uBlnbqUYL51dOJC/nau4cQL4phxtQ4/rHwEKpKidvT1NHN5qdMTiNs6vjne7nIMQHWX4++APzg60B1ZQ7i0bUJ9Mt5pwzkm64pQpXZgKIIsZx7MxUYHM6NfLFyu4o1rWT0/rLyGl8LC5Aybkv7IeYit7STdFJo88IKQPGIuO7evRNDh5IO5nIBbVR5mFua9qJP1WC0NHl/6b68xvtjyV1tLQxUKgooHa83nxSPAbUBC1iZvPBT1ssoGnZ3QwQAWE04H/31fPzgh7lulJqHh97Vbc8X0bA9ctx4cDvK+7irDXl4/aAtxMJS+bnIbL4Aa7tmXTvGH+/uoMCLWlsa2KPLFNZi69tDajb3kvv4k17U004cLphhBVi2Ffjldf3w2rvkj44XuR9wU0c3LpwNz/ItlRaQh196K1dGmzE+gdeWF2PSCPtbfWtdHPdfTaxHUURBMq0ygJNpFU1CDRa+WQ+h32TPa/CuNK943N6iq72jCU45IW7YtRMqNz4zBTWfeJCzAVaI14b1W6DIBo4aMwYAoFjjLhWXE3h4S5vsylnXiM9nPagee+RvuOGmb7LlRBu57z79htj2azm0B+FY7lye0AaMhc1D64SVFw+umsmgrWUf9u7Ybdvn+BNPBQDs2uI9zClQOLR0XO5UNm2ztgBYudYP2sMp19JvBum6hkhI8uxooma7ew/tOadLiCjVyJpdCAnFeO3dQ8iocFnapg6SAcMK0JAGxgyvwaYdwZkybgWqRtcmsLXO3ewxkTEYuFvr4szSAsDGOuIuUzXsy42nu3qT6Quul0piA5nbHI8Xo6l5Hxp27cTA0ceiyAI9IkloOLQTihL1tML795FyZD54C7F6zzzzPr7znZm2dVs2b3ZB66d8sPopJGr4+/P/X3tnHm9HVeX7X81VZ7pTBggEZAgQCLMCEURwABnEljY2CjaEIINPbFRo1Nc8mqdtq4jiBIhAREFtaRxoBdtWQGbFoAQIECZJSEhyxzPXXO+PXbvOrl276px7od97fj755VM5NZxT9wz1rbX23muvdRv+buU58Ow2HLcFyxhD1yFDIk67i+HRbC0gAIXQAsBMo9jjAgBTJ265z4yTisClqg2Jx3VF0BZ1SHUZ93bNn6Zw6MHpOPPX2rZduGAHeK4LTdfhuS5814Wq65iemUpc42qJGI4mM948p46oEw6pRMccSS4QN2rhoYfCxD02NMDxCKRjOy3E5r9sxaI39CBa98JWRFHPgklSC1FUyTzSY6tOJu5x023g3UcAdzxMjrHW9tD9JBy2hFhYCi0LK3uMuslFmt74KkYW74jpjeSCouuvTJIUMIe+ieSdWhNXCgSA40/+INY/vRadVn7S7X7addddAQCTW7dibGG2WDQLKK8n1j4DADj6nSegNZ0eXyxVqilLS7f5R7NkwXHJ92rolWQdIGDWRkjbhN0vkmVmXcJB4OTltAmkw6ML4AmKaBWBS8UCzEM7KLDJ8wsgnTefNGfazRaqlRpCKW7/chMmZDVLs+fmz2X2fD/lGjvuHCOiqHtMVSv1LCoVhZcFltW6F3oXN4WVrtcMGQ2HfOhz3t3CDf9BQKUWuOk28EbOcJ14QnYQe+uGrRmrOwi0IlFohywLey5biq1MhsaFu++BqaneFz86qifbg0LcbbdhxbNEKmZ6yGd8kkC4z777JkA/s24dAGD+WM8l3byVzH465I2HoTIyloGXim3n5ll4CqbTzm/Ds65x6rXtLoyyRSzwgsWYmd7IHU93CBplLbP/qKNPxgP3/QIAMDSS7qxjLe6Tf3oYfs5Fr+rpvoXhEWIpDW6/47oYnxiHFWfkoMBauolytWdg8iZPAKS+VAQpVWdqEGCp8sD1XTexsoZOmphzco+PO3b3SKmTIZ8G1/5ymN9j/lAZ2kjvQ2/+C7mAKcgsuFSsFQaQAFwTjO1S7b24gUP3y36OZYuJu3zYkl4H1V1/3gWHjD6aCy+1riI1O8y4cKn3w++89zIMje6K9U+T9tReSw8QrrPKg7nbbqdALBKFmcrzZeyy0wJs2JTOdHDIGw9DqVKFZgyhPvkKhriylkW/NQDAJedr2jbeeOhhePaptfCjcso9TrVty/PQbU/AYnvGBWUytk6IK6YfdfTJqe0nnngk8xwRuDykALBwYfpm7rhuBtrpqWmUKuW+3wML7W9++xze8fYlyTZfFI4HNtmfA26n04EWB5mIbkKu34Wml+fepj3u2N2ji1a8ihfDS/Ddr/ZKKLBtWCoK6FPPtzGitjL7qIXddw+yb+PGLhpOmLjJPKzUAgPIdEi5Q8RtPenE98LjXB+360K3ej+WJKtoTryEyuhitKY2Yv1LpLdZ0b2kQ4oGWoxPbMDzTz6NereLIcvC3593IR56sJf9Yt5CkhFfBGfyPSzKafMxen79GnSZidXzx8YyYIqAphYWAP7y4pZk/ei39OaUbti0LQUvr77gAgm80BfAL5jMDkAI6Uw3e6PirS4VCy4PLQvswYe+BQBw969vxaYNmwrf0vDIKAxdx89/+QTe9c69U8cG+vyxKLwi60olgnYQS+v5PqQwTGoD6/FUx2anhUqlVght4TjtijPOB5zLsbt8JUZ32Q2mTH5AOyxh0UgHdkgCpV986SUsApIIKNbyEitL1imwAFLAAsQVzrO+jz7fc5t3W7YnjnvXe6DFvX2//tXPcfxxH4SqxpkdykweXN8CQqA6vE/yuPwIBa7T6zRJlwk5OGm/1uOkdG8+4njougk3aGP988Ri7LX0AHzli9fhE5eKa8YCQKueTcJ+/XU/xrnnvx977nVosu/59WswPjmJffbdFy+//DJ23XVXPLNundC65mnDpm3YZadeFoSJV/+CXZbsD8+pZ8CVJKn/hasv6IHbT2Z8g2TgHbYETaXYQPNAU9f4qKNPRn16Arss3h0AUG+RcWkW1rcdd/pAwALE0r7npP3hxJBQqzs5MZlyhYukSBLCOIw2D1i+TWu7NkyYGXBFMcus2MLebNtWpEJL+81v/q/ojttvwSl/28uPZFgV7ORcjhfDS7C7fCWuvo2Mc64443zcdst1CdisaC8ytbZUPKT0OaL9AIH2vIt7pRGlsIxIbkOTZQIogChO6E2P0XVV7SbPocqr6/OTn92GU/+GzCRyXRuyoiHkAu1lRUMIptMkSP9I6196WQjuIHp+PQku2G/pQcm+P/7xQQA9eJcfsRw//MFPcfRbDshAu2HTNpx19oWpc1rDBvxO77d+7plHCJxUjHVNtvV0OpRcq8tZ26u/fisu+tjpwqdSaCvlHbF0n3QS8D+tISlG//z73+Ggw9+aAMvq+zd8KbWd5y5TeKnGJ8hwlqWbSVt2XpxSZmJyIlkXbYfcBImJcTJePW/+PEyMT0BWZIyOjsJ13CTYolQqodPpZGYAsZLCEJEs50I6J/f4zmus1MGm8laMe4eBgmxYFTjdVgLyJuOKFLjrXtiKffdYmPQkFwF54KF74fE163OPAcAxbz0BuqXD7bool014YQhNljMucuZDhoPVIqIQX3XV5bjwwk/DMAw4jgMoARBwgOfFXQb5FlEVBMw/s35dst6Iy648v35NClheDz/ycApSXvfdvxb//Ll/gSa4mEWSlQ6eZco77r/PkXjimQfRtG047S7mjTE9s57es66A0D1++t5bsfSYNLR8u3aXxbtjv/0OTO3rdhzce9+dibUFgF122zcBlQJKH1eeQ6olmpYJMDOLfvLjm1LndVwXrUYT5WoF7SYxHGwnFN1mIQ6DEKqmYnRkNIF2YnwiAZX2IrOaZHJNVSvZYTkpvk4jQSy5CNw5j9OO7rIb3r7Mxv5LSXuKWtbZ6IUXs8EKbM8xVR64FFpeJ560Anf+8jYcfyKpRhfFPaTUyvLWlqqocp4btPGNq7+E3fZYhpNPfDcBllegQGamu4VwIMPoWd6AzgeOoHAZJkTg5pVwBEhK2tt/fDPe874z8NTjJGzz+eeexfjkVAJu1/ax55K9sfe+b0y9VgSt57r4yyuvYOmyOGqrI6PhNPHySwTavfc7ALJRhupLcIMWnn1qLe79t9sAAGOjwOQUeaSaFDgTY4IceKd85Erccc0lWHrM6TAsPQG22el5MNWShvvuvxtHv+VtaHY8qIIpflQEVO6zxR3kmkrWNXXw1C8U9LZtJ7/ZRAxh3hAQDb6QZECSZESMRRZBm3qvce4w/pE9Pqc2LQC8fZmNNyw7AAhIFv+LVryKTcYVcApiUEV3El6WJR5GeOuxNqSw/4R22tl04kkrINGMg/Tvyl0AcvLIu8WF51XIF3fyu08EAhALKwA3cZdji5tyleN9Cmd1RcD2lSzDMlX8+hc/Qtf28Z73kabK+OTDiVtsmSoefuRhbNr4At52fK/OER3QT06ldHD3f5IEY3sv2QHPPrUW++9zJEojZfzocwTM004Hlh6yHL4a4YpLL8Npp6/Alvjr3bKt93j55z+L71xByrKMjQLT9d5bnq4DI0O9x8kpYPXnLsHYKLBk34PwwH2/SKCtlno3v6eeehxjo2NodjxseGkdJqcm8aZDj0x9HaZlwu6KY321+Oul8LL9ACKAPQbGd//tWcm6m1O/WJWKU+HYviDJX05SBKo7fnIjeS/ctaGp+QW/C+ka3WU3/PbJ7B2NAmtYlcLsgYPow2ens/KXKyYkRYeUk0mhVKnAKJegKnoy19aHjEhSEUkqvDDMLJHczljXeiMd1O86Aa666nJMbn0Ku+2xjMCrBGlgAyXrJgdyzyWm6+y+WHMCFqQExnEnn4YNm7ZhfHIKqqxg08YXMH9sFPMZk7b8iOV42/F/l4TL9WJbyVQzz3Vx189ux+5LlmD3JUsSd9gvke/w8s9/FqedvgJ773cAQqcN1U/f5C//PBk9OO100tb/96svw0h8XU1OETjpEga9fQDAzwE/6uiToZnZ72O//Q7Eho0vwoCDDRtfxLvf/RasvuHLqHEx3EVWVjRDkQfWC8IUsCLpupVZqM499+Jk3fbtZKHy/ShZuq6dWnidcuoqnHLqKvztaRcky2lnXIjTzrgw81yqwivpohXxWGbQG9N8MbwEQeihxFTypuBSmElXNqBrOiIp+y2yVvY7N30hdazbdhBGUWJtJUVHFLCxtT0Lr1s6Ol0XRrmUACzJKne+DiqVCoLQRjdOLqYbpD1Cwa3gGTS7I7jow+/ETBd46YUncdVVvcD03fYgM032WnoA9tpt19T5qZscwunN6OdkGOK7bRAEUBRx8TIAUFUNnmcnbjEAnHPOJbjhhitx3bVfxfIjlmPTRhL8sWnjC9h73zdmMk3QOFfW4h504FHo+o0E3M50G1/83GUJkADgBsXRUPu/cwV8pYKnf7UaT20D2AEq3n3mLTEAzDQbKGslTE6le8l3Wbw7fnvff+GU496Lhx58HACwZWYSW159BTvsuDM6dgtmqWeFSoYGIEysrDbAvVHjZu8YZrHh2TaeHtP/+jf/N2y3A8gyfL//ENInPnYZvvJ1ctMTgQv02tYAGQ4qUt/e4/naH7DFORiKrCWwdtrTCbT93GTaQwYQWLvxUArvHnfb4hxCUeDi3t/dldp34knFaVRpnqnA0wC1d97mRC8Ubtiaxky3d+P57i0/xic/eQUA0hEFABdeFKf3pC4yZ2XZXmUKryeYNUJTlBqalsxVpcAGQZCCVhVkI3x8zUMACJi0/cq3awHStj3pPeJeW03XoesqXJdcEM89Q8ZE9+bKOPK64jME5h/dSt3n3vrln/8s/v3qy/D+j30BP/76p7DioyTXtWKUYVoKfv/Aw9g68UoyFvvAfb9I1mXNg91MR2GZVQt/WU8mwi/cYT8AQNki300oK5DDIJO6pcSG7CFEz3nkrKsvJxZX1croctMWK+UaWu0GIClw3XjsVLeSdbbAtqmTHmHWupqqKXSPgf4ucp7OP+/iufceP9m5ECMj83DbLddhxRnnp3qKV5xxPprN4ruyrmVdXTNuy7Rb4g9KLS2tBC/F7oxRLsG2bZhMCCBNRcNmdJSYzPq0TUtd5HpjAhU8k0CrWgsxVCPWV4oTUG6dTFdDG65kgx3knMoKPLglMz/Rl+O5MDQdjucKgdU0E3985O4UpDst3gPf+NbtOOG4ZbBMmm+JwLzsoDcncOrxBP12q4NyJZ02locXACYmpzFvbAQTk9M48ui3Zt4LtcwUWqrLP/9ZXPGZy7DIADY7wH5Mx/bosrdi6knSH3LQCSuxy277YtTUsGUmbWE/ftFnceml5LjTJdcqBZaVovFtPxUdx4Om8Ne3Co8bpqtVavC9dpKrS8m8hqjVacN1u4lLTMFVJQ3grHQpntI4JZgZRv7mKKZmJjE6PIZupw0rniHX7bShqWrKqmpcE2rVqotmD+3Xvv7pyPUAXSMBzMtK30iObTKIVeoHLBUPbhAGUGQFAecaykxvawgfiBT87p47+lrX2WhmnLiUw/P3wNVf/dfUsbPOeD8CrRcI/6mLv4wvfPniFLQ8rNTa5sWslkwTnbgSgQhgWY1LSggqnFNgWVFQN2zahgP3PwjTU5sTaPfd/4jM+U1LR4D0e6ZNfNvNxi0/+9TaxALrSgVu0IKu9FzIEDLCeKaTrGU7+UyrOAmeZ/cu1MmpSYyNjiXrABBFxP2VpDrM0hC6bQIwD2zqnEH6u7/g3Itx7fXp+q6l+EPzCfZYeFs50yUTcNWe1aTAnnH6ebjl1m+nnu8HBVMV4yR3uqanOr3OOefjuOGGrybbc4KWHafdZFyBnZzLcfVtO+IdJ70PIyPzEmCr1cqcrG0RsFQh8v17s8CCsSpyizPvSRvGwrFsmhYnnn0iKxp0w4ArmI0ikmFaCP3i51LYNS37ef74yN3Jumh8lg2s6No+Tjn1zMw5TIu7YTIAU3hdyc50PokU9qkfZFoK2jMNeHHbfngs216k0PLtWd2swbUbGWjlMMi0ZalYC8uDqylaYm1r8RCDVhLcAAAgAElEQVTM6R88F7f+gNSk4i1tq9NGpVROwK1Qq8jlxNK43F4iK1urFNd+8l0Hnu9nrCurPGgLm+3ULZ6ensAyEJd4BVc8rhqHhClyr3Oq2WwlkLqeKwSWSpEVeG4TsloC4MdviYKqQoYqBJcCS13j5Hw0Z3IoQZEjoPVHDHPGQBWF2SV/EZipT2J4KO0OG4aRpCJ1HSepAEjdcMclNyDPd6GpOgzTQqtVhwErTtstJRYVAELfSbaLMOjEs282b96A5Ucsx4EHH4GHH7gn2Td/bBQjo4swPbUZlqmiWtJTEx54YIEeqABAIzq7TXKh1gYM8cuT3Q2gGGV4cXWImcn4Zq73fqPhOMPhDovI7zDTbEALACcEtrz6CgASiLFktz2AuKL7lldfwe67VZI2raZIAkjJNe4FEYZrw3CdJiyrhna7hZn6BIaH5uFb134eM/UJVEoWZupdVEoWWp0uDLMEJ4bTdbvwPQ+ddjrFT7U6hGazDqDe226n28ZSQN5Dsz6N6tAImvXp1HGVY0HU6STlFD5LjhdZ2i99+R9zD9LpQ3kytRK8sP+dG0BqUFokCq0qA92Wi+poDfBdqKoKHzIQCd5L0EVVfgKduH1UZF0B0hF11hnvx3dv+bHw+FlnkArygTaM768md+oPrTw3OU7dZ5GLTN1j1k2uVPLH4Vh5no3bf7Qaey7ZGwceTFxfCi0AlMoWNm18ATst3gObNr6AU99Hsj6KwFX7VDeciduZInB9L/Y0Ync49LoZ19jOqcc0PFbBTJMAQDufdhgew0wcFjlcraE9NYPbrvknnPWJqzOvH29PY355BDNu9gL3uLzbJZPcEELu2vN8O2Mh6X5WY6PzE0vbaTegauQ7ox1R1Wr2d2u2mzBVM/HGWFFwq/F8X5m7PmglSb4gux8GOO/Dn5y9e5wH7cjIPHTa5A7C9yYD+dnk8yDOQstYWjn7Q6myDD8MoYqCOBQrARZAAi0AeMZBcBwbhl4CpBAOkyx6eGhMaGGppIILXuLLSfJhlczFcuaH/gdu/v63cs/FS1FV2Nwdn4f28MOPxk/+fTVGRhdh+VHHJmOV1ZIOj/kF+0EbBr3frcE1d0qmBlUzct1jFmIhvHr2xjxcrQEd8mY/cNZFOP4AYMVHPpd6zjnn/xN+fseVGN8cvzdZhoes97Bohwjj41witlBCtVpDGIZot5lKBuUKZurZ5Htjo73EZPwwDysWXM8RBwKJAB7iCl2zpV9FmhO0V1716eRgpiRjH0sLEGvLikLrueJMiACgaunu8X7BVaos4/wLrsB115JhGsV5EiUmZLrTleAZcRxvJMNxxUHvebBSFUELCMAFsvDyUk0oKp8LWIWi+rDb2aEjOkZ75x23YmSUtLs3b96A08/4MO65+z8xPUV6vE9930o0O25qLjAARLIGKfQwnVMOg1etWhGm1skrcUJn0mlcXLYnuFTsZjd2hYGDlqZjkNt2fv9IJ/BQUjR4cS5mTZEwf36ITkfsSTWbvc9ardbQbDZQLlfQbrdQLldgOy3YgnKlAHFTfc8TWldeefACgGmII/IotCXDEgKcB20hElEUJAu7D+j9QKJ1UyulgPVCaWBXmbphs9F1114OxXkyBezmqVHUg0Ph6YeknmsYZnqJx9xm6sWlIYrUD9gzV36SWFt+EYhCbJaz1uSGG64EAJx4Sm8sds8lvfmiI6OLEvc4T5GsYXh4LFnyZJnKQBkpk/OGIXSNjDTw0gKyAMCwUsKwUsIOw2M4aOmBKWDbbgftOGghWahkGfMXGSjFN08NLjyvifnzyfdcKk0nC6sqUyGAABxipj4Bz7cxU5/IBZZ8JnItuYxbvvLMf0g9x3O8BFg2Ugog1tZxHNQbM6g3svWXSzHM/Swur7nF1iH94+StU2ly2pobZfJFthi3j7ewg0iWdQB+ClbqDlfH9kyel5vzp8Dy8goE2fcVmYAVSWoGXMWsIIgtxs2rrwJyBt5R0HtolnWhxaUilnVRsr52HRkaOvZtx+OC8y/BLd/7WuY1UughkrWk/Uo1PDyW2te1CWWWOVjhMYCAm/wdWU5tAwTcGfS+7+FqOqi+XKohcAEawVoyycXcbFhot9p44QUJe+xhYHyLh/k7aADE3k+z2YAcX3N82xaQM21bvl2bW5MXwOqbs98p1fXcEBONhMuztHPVwNCydUYkSUmsq64Bspx+U24QQc8ZuGZVKWdnQtiuAyfuRDFKxVPLNOfP+PBFt+PWb58KoOcKC4MeIhmIJywjnrBMqgOUoOoqfM+FF3hJR0BGguGoKOrti+ILiC2QRcFVzAoC34eiqggypTGQutuXKxW0Wy3msfcd2e0GTOY7W7vuWUjSC3jx5fVYtfJCnEqf5/spYO34b7LhvmxHWKtVTwErSzLCKITMBqv0Geph5YUKNHD1iJivVUFc2qVJvKoqjRJTVdidBijXvRFTD4oMqHoHL28ESoqGzXHsixeHW9IOKAAJsHQ9DHvb1eowOlzid7Y8Cw1LZMdjdT0fE83Q4Dle8ihqy1JoqbUdqg3P2rqyGviX4Nu0URSkrGoYdpOlCNiO3cq1fDbTgWVV9MQ76ray1mZEfQolK0qAbYb7o7rju7KBD34AsxwnOItkfOSCy5Jjfuz2+MwAd9E0uUHkcWUSlTiuVYktahB5yWLbNgKuuh8Flle71UqAtdsNlMoWDth3b0SRj1Ure8HlFFDb95OFPeaFEnzfh6qqUFUVshShxlm8MAqTfZ1ugE43QLvrZZbU5w6VZCEf2CDrigEoBjT0Fl7NIEAzDkYwS7XkkV0HgNGh+dh1cQXzFxnQNRWLFhFYS2YtcZOpyuUhlMtDMbC9y7zZnEHghwj8ELZtJzfMJMjf81LAAsQ9dl0fnhukFvJdSVB0PXksVaswDANWPPndKpXg+i5c34VVKqFUqZF54JqBkmFB0wxonJfJb/OadWk4tn0ry1ZiZem6LFtwgyhZkufG4V+Vci1ZP/e8f0qd2+m4MOOShd2Wmyyj83q9eiPqUxhRn0q2O10JzXB/hFAxNbUldT4aqWS34nu2FOKaa/6lZ3GlEKquQtX0zPhZP9Hi1LOVzgyTaIYCz8m/SVBrS9cB4Mbrr4RZriXDP1Q3rv4GbNeFmeNuK7IGRe7d0HzfT6UarVVrqSX92vRloseRSZ4fQdUMeAVB855g2o0MwBF03HRiK0UhZdfNUg1T9XG8vLGFlze20LZn8PLGFjo2sZoT473Pfc6qT6LdrqPdprMUBCVTVRmmaSbj/aoqkUUbrBI9AHhugED0+WLPgYLLKmKyYrLJG1hQ16x5DGvXPoU8FfYef//Wb6YOvvoqKc6744674Le/IUH8hx56eO7rqYIY3rI1mDdenyG9y1alBxILauq54cEwdAten1oooag2BYiLfO45l+L6G76Y7xoDiJgBbze+4Exudohtt1CtxQEmjWmYZiVTT/aMD5yHm75HxiLzgHWdDnSj94OzlvefL7so9VwpLmMSxW3qTrOLL135tcTCsqBSrTzrY1j93a9n9suKAjAXVYuZURXEF5iuqXA9PwE3Krjva5oKz/OhMeGHHhxoMDIYlXJmQrmhj1ZzWniMatfFlcxwDy/WRaZSBAnYimbtSMj3IPNCLCNBOCM/Ew0AvLgDloX1W9+4afZDPjy0rCi0QDG4QZB/fhHEbJuWQisCttOVIFeXJ9uOm24jyIqG4aExTE1ug1kpE2vLtGnVnHZKHrhOfEfVDS2BFuiBK4PsC6HB5oYsKMgu1xtbZGUBZNzkPGB5tRvNFLiAGF4AkCXu95FVtAQ9nQFjFXTuAu0HLi9R48jgbm4Kl7o/LyAfADSlAk3r7zSy4IqABeYG7WsFlmrNmsdS23nQFpq+VrOBSrWGVjzWRdd///sHuT/2ewBieGl8p64oyWRoaknrcRN2aLia7GOVtGUr+2WOWdUhOG4XRjwTw9CtFLhh4BF3WQLsdhOA3OuAMkxANEwzgFzOreMBBZPBwhBM1qaSIcEwVDhO9n2wbjFt497znz/H4sWkcvnGjSQjYaNpo1bN/o1yrZrZF8Szpii8oURvMsxnyZlxFfBpamNLa3Gfr9PN9j1Q95iFVwbQZb5Hg5lel4ShMrO23NBHpZoeh201p1EWVDig749CLLKwAODFQAXuYH0YGj/hJX5/RZMYJEWB65BeNU0tbk6tWfMYnPiaNPqUWi08WonbNhWmjVOp1vD2d5wAIG1tRWKtbJdxX1XDQtlSe/AKgKVi27O8DN1COe4FbbfqGB1NJ6zu8GUXW20CLADkfDF+6EOV+fbt3DqnnDgtitO1MwCHiHItLQssQNqxGzduwuLFOyWPr7yyFSiYTHHvQ/fizYcdDQCImGCHEPlBABUmYkdkbamGmIJl3a4NyzKFwLLquckygBCWoSU3DMfx4DgeatVSKo48yAlvjbwoBeyqVR/HjTf2Zsfomgopri1EDQVtHYWcZ6HEQUL94PU8NwVucnOJb0oieKMgyMAahT4kWcXMTDpFrRP5fWGlmnVH1G9/cxd++5u7EutbJGplrdgVLVsqypYKS1chKwZGxualFip239TEOFyvm7iW7DpAYAWQwMurZPSmYZmVMlRNSRZeqiQnwJ599sfZT9L3s/aTDCmzGIaaWkQqVypYde4lqX0bN25CFPmoVU00mnZqobrzpz9N1qVAzizJZ5bNZGHFAqzIMhRZhq6p0DUVZ575cXS7dgIsAJQsHSVLhyRHmUXT9PiCJ3+363joxqCKOqTO/NDHUtsUkLP/njQPJE2CpElwPR+u56eABZAAy0pVyCKSqZdRrtSEixx37MmqiiAKcxfXdcnidDAzPY6Z6XG0OjbqjanMwgI7PLwA657/CwxJTSxtPxW2aa+97vOZg/c/TCY06zm++SGHpEPSwpDcaSymDdl1/cx2tdKDa3pyIgXx9OREocXNA5aKt7hUvpf+cdWCEmjOHCK1gPwEdrl/J3aXqVsFAHfd9TM8t349dt55YeIaA0Cz5cMPQqhxbzx1laPIR6fZxef+NX0xU0mykvRw9lN9JptuUeQas6JWV5IjqEq+W9jlxjRr1WxvKxVvdR0miyNtY0tSAMeNYOjZpqDLucnnn3MJrosjzACxpS1XaujaHYS+n8DbT524x7rElIPtFJQ0ffalDQiCEIoiI+CGQm/45vfmlo2RVaMxncDqMr2MuqwmQf9r1vyJObsYAgU6Vt/4M6xc9TeZY5EUf4Dnnk4fiLffftgOuHfNNhxzaG9eqcfkH3KVvZK27VBcgMpgPnq7wA3yozAXXEMz5gRut9sdCNxmo4ELP3oZvvHNz6b2/+T2m2GVhhBFPqzSEBYvJvufXfc8/HhMlII7NdOBqsjCdi5VpISIECLkMl7ylpZKkeVMmzZPFMLsV8imgUk/d64ySloKXGpdCcD9mzMssKZeBj8Hod1qoN3qeZOWWUK71YCm6akbCO8pKCq58bA3jxJXz5mH2JBUOK9XJXjW0n7kgv+Ja679FwDIdETxWrp0X1iWhsceexyyIKvi4Yf28vM++vgfM8dv/PbPsOq8HtBBEOK7N9yBs845Jbf69+slM2foYVCNT24R7j/xXSfjzl/9IrXvbce8K7WtRB4CSUse77rrZ6nj659dh8WLd8Kz654HADihgsnxAGPze1ZzdJhcNJ/66CnAcDruup9U2YQfz1+1WzYqtWF028XNIN7iimAssrZUWsEElLy2bas5jUp1BE7Hy+095nvHeYub+js5N/QiKyty70WWnhcF99mXNvT+/oCWdtbuMUA6o/p1QrFaftibU9uqbkDyXoIXZTNEAFmQ+Q8DIIFXVuXXFeRBoM0D87XIycnly2r9s6QaQafZhRP2LnJDDuCECgyZXHTlWhWXfuozkCUTkRJCCuRUZ9Sgsls2FIUm5Ysz8XPvk4U2z3oOAi2QD269MZn0HrNjtpXqSLJdsZiynkx4qSxFCCMpBW8/cKlbPFv96cknUtteTv5kVmznFr3O6Xf+7a9997W7x1StZgOHH35krsU9+vA3cHtIoCiFlOTISQOr6r0fdvmbjswEcfdTEAJWHOOpB70qBf/10Oa8l7wumj+WrZf73wG1SBRSFtjNW4FFaOJ/febTua879LB0JYKRofR4cLmWnf2zzz5kNtHwUH7fgsXc8H79X3cIn2M38t3iifo05g2NJI/s/gULelBufbWJ4aqOmaaL4Wr/SDbLDNC1+7fhN27tX2O41R78ujzqbScUHk8B63qAoiAM/b4zOvta2kZjGrVaeoyM7qPQ8p1PAPDYYyRn7eGHHQlZUHGMStUN+K6TgpZVP3hZIzxSJT/sdLOZ2s7Tlilyl95hdCRZF2mnhQsTCxNFHoL6WjRkMovo2XVPCl8zCLiDWNd++vMf1wz8XB7WQZWX0Z/K98RX2T2/W4dj35quaB8WXAvkXFl3UxQYct8DT+Poo5bC8/tXo2gXTL8TKorwWkYM3LyZY5GD5cf2SntmoAVgqAa6gQ1LMecWEfWd68+PAMBu9e9IibjUIxWtDifaCYa0CV60CJqUb/Eibbe+558NvFR50AaCka7xKfF82tFacc90FIkvGtp5owwQy2ozk9JbnfSY9b333df39VQU4BPf+17c+dOfph41Ln74lY0vY+fFu6LdmMR0fbCMmkB/gIF8iIG5QUvFwkthpZXpHn7keSw/Ys9kH6/CUjW5DIjBzYVSoOXHvFO4X9P0ZOw3YCaZUGgB4KZrfjB7aL/xlY9nDpoV0jNr5HygM8+7Bjd/+yOpfbNpckbabkk+nyJQK/LGzL6JlgXNzFYzo6IQi6BlxYfpUdFxSbZdR6E9++xLcdNNXyTn5/ybfuCy0P7iV7/Mfd6pp74v91jU3JDaNsaW4r4H78HRRx6L+x4k6WlohUEKcLsx2MT/6XoLI0OV1GOedGl2Ey8ApNzhiTgRWj94eQvbr/7r7KHNXt88rM88PYF9luZfb0A+tHIkJYEeciThxut+gJUXfCD1nDlB+8UvXTJw2WzLEl+YFa0u3E+lK3MLJ6Sq+4vh2dl8P7wWzN8N28ZfStZZd3ioXEGdySH0yX+4Ald97fLU60eqpcQtHikYT+QlqyZCzhr7k4O7tPJQcQWAIj3y6B8y+3iLOyi4eQogoVFvojYk9mqK2rCDaqI+nYFY1tOXpuTHCQlUF74tQTXJcXYdAOozvfczVgUm+WC8HNc4z7oGIZf8gMYvROTvsO4wK2ppk88TpfkMpei/D1rL0tDterOGNs9l1hUfbqAm61QTjIteZE2reLHfWx5YzXYH1XIJzXYH6vABaHdc1EIy3KIMHYCgvjaz3nsjy5JVOtbJWtzm5HOoji1JWVmRWMs7G0sL9KwtFQsshbVcG5szuEHBrBdWLLiy4SN0VMhG+mIPHbF3s2UiW5F+bKiMmSa54GlH1HRBeZr7730Bbzlmj9zjauBgpj248Wi1bVTKZrIOMLACCbCseHiLoKUWeE7Q3njjl6N2ZwrlEkm8PDHZ610bHh3BzNR0X2hFMtTeYDMPrq74cGVSj1YP18OV94IeiotNA2mYZyMKvmdPQAtIp1G1nLagzfbgbRejYCyvKEWsry0Z+G/w7d0R47V3ZEmV3dHuEK/jmWd6lQwGAbkftLfecg9OP+NY4TG74cCskc5Hl4lYY+HlwQYApzW45S4CGSCwssoD90+PbcHBh2RHCQAGWkHoZJ4owHIkQWFmN/FDRHO2tPPGFqZgZZUHqqbmJ7z2/FZyXGUqivu2i6r6cu7r+kkEL2+RqRs9aoqtWze+WWiahplWE/O0DYXgrn3exwF7kossD9pOVIGFwbIfslKUwcLC9fJOfZ9jtwqyXw4tQaM5gXJpJIGXXe977jiH1dj8hbjn3jsHek3yWs51FkGaHPM7CNUSZL/3e3Rtpe9wznS3hRGmHCsLMg8tr0Gsb83S0Oh66BaEKvIqaYTFA486CQDw+AO/TNZZzQnab9/QC65QuQ4GFmQRvIY5lDvxnBUF14jrqXqejzCMUtkSVp1zMW68gSTNChBAkRQgIilFWL36anb4pVrbGQBguzZMPRuqx7ZlRZqnbcCEtwsM9xnhcQouD+2jz9h40z7k73Wi/JtYqfYGeN1uYkUNrQNNW5ixqlRjJnEXJ+0FybpIYZTOPmFWqoAttp5RwWi9b5ML++yLbsFNV5PyErpVPJQGAL+869HUthvquP2Oh/ChM9LDTrYjwzRC2E72JnXbbX/AihWHZfbz4M5GIutL4c2DdJCx2QXzalC5nvGtk+KZUhRaVlZtGHsdkC6gPWdoVUmHH/XMNgsvBXd0ZJ5wYrMEKZPIjLWuVDRYWlFkBE4Aha1b4Q3QFyYBjTrpTTatHQEAmqag2XgF1drO8LwAmmBWj/BUggRuVAVfFf7w6MPJOoUVSMML9ADWtPzSJEDWFQaQgZQHczaiFpbVoBZ2zBjMCgMEXrkihlxGvgcgkpsDz7/99En83XuXCY8BwLaJGSyYN4xtE/nTDe+5/xUc+5adhceyGR1nLxbgsTHSU94VTH9kLe6c27RFb8SPXKiSjjAM0LXrMMye5cuzsoqqQmInEgQ+oKgpdzDg55ky2fVq5XRho0Z7ilheTq7rDwwqVb3dwnDOBUZVBK7w+YL5q1FjreCZacm1Xtzw1ORmVGqj0DUTU0wJTgrxa4G3I2eTfPeDt1wir5kcJzftsfkLU9t5WvtUttfczZmBJRJrYWejIlhnq9cCcLOR7ZR97IkGDtk/+/sdeNRJrz+0IZO1MK+bhQVXYdxH00hbWyfwAVGaDzmCAgUBAoR+CC2u3xpEHhRJA+0HobVY2UcAA0FLMxPSRyqRxfXCnNhaQZK3CB6kOK1qGA8LSHL+d81Gx9CAAV6dTge6oLIeAMhMDiuJm2bj15+DOrQEfv259PnkEcwb2xkTk68kIAIQAkuPtzvTqXVNI55DUzCFL0/Pv/QcOp3GrIAtkux3Zu0mA0CzNVivOQW10fVQm0WHKyAGdVCtWVt//aANuTSjedDSnDo05y8rEbjUPU6Ju9CtkNSW7cp7QJEUrFp1MW68MZ0k2uUKNeXB6wsqlmkFgRBe6ECTDXihIwSVlcjCikRhpT2HnuejVCrB90K4np0LKSse2CgKE3ApsAAyvwGv6WnSi04tLQsnVbk0Ao+LlomiIEmt25yZQnV4dNYQz0zn184RSWR1ZwPuoMACxR1SJUFVwtlI5CJTvSZo+TYtDy0gBpe2afsBSyWa5gQAkKMkYyIAoTtMxQMLvD7Q8lY29MNUOlSRBrGwqb8RA8taWt8LoWpyEhpI6/mwKrKyK1d+AqtXfyW1T9dNBKEPRVbR7fasHQWV7UUWvk8/TKXS5aVqSpJgwCplbzqtlrg33Yjjzx999BHhcVZ8OQ/b6ySlaGwvCzSflM2eyVrAZmsyAXS43LtmB+lFfi3w1mpVNBqkfc9C/LpZWj9yIXOlJftFKbJfGAvsmWd+HDffTLIr5AILpKytIinwPE8IlwhYKjG46e/E98XnzXOLWamSkbKuUexSDQqspul9Q/FEVlfOqWXKwuvXn4MxthQA4Ew+jdL8/VORPJKaPsfU+KsYnb8jHEHHj6IosAt+KxHMVsnEtrgkQKkm7kk3ciaMAFmIi+rvUGBv++H9WPGBt8DUSnC8LhTNQCBIYqCwicGDEFBkREyI5I9+cC9O++AxyTZNUGc74t8q9PJvZlu2pL2JxbvtjvrkOBqNJmqCZHx33vnk6wOtyMoCg4Eb+D7KZXEIYAKtFPTqzcbror/JwxWEHhRZ6+sae16Q1FgRnTev85gFN/RDyHFnmioZiOJynFKoxuftWdgolPqC2w9YanVFbdqo9SKU2h7xe5eTdqsxthTO5NOJa0ylC4a9WIV0ul/bTrnIyfH4l477DxMpCsBmDNU0TXhzzbOylUoNEiK4bv4cVBbeInCBHrwstELFoCbrVFKUqUXUe0n6Pd72o4ew4rQ3I/QCyJqSCy4PLQAhrFRzhlbWNHRaXZiGClnT4Dv0DYfJ/zJyoBXkELYEwfiOa8PQTQIuCy2QadPyE95lBTj3w5/G9d/512Rf4EvQdC1VokPTFMhyDyrS8SSw1gNWitMMLYE0kn1IoZrACgxuYamoawxkg99FFjZqvYhpp7efRkdRgPnUoYqiIAgCWFY69QkVhZWVyNJSSUqYQOp7QcolBpDZ5i/0SlyjqNVqJOt0u8jqsrr//nv7Poe6zX5fs5K8UQIxc0OnObi+f/Nv8KEz3wEAkKAigp+xuJZRQ9dpwDJqkJk8aHZBdBZrKGYmSH7n4Xnz8YPv3TN7aL91zReEB0sVK4a3By4VW7jYzwnfywNXpH6ldUS5xWVZTwFrGAbC0Ics98Ai6/2DP3zqKikhEMiAEkLpkxQtL6keD7IslxGGbahaCVKcDpVvz7pe9nvRNTPp3aY/uKrp8D0XqqbDdRzohgFXkEnCssrodtuF8FJYjbIJp21nPq8X9O9ko5aWrg8qkbU1Yu8g7xrh4WXbt5XqMGaaUxiujmKmyXWO5VVTjK2sFAf4qFx0mgQ1AbPrMHmkjN7Nxw1s6IoJWVcLgd340ovYZffdhcfyoB0oVq5UsZJFT7mbMgA59S+Mb795wAJA1/PR9fzcHyH1BnP4yN3P5CzWdC0py0GtrCyrucD6vgff9yBJZN31uggjnyx+mDyyBYSLigmLpOhWsshKPBPF6yCCiggqrFIN27a8glanDdezYVlDKFd6i6FbqeGoKEKmDpFekDKHdjyxHVAAgTWUA3zoAxfCKJsw4oB40Q1KUzRoigZFIW4xL98LEtd4EGAlRMkCALou7tQxBK69oZs48qhjk6VSHU51SLWapGMnA2wfaZqKH95yN/k8HNyRLCeAWkYtWVjpCnmvRcACSAH7w+/fO9B7m7Wl1TUFrhdw8CI3JScPry5I9AaQFKV5QdcigygrZD8Pr8wlGmVhsf4AAAY4SURBVJdzsivy0Pq+l3KXfVFGBCXMuOdanB2fWldJLS5e4AYuDE2DI5gvWi6R4JQwkOLPwr3nwIWs6AgDYok0XYfvR1BVCZ7rQuMu9jxLy0vkGvu2+GakaSa82PrzFrdkVtGxs1FOg1paSTBBni2xyd7kDd2E49qQJXJuP8x+6Y8/TjKDFgIrsrZ8qRQAKtNEkcIQkSxDGiBLpRvYMK1KAi+7XhB8ByDf0hYO3JUqcaXqVjdZj99K6nmyoiQWlm4DYmvrxhecCN4gUhJw1TgVpRd4qWIAtGePB5mHlSqM3wMPryynO7j49m0EGRLj+IeRDzlQAYQJqKworJGfBZd+ZioKbLk0lABK/2oesACg6jr8GE7PdRNgAWSA1bSSEFpqYVl45VDJgKuamhBcCmwIL2VlgwBCYF+rIoQJuNTSel4AzwsSYAFAjT2pLtMRue9+BwMANLUHMNXMzASGh8VTPGcEdYN8z07ApRPq2Yn1FOBIllN1gkyQ3nLTyvaaU3vZD15efRO7dVrZjhnV0JkOKaSAHY8b0mMLFmBy2zaMLViQeX0URnDi3lgj7tW74Nx/xE2r01W2S6UyOp126o4uqRqUnGEOcvLsLh5Yn+kUkZkJz54fQFOV2MrKKXDl+M5hWLE1DNMdEJJkwgni9k0AmGYtAU+FyY8uxW81AnsgDXC+vLjNF4Ue6GyuKIogSRI0nbRpRcBS5bVnWYmALSopInK0gmAwK9tqNVDtEz7Kio4IeExHF7W0mgrw1Sc9nwDM1gz602PZBAFUecnr8iZxAH0yY3ASAezENaEMs5Ks56nQPV79va/lHmShpaAWaWzBAkRxj6YiBYlVDSIlAVekvE6PPHBDUZW+PnMdPceHZqgoyhcdRcXpMHWzd9Flfr+ie4yf/2Pz50nq0nAdNayVLYKVV5GrnOceA8XwAtmhH1Z8b7HIJeblum7KymqakgIWSLvH55/7KVx3/RcAICky7jheClo59sD8MMhYYYBYYgAYHp5XCGue8qryzUarr/+P2fcer/7e1yJqaal7TGFV4yAJut0PXGpxo5ycsyy4pVIZ9eYMtPgLF4H7ekDrCSrWyfHg4wXnX4prr/tifE52KCeEYQ0hikK4sTuom1XIMpLUl8KbrgRwhpXs5tOMBBLpoIokhCGw6uyP4ebvk1qyQU4ZxiLLyQY7RFGxJa9Ue+eZmhAH/4fwIEMTguvYAQxTSa1Ta7tt82YsWCTOc03FA0yHVaSc/lIKrqg9SyUrWgZYoActfy7RDUHU5mdF8zo/8ODdyb7/p9ACgO+HUJk3Qbd9PwQCvxDYRTsuzuyzBcMY1OpSGZoBL/AwVB1GvZmOzyxyj4XQAr3x3xhgEbB5khUVulkcsijKTpHAy79dBl4eWlmWyBhrvJ/taHut0JJtct5KtYxWMxuwz4ILpOHVcuKgRVGldnxDM80q3AFGCQDai0xBZVtu2e+2yNKykhWxey5HIUJJxrmrPpkJC+XPDfQH14j7aAJIUOKbD5/ZIyiIAQgEva0f/cjlcx/yUbm7hqrKOPvMuMCxomL+wh2ThWrRjosTYFeuTFdBMzUTpmbC0AwYmoGRoVHUavMxMjSaLKVSGUNVUrmNPgKkIyoMotQCpGGVlRyoGYurxVXqtJyBfDmeLigrgjHlbj31SIGV5Rwry7NWYPBoUISs5A9rsZoNsKxEwLLqtNvotNswrUqyKKrad9LB6R8gmThNswrTrAIhoKtmZpFlI7NQSZmuFjK0qOmlZCmVqyiVq9CNMnSjjJI1hFLc38CCGhaMKctROGdgKaSGoifrADLAnnfOxb1jglh1Eaz9NHCbNmVdY/HbAKAVVLoGiJU1NRNWqYTp+lTiFjueA0MzMsWKeLFWd1YucizPdQioUlDoHrNirSxrUemMmiLJMsSWFmR/5MuQ1BCRLyfjtuR12c82G0ubB+xsXOROu51M+GAnfrCJDSSFWFXTzOlIyvl6/LzSHAKLqRWEXvLXHwDUm3XQ+B2RpaWucSjJyXpeW7nIwlJYncBNgdsvd5bI4s7G0hZCu13btV3//+m1t5a3a7u26/+qtkO7Xdv1V6bt0G7Xdv2VaTu027Vdf2XaDu12bddfmbZDu13b9Vem/wOYtwK/upT1QwAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 288x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "k : 1024  M : 2 \n",
            "time: 308 ms (started: 2022-11-24 03:28:16 +00:00)\n"
          ]
        }
      ],
      "source": [
        "display_clusters(image, clusters)\n",
        "print(\"k : 1024\", \" M : 2 \")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "z19E-gcEp7DW",
        "outputId": "5f091ced-a102-469a-cf1d-3fae3cb3c5b0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "time: 3min 44s (started: 2022-11-24 03:28:16 +00:00)\n"
          ]
        }
      ],
      "source": [
        "img_path = \"/content/Part1_SLIC/BSD_data/images/10081.jpg\"\n",
        "\n",
        "# Load image and convert it from an unsigned 8-bit integer to a floating point data type.\n",
        "image = img_as_float(io.imread(img_path))\n",
        "\n",
        "# convert RGB to LAB\n",
        "image = color.rgb2lab(image)\n",
        "img_h = image.shape[0] #  Height\n",
        "img_w = image.shape[1] #  Width\n",
        "\n",
        "# k: Number of clusters/superpixels.\n",
        "k = 256\n",
        "N = img_h * img_w  # Total pixels in the image\n",
        "S = int(math.sqrt(N /k)) # Average size of each superpixel\n",
        "M = 10 #Compactness of the cluster pixel\n",
        "clusters = []\n",
        "cluster_tag = {} # cluster_tag should contain cluster-assignment for pixel h,w. For example, cluster_tag[(h, w)] = c\n",
        "dis = np.full((img_h, img_w), np.inf) # Distance bwteen pixels and cluster is initialized as infinity at the beginning.\n",
        "\n",
        "clusters = slic_algorithm(S, image, img_h, img_w, clusters, cluster_tag, dis,M)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 215
        },
        "id": "mdcgUhVHrqpy",
        "outputId": "7cd8301d-af08-42c2-ad4a-902bad6fba20"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 288x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "k : 1024  M : 10 \n",
            "time: 330 ms (started: 2022-11-24 03:32:00 +00:00)\n"
          ]
        }
      ],
      "source": [
        "display_clusters(image, clusters)\n",
        "print(\"k : 1024\", \" M : 10 \")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "u2A156D4sjNO",
        "outputId": "bdd3f3dd-b93e-4cc3-bb35-b0720daf9756"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "time: 3min 20s (started: 2022-11-24 04:00:13 +00:00)\n"
          ]
        }
      ],
      "source": [
        "img_path = \"/content/Part1_SLIC/BSD_data/images/10081.jpg\"\n",
        "\n",
        "# Load image and convert it from an unsigned 8-bit integer to a floating point data type.\n",
        "image = img_as_float(io.imread(img_path))\n",
        "\n",
        "# convert RGB to LAB\n",
        "image = color.rgb2lab(image)\n",
        "img_h = image.shape[0] #  Height\n",
        "img_w = image.shape[1] #  Width\n",
        "\n",
        "# k: Number of clusters/superpixels.\n",
        "k = 64\n",
        "N = img_h * img_w  # Total pixels in the image\n",
        "S = int(math.sqrt(N /k)) # Average size of each superpixel\n",
        "M = 40 #Compactness of the cluster pixel\n",
        "clusters = []\n",
        "cluster_tag = {} # cluster_tag should contain cluster-assignment for pixel h,w. For example, cluster_tag[(h, w)] = c\n",
        "dis = np.full((img_h, img_w), np.inf) # Distance bwteen pixels and cluster is initialized as infinity at the beginning.\n",
        "\n",
        "clusters = slic_algorithm(S, image, img_h, img_w, clusters, cluster_tag, dis,M)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 215
        },
        "id": "LFwhQiJGsnaK",
        "outputId": "0b88175b-89ee-412b-b57c-b7c6d07c4bfc"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 288x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "k : 1024  M : 40 \n",
            "time: 302 ms (started: 2022-11-24 04:03:33 +00:00)\n"
          ]
        }
      ],
      "source": [
        "display_clusters(image, clusters)\n",
        "print(\"k : 1024\", \" M : 40 \")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "N3GhFsmnxic4",
        "outputId": "fd151211-e0b6-4daa-814c-b1e171d2e02d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Avg Run-time of image  49024.jpg  hyperparameter K: 64,256,1024 : runtime :  93 seconds\n",
            "\n",
            "Avg Run-time of image  10081.jpg  hyperparameter K: 64,256,1024 : runtime :  110 seconds\n",
            "\n",
            "Avg Run-time of image  14085.jpg  hyperparameter K: 64,256,1024 : runtime :  99 seconds\n",
            "\n",
            "Avg Run-time of image  14092.jpg  hyperparameter K: 64,256,1024 : runtime :  150 seconds\n",
            "\n",
            "Avg Run-time of image  2018.jpg  hyperparameter K: 64,256,1024 : runtime :  135 seconds\n",
            "\n",
            "Avg Run-time of image  23050.jpg  hyperparameter K: 64,256,1024 : runtime :  127 seconds\n",
            "\n",
            "Avg Run-time of image  28083.jpg  hyperparameter K: 64,256,1024 : runtime :  96 seconds\n",
            "\n",
            "Avg Run-time of image  3063.jpg  hyperparameter K: 64,256,1024 : runtime :  86 seconds\n",
            "\n",
            "Avg Run-time of image  5096.jpg  hyperparameter K: 64,256,1024 : runtime :  118 seconds\n",
            "\n",
            "Avg Run-time of image  70011.jpg  hyperparameter K: 64,256,1024 : runtime :  108 seconds\n",
            "\n"
          ]
        }
      ],
      "source": [
        "images_list = os.listdir(\"/content/Part1_SLIC/BSD_data/images\")\n",
        "for im in images_list[:10]:\n",
        "  run_time_list = []\n",
        "  for k in (64,256,1024):\n",
        "    img_path = \"/content/Part1_SLIC/BSD_data/images/\" + im\n",
        "\n",
        "    image = img_as_float(io.imread(img_path))\n",
        "    image = color.rgb2lab(image)\n",
        "    img_h = image.shape[0] #  Height\n",
        "    img_w = image.shape[1] #  Width\n",
        "    N = img_h * img_w  # Total pixels in the image\n",
        "    S = int(math.sqrt(N /k)) # Average size of each superpixel\n",
        "\n",
        "    clusters = []\n",
        "    cluster_tag = {} # cluster_tag should contain cluster-assignment for pixel h,w. For example, cluster_tag[(h, w)] = c\n",
        "    dis = np.full((img_h, img_w), np.inf) # Distance bwteen pixels and cluster is initialized as infinity at the beginning.\n",
        "    start = timeit.default_timer()\n",
        "    clusters1 = slic_algorithm(S, image, img_h, img_w, clusters, cluster_tag, dis,M=15)\n",
        "    stop = timeit.default_timer()\n",
        "    run_time = stop - start\n",
        "    # print(\"Run time for image :  \",im,\"hyperparameter K: \",k,\" : runtime : \",run_time,\" seconds\")\n",
        "    run_time_list.append(run_time)\n",
        "  avg_runtime = np.mean(run_time_list)\n",
        "  print(\"Avg Run-time of image \",im,\" hyperparameter K: 64,256,1024 : runtime : \",avg_runtime,\"seconds\\n\")"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}