threading_background.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading\n",
    "import time\n",
    "import concurrent.futures\n",
    "import os\n",
    "import numpy as np\n",
    "from skimage.draw import ellipse\n",
    "from skimage.measure import label, regionprops\n",
    "from skimage.util import map_array\n",
    "import time\n",
    "from skimage import data, filters, measure, morphology\n",
    "import matplotlib.pyplot as plt\n",
    "import asyncio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def threading_test(name, radius):\n",
    "    for i in range(30):\n",
    "      print('a')\n",
    "    return name, radius\n",
    "\n",
    "def threading_test_sec(radius):\n",
    "    for i in range(200):\n",
    "      print('b')\n",
    "    return  radius\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Main thread finishes before the background thread is complete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Am the main thread\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "Main ended\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "\n",
    "    print(f'Am the main thread')\n",
    "    t = threading.Thread(target = threading_test, args = [\"Kapoorlabs\",2])\n",
    "    t.start()\n",
    "    \n",
    "    # Main thread is not waiting for background thread to finish\n",
    "    print(f'Main ended')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "a\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "b\n",
      "('Kapoorlabs', 2) 2\n"
     ]
    }
   ],
   "source": [
    "from multiprocessing.pool import ThreadPool\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "pool = ThreadPool(processes=2)\n",
    "\n",
    "results = []\n",
    "with ThreadPoolExecutor(max_workers=5) as executor:\n",
    "\n",
    "  results.append(executor.submit(threading_test,  \"Kapoorlabs\", 2)) # tuple of args for foo\n",
    "  results.append(executor.submit(threading_test_sec,  2))\n",
    "\n",
    "\n",
    "results = [r.result() for r in results]\n",
    "res, cellres = results\n",
    "print(res, cellres)\n",
    "# do some other stuff in the main process\n",
    "\n",
    "#return_val = async_result.get()\n",
    "#print(return_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add daemon to kill the background thread"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Am the main thread\n",
      "Background process started with Kapoorlabs\n",
      "Main ended\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "\n",
    "    print(f'Am the main thread')\n",
    "    t = threading.Thread(target = threading_test, args = [\"Kapoorlabs\"], daemon = True)\n",
    "    t.start()\n",
    "    # Main thread is not waiting for background thread to finish\n",
    "    \n",
    "    print(f'Main ended')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use join() to wait for the background thread to finish execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Am the main thread\n",
      "<locked _thread.lock object at 0x0000013EBB30D1B0>\n",
      "<unlocked _thread.lock object at 0x0000013EBB30D1B0>\n",
      "Background process started with Kapoorlabs\n",
      "Background thread finished\n",
      "Main ended\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "\n",
    "    print(f'Am the main thread')\n",
    "    t = threading.Thread(target = threading_test, args = [\"Kapoorlabs\"])\n",
    "  \n",
    "    t.start()\n",
    "    #Wait for background thread to finish\n",
    "    t.join()\n",
    "    print(f'Main ended')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available number of cpu 16\n",
      "Background process started with Kapoorlabs\n",
      "Background process started with Paris\n",
      "Background process started with Berlin\n",
      "Background process started with India\n",
      "Background thread finished\n",
      "Background thread finished\n",
      "Background thread finished\n",
      "Background thread finished\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    nthreads = os.cpu_count()\n",
    "    print(f'Available number of cpu {nthreads}')\n",
    "    with concurrent.futures.ThreadPoolExecutor(max_workers = nthreads) as executor:\n",
    "        executor.map(threading_test, ['Kapoorlabs', 'Paris', 'Berlin', 'India'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available number of cpu 16\n",
      "Background process started with ['Kapoorlabs', 'Paris', 'Berlin', 'India']\n",
      "Background thread finished\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    nthreads = os.cpu_count()\n",
    "    print(f'Available number of cpu {nthreads}')\n",
    "    with concurrent.futures.ThreadPoolExecutor(max_workers = nthreads) as executor:\n",
    "        executor.submit(threading_test, ['Kapoorlabs', 'Paris', 'Berlin', 'India'])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def relabel_map(image,  current_label):\n",
    "\n",
    "    image[current_label] = 0\n",
    "    \n",
    "    return image\n",
    "\n",
    "def threshold_and_show(image):\n",
    "        \n",
    "        threshold = filters.threshold_otsu(image)\n",
    "        mask = image > threshold\n",
    "        mask = morphology.remove_small_objects(mask, 50)\n",
    "        mask = morphology.remove_small_holes(mask, 50)\n",
    "        label_img = measure.label(mask)\n",
    "        plt.imshow(label_img)\n",
    "        plt.show()\n",
    "        properties = regionprops(label_img)\n",
    "        current_labels = [prop.label for prop in properties ]\n",
    "        replace_labels = current_labels \n",
    "        return replace_labels,label_img\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total execution time 0.12599587440490723\n",
      "Total execution time 0.002000570297241211\n"
     ]
    }
   ],
   "source": [
    "from queue import Queue\n",
    "import threading\n",
    "import multiprocessing\n",
    "from functools import partial\n",
    "if __name__ == '__main__':\n",
    "        starttime = time.time()\n",
    "        \n",
    "        \n",
    "        image = data.coins()\n",
    "        return_labels, label_img = threshold_and_show(image)\n",
    "        for new_label in return_labels:\n",
    "              t = threading.Thread(target = relabel_map, args = [label_img, new_label])\n",
    "              t.start()\n",
    "              t.join()\n",
    "        endtime = time.time()\n",
    "        print(f'Total execution time {endtime - starttime}')\n",
    "        starttime = time.time()\n",
    "        \n",
    "        nthreads = os.cpu_count()\n",
    "        with concurrent.futures.ThreadPoolExecutor(max_workers = nthreads) as executor:      \n",
    "              executor.map(relabel_map, label_img, return_labels)\n",
    "                   \n",
    "              \n",
    "        endtime = time.time()\n",
    "        \n",
    "        print(f'Total execution time {endtime - starttime}')\n",
    "        starttime = time.time() \n",
    "        with multiprocessing.Pool(processes=os.cpu_count())  as pool:\n",
    "             pool.map(partial(relabel_map, label_img), return_labels)\n",
    "             \n",
    "        endtime = time.time()\n",
    "        print(f'Total execution time {endtime - starttime}')     \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATwAAAD8CAYAAADqmhgGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABSPElEQVR4nO2dd3gc5bX/P2dmtqh3S7bcZFtu2Ma4mxIIBEJIfkAqkF4hCbnpNyHl3rRbSG76zSUJqdxAwoUkJKRAEiAhhWYbN9x7kWT1vtLuzsz7+2NXsmyrbJnZXUvzeR49Wu3OvHM0O/Od877vec8RpRQeHh4eUwEt2wZ4eHh4ZApP8Dw8PKYMnuB5eHhMGTzB8/DwmDJ4gufh4TFl8ATPw8NjyuCa4InItSKyT0QOisgdbh3Hw8PDI1HEjTg8EdGB/cDVwElgE3CLUmq34wfz8PDwSBC3PLx1wEGl1GGlVAS4H7jBpWN5eHh4JIThUru1wIkRf58E1o+1sV8Lqjyt0CVTPDymEAqUbWfbiqzSS2ebUqpqtM/cEjwZ5b0z+s4icitwK0BQCthY6DmAHh7pYodCKGVm24ys8pj6+bGxPnOrS3sSmDXi75lA48gNlFJ3K6XWKKXW+LWgS2Z4eOQebq1fV6aJsixX2p4suCV4m4B6EakTET9wM/CwS8fy8HAUZVnuiVIkgt3bO/pnSo0rWMo0UZHImJ+LYaAXFaVt42TGlS6tUsoUkfcBfwB04IdKqV1uHMvDwwnsUAjx+0HXsQcGAdALC9w73sAgomso0wRdRwsEUAMDKMtCy89HdB07HAZboeWd7gHZkSiaz4fIaKNGxPbxGBO3xvBQSv0e+L1b7Xt4pMqQ96YGw6DsmFelFMo00YJBtGAAezCMHQqh5ec7dkwRAU0DTY95kZYFtgWmiTVCqIbEV8XfswEtL4gYBuKzsPv6hu0SXY+1b5rYoZAjtk5mXBM8D49cREUisa6hrYY9OBWJYA/GvLqh3wBKCcqyhkUl5WMqhd0fQnQd8fsQn4GIxEQtEjktwEOip9Tp14CKRrCVDboOtgKlsPv7ARCfHzQ5Y3uPsfEEz2NSY509XjZibG7oMy0vb/SdlQLLQmmxoe6xupETG2HFPEnTRpnRmKABJCFSyjTBPHf2VUXHHtPzOBdP8DwmBco0EeP05awsKy4040w+xD8bsyuo6bExvb4+UArx+c8YTxuz2aFjj2wqEIi1FffMRh7fI3N4gudx3qMiEexw+Iyup5pI7BLBtmJiONTlHOpanoXk5Y0/iTBkh5Ze19gjfTzB8zjvEb8fzec706uKj9WlzVmieUabQwI2GEZGeH6ixzxDZZogGqi4XbYXI5dtPMHzSJihwFbR9TO6j7lCpmcpxXf6HAyFg2iBwBkBwOIzUOHJJXQSCMS66ONg9fRkyJrkyL2r1iMnsMNhiMeEDaPrqMFwLF4tR1CWNRw3l/FjjzLpoPx+VNScXJMJ8e66XloKfl/sYaeNv2bByM+LzT7bCqutLfZmDoxZeoLnAXA6wn94vMocHsM6Q+CUHZu5hHG9PKu3N+YJjhjfGvIOh8bXkvUSlWmiombMs9J17P5QznUTx1pFcV4igpaXh1ZWOqHAnYPPN7yg3phZC4Dd0YkKh50ZakgRT/A8gBHdwVHGrM6+QO1QCAkEEMOIxZFZpwfyxe9DRaLDgbwqHn8WayuKGD6UGZ2wSzQqcQ9TRSOx8bMcE7vJhFZUhASDSDCF72msNsvLIBpFhSNYnZ2OtZsMnuB5ALFYtGTGwFQ4jBWJnCuQZ3flbAs1QphUNIIMhWgMDMZEUNeRQAB7YBDN7zvDo1RKxUQ1EoktudIEZeOJnYvoxcVIcdFwV9ZRfD7E50PXNaz2jox3cz3B8xjuKia/Y2oXqwqHz1xJMORFisQELh5iIoYxHAMHnBnD5uE4EgjElrBlIAGB5OWhV5RnXPQ8wZvCDC15yhlvaeSSKsNwJpbOIyEkEECvrEh+rC6dYw6JXlt7xo7pCd4UJFdDBkYy1lIqD+eRQAC9qtKdLuxEx87LQ6+syJin55VpPA+xw+HY+JeX7NEjTYY9uyyI3bANcU8vE3geXg4zNKg/xHAEf7zbp6KRWMqgs5Y2DWXfOHu5kx0Op74AfgTiOz2poFeWowrzhw6MfaIxntHDzmr4gcfEiGFkvBs7pi0Z8vSmvOCdveg8V1CWNZxZY/i9Ubp5yjRRvb2nRSguNBIIxGZDh7aLj4+ldCmJoJeXxV4bBlSUnm43/vkQ2vw5sReWDW0d2D19WQnC1YqK0BJM4Gm1dUyuQOEE0fLzkxc7OxaHic/nuD2Sl4dWWOhqLGPu3ekuMzKL7JAHpeXlnY4pM03Hkj5mkpE3rBYMns7cq+xYmEeKnp1eWoKUlqDyg4m1MbSNoUNNFXpJMYQGME81p3T8pBhaEVA/D5UfwAwmdnlrFaVolgUt7VgdnVNiokQrKoqFniSJMk3s9o7YmJ8LjoJWWODqRNqkF7zh6HxdO53cUQQ7FAuW1fLysAcGzswwGw+bGM4q66IHOHIm0h4YGH6tFRXFViWk0C0cmcQSSLlrqZeVwfQqVBrdYJUXgKAfQyQmem4Ufg8EYjfKvFhEv6UnZ69dGPeOi2qRebVo3SHsw8cmdZdc/L6UHoLi96MVFWG1tqGVlcXacbJLbBinYy1dYFIKnj0ijgti3o+KjtggvgpAfH7EME6LXrwLOCx88UBcLT8/Jpp+X9rZb8+xdWBw1KeZGhjI2g2nBYNopSWosmJnBrNFUOUlGJqG6u1zdJZYAgGkvg6r0IH1vZqgAKu8AJ05WAcOZ9Tb0xfUjSke6njDOQ+yVBGfH0mjSyqFBdDbi93VjV5Z7vgYoFZU5NpKjEkpeKLr2AMDw0J2+gMZ/lwCgeEvSgwDrbDw9JrPIY9OKeyBgVgboiGac8ts7FBo3DizbImdBALI7FqUz/lLQ5UWIZoGvb2OCIkYBrJ4Hnae8+NJVnkBev08rINH3YtT1HS0gnys5fMACOcZqDGeL/q0IsRW+E60Y7W0xtYzp3iNiN+X9hicVlGO6u2LpZ13GMnPg64uVx42k0rwhmcnDQPx+08vldJ0RNfHzVY7cvZypBenFxUNz246McN5umE95+LMtGAQmV0LLojdEKooH6OmGrPpVFrtaMEgLJzritgNYZUXoC+Y64roSSAASxcQrkisJrMVjF2T5qJqWFSNv3MQo7kLNTiYXOCuSGxNa5qIYWCFQkh+HjJWivxU0TT08rLYjK3DTCrBw7KwB8OxMYChGLX4UzQdsUppofsYDIlwro0PSSCAzJrhqtjFDiSxrnJza1oiopWWYOa7n6bKKi+IVTFzMteeCCxbQKQs9QL0kbIglNWgR218uzWs1lbn7EsAu6s7ds24MFvrJpNG8JRlgUhsoD8aiT3J8vNdDzkZLr+XKCPi6EaiFRQgwQCqdhoDsyaePQu0h5Etex0Lp9Dy88GfuYvXmF2LefR4SvuKz481a5rDFo3DwrmwbbcjTYnPDyvq0xK7kVg+DXv5bAI7SUj0xEjvO1ahEHZ3TyyGL0urM9Jh0gje8JiGxMblhkJN3GJkub9EPMih2eJzBEoEfUk94ZoiIiWJ2xuankfemiUYPYPQ1onV3JLKvwHEQk+YXpXy/kkjgvL70AoKUkoIoNdMw0xyJjYdlE8/vdA9TfSaaQw4JHZDKA0iy2bhf2Fi0dPKS9M4kMLq6EQvKc5IggE3yH6ItUMMZdxQZjQjnt1wzQLbigVjTmSfZZ0rdpqOrFlG38LSpMRuiIGaIL0LSwmtmpPa0hxNj9lQ4tBsbDL4DKS25ozg6EQwamdgTk9/DCoZlC5QXpr2OdIKCojMqXTGqLOwdSG6dGYslMhNRMPq6YNodOJtc5DzXvCUUrEZz3h6Ibc9uyFE14eLuNj9/Vh9/bHVDEoltMZVfH5Ys5RQbV5acW4AVlCjf+OC2DKhJDCmVWLMnYUqcHjQOVF8BlpRYcKbi8+PKi4ALfPdKKuiMOX1nhIIoBUUYK2sH558cAPLp0GVi2tSRTCmVSKaYLa0uXcciAU1u1Dl7bwXPOzTazYzJXZDaCOzwdpWLEI8XmPBDoXO+FGRs7y7lYsI1eanLXbDh/cJA6vr0KsS75oOX7TZHIepSNwj0QrysEqyJM4A01JbZK8VFWIvn4/td/92C88qdbcc5NBqluLEH1QpHcbvP/P+coi0vgEROSoiO0Vkm4hsjr9XLiJ/EpED8d+Z6X+IZHxNrBjGGQvph+uY2taILnY8ueVQyIzPj6xdTqjW+RvXzNfpX1+XsCcimqCCuVOQZyIk6OzYV7JYxcHUlh1GomiDJnYGxh2VgLZi0dgbpJlhR9k2ylbOh6KcfZy4o+A0TjxyXqyUWqmUWhP/+w7gcaVUPfB4/G/30LRY6EkW178mI7T6jGr6Zzrn2Z2N7RPCK+tcadsVNEEvLk5oU1WUWDIAV6mbldz2IoTX1BOuzJxnqnxje3iOTLwUF7qyjjYTuOFj3wDcE399D3CjC8cYRkRis6QuRHwndPxgIOGBdzEMBurdD6cw83WMeXMn3E6vqXbdlgnRtMQWsYug8nLAG9VIqlubrevSzWEKq6cv54LmEyVdwVPAH0Vki4jcGn+vWinVBBD/7fod7ugKiBSOnbDrLRpmofs3gG0I0eqSM7vbo2A1ZzZYNV3sYPaDXO18P0btjMR3uHARKsMj5ZESP8bc2WN+fs54cjKEw7HIBDfXGCsVq3znAun6pZcopRpFZBrwJxHZm+iOcYG8FSAoOdBVyQDawsx1NQdqghSVlowfl+VWSorJznkWbHsGSqF6+5BUZpyVwu4fiIW+uOm5KuVaTry0nj1Kqcb47xbgIWAd0Cwi0wHiv0eNiFVK3a2UWqOUWuPXEh+MHgr9OB+JTCtwbewuFc4osO0xZbBDIdTIpBqJ7tfZBZrEsqW4mSXZxdIFKVstIgUiUjT0GrgGeAF4GHhLfLO3AL9O10hlWcO1Se3+0OSq7p5FpKAACTmTcmiqIFELNRmuvxScBvH7MzI56GYVs3S6tNXAQ/HxMwP4qVLqURHZBDwgIu8AjgOvTdtKTYt9QbY9vODc6utHCwZyMj37+YLV2opul0O2Ao+TRBSppah30oawhdXVnfD22uFGZNW8MdM+uYEoJhQ0u7sHPRhMylOTBFPmp4XLvbeU1UIpdRi4cJT324Gr0jEK4tlEdP10WqahOqVDDMW8aTp6Jr6Isew8T7vXOYNSqHACg+hKoR1uwKqf6b5N46CFBklm5NPq6sLojRAtztzwga8nMmFiBmWaqEgUcSG4Nx1UT6+rmYRycqWFikRGX50wGnbqiRCdQA2Gz+saCHZfPyQiOG5h2YmnNsqBspTm0RPJ7aAU2o4D+Ltzr0iQ1dYWu35zBdOMZQB3kZwTPBWJnFuTYajmwxjhH1591tRR4TAykEXRTuK7s7p70Nv7XDRmfIxjLSnl8LMHB9E6+2JdTZcRBbL7cGIbK4UKhXLmga2iUderx+Wc4J2BZcWKTvf2oiKR7AVxjkEs5VPuPbmTxWxozNpFr042JbGxgs5uxMqSrWlkCLEOHkEfdP/B7OsYTGpJlt3fj+rJ/iSMGgy7OlkxRE4LnjLNWLJMTQefb8wVDSoSyYqXZyfZHQjsP4XYmblZ804NYicxuE6r8+m0x0UppLsPO8kAU6utHe1oeunhU0HvGcTuTk8YfIdPuerliQLtZEvSDy+rpyerM89qMOxKOvfRyCnBU5YVm6g4a+ZV4pMXYz65lMr4+I6yrKS7N2ZDI0WbTxLojOLvdnFg1lQYrT1JeZ+qrx+imRsLlcEI5smG1LqIXd1ogxm0NWph7TmQtjdvNp0ieMi91S2BU30pp3q3urpR3T0Z9/TVYDhms1uFks4ipwTPDoVixbHPEi9lRmMFtMf5MuzBwfSWzCSBsqyUMzmYDY3of3kef7vzmSCGMEIW1sEjSe1jDw6iGk4h7V3uX/RKxW6uVHePRuDAMbSBzCSh1NucEwLV0YURcl6sNVNBS3pektXTk7nurWmiunuw2lzOq3cWOSV4Wl7e6Ov0lBq1DsTZZGK2dljs0rgB9EUL6J/rTopsUYrA9qMp7Wv398eKZbe0uyd6tg3NbWl3Yez+fth3BAlbro3piWljNHViHj/pWJtWTw/6tgPk7WlCj9ppd3FFgR618b9wzJFCPlZPD9apFveiD5QC08RqbYvVJ86wR5lTUbtiGGjBYMoFh1V8Wnu8cozpoCwrpRoMZ2PtO0heyXJCtc5Hrfu7zOTG7kbBamtHVwopLEAVOmijbcOpNseKLNuDg7B1F3plBfbc6SjDuee33jOItecApgs35FBSWK2hEd/C+aigD7M4mHQ2ZFEQPNKOefgoTnYIVTSC1doaux/j6f/TzX+nIpGYVzeQ3KSK0+SU4DmBikawlT1cm9axdtPoxo6GbN1HPosYmBG7kNJdYytK4e8y8W3ah+2Ap2u1d0BnN0btdFRRXPRSsXEo8WlPbDbQ6km9KzsWVls7umhY86en3ZZxog0VicYeGhnwPqz9hwDwlZWhVtahNBlzVcZIb9DXMYh+qj3t+r7joUxz2BMfWlKmlZcldR2o7p54kHMkJ0qT5pTg2QODKDP9cZmhLMMaxGZ30xATFV/S5oRnd0a70Qhs3k1BMEB0/WLMfB0rxRTg+qCNL2Si/2OnI2I3jG1hnmxADB/6rBkonwFGgl6IUshgbEzVOn4yNi7rooBYra1IZyf6rFrsovhDJOCLFeAZC1uhDUbBBrXvMCgbM0s3pdXZifH32DUmS+djnVVzVzNt2LEf4rP8yrIwMzTQD6djYO140gHR9VFrqKjBQayR47M5EuM3hOTC0qgSvVKt918b+8NyeOWECOL3x5aoJeHxKdOMVxozMzKDZNTOQJUWES3LY7AqwYSiSlFwpBc51Z5WmcZE0YuLYWi4oKTonKLd0t13OlbNsjISVzUeRk01jFco2jRd9ZA8ssNj6udbRmRgP4Oc8fASmZRIreHYhIcCOCvmS7SYCI4aT5fBpyfEg38bwAgGKUpibbDV3pGxp6jV0wPxLql0dZ8TCG4NDOTUE9081ZxtEzxyjJwQvIx5mWeJmLIzM7ObDPbgIKQ4aZNJhh8iHh7nEbkRlpJDXoGHh8fkJTcEz8PDwyMDeILn4eExZfAEz8PDY8rgCZ6Hh8eUwRM8Dw+PKYMneB4eHlMGT/A8PDymDJ7geXh4TBk8wfPw8JgyeILn4eExZfAEz8PDY8rgCZ6Hh8eUwRM8Dw+PKcOE6aFE5IfAK4AWpdSy+HvlwP8Bc4GjwOuUUp3xzz4BvAOwgPcrpf7giuUeHucxemUFiEZo3VyiBbG8gr5ei0BnmL7ZZ9YRKTgxgLZ5D1ppCaq3N+WaLx6J5cP7MfAt4H9HvHcH8LhS6k4RuSP+98dFZClwM3ABMAN4TEQWKqUyXyXbwyPH0JcuxA7EMjB3Li5CndW/ssp1BsvPLZrUMy+PIv8FdNcGyG+OEmjqxdq9PxMmTzom7NIqpf4KnF1T7wbgnvjre4AbR7x/v1IqrJQ6AhwE1jljqofH+Yn4/GgXLqHzwnK6lhbRtfRcsZuI3pkBlEB/jQ8ZCCOBQGpFlaY4qWY8rlZKNQEopZpEZFr8/VrgmRHbnYy/dw4icitwK0AQ58sVenjkAsbMWjoum5W0wI1Hx8bpwHRK9vSitu5yruEpgNOTFqM9ckZNZ6yUulsptUYptcZHYkVrPDzOJ4yZtXRvmOmo2AEoif30LCoCLblatlOdVD28ZhGZHvfupgNDJbNOArNGbDcTaEzHQLfQ8vOR/FGKCys1XIvTwyNVwi9fS2+hju1i1RhbB/uyFWhPbnXvIJOMVL+Oh4G3AHfGf/96xPs/FZGvEpu0qAeeS9dIJ9Hr52GX5NM/M5/+aec+HTUTKnb0oh1tynqZQY/EEZ8fe+2SM97TojZq086M2qEXF6PmziBa4K7YDREu81GwYjEAWkcv5skG9w86CkbdHFRPL1RX5vSESiJhKT8DrgAqReQk8BliQveAiLwDOA68FkAptUtEHgB2AyZwe67M0IphoM2bQ9vGaVjj9KBtA1pXFRFYUEiwbS6+J7ZlvGTj2UjgtMGZqpOb84jECoTXTKPj0li3caBKO3NQxYb8BRsACPRYBP+4PVbo3a2iUZqOVJbTsbzUnfZHIVKgEYkfr/hoEGlodLcoVry+s5afT9sNi1Hx8x0tErSIwswXAutjBbrL9oXQNu2JFZ3PEXKiEHexlKv1cpVr7euVFXS8tB4zX4a/oEQQBUXHowSffCHjsU9aURHMm4lV4Of4tacndcr2KEp3d8f+UAr7hQNTTgCNujmEFlbRucgf+z4TGSNTIDZM29yP0dYHLW1YXd2O2hV56RoGK4ykrjEnEQXl/2jAPHbCtWPYl19E48XxoaCJ/k8V6zHNfKQDaWjG6ux0za6RnBeFuN1Cryin+8p6ogXJX4VKoGeOD3XlcvJO9mLv2OuChediXbGKjnkBeuaf+1nHMqFjWWncQKhYuhaxFCVPHJj0Y496VRUDq+bQssCP7U9yZwGlQ/P6AqCAgqYqSn61zdkHmST3QHUaJTA4fxrGiUZXHoLq4gtjYpfo/yhg++D49eXkN5VRfDyC8fgWx+1KhkkreBIIoBUV0nFtPdH89K7C3pkG/TVlVGpL4dAJ7N5eh6w8jVZUhMyo5viN0zDzQRkJeN4C7csFEHpnL2bmvQexu7pR4bDz9gWDaKUl2NPKOPrK8lG3mf2HPoyjzdg9vdihkKPH18vKaLlxAdFCZxSlv0bDfvVKyh7a4Yit+pJ6BsuyP2MaqvZRognKdrBREexLLqTpkvzExe5su6YLoZoAVYG1BP+4FWWaDhqYOJNW8Fi6gOa1xY41ZxvQsq4EY0UJlU8cd3RwWK+qoul19YRmKMaI4pmQcLni0PvnU7ZbUfrA886Om2xYQfviAtpXxG2T0e+mg6/LB+oo3SeU7x5E+5szs4dGTTUt181zTOwAEBiYpqFdv4LS3+/G6ulJqznlNxwPP8kV7EsupPFFDsTKCrSu9FGprSL4u03ujjWOwaT8ivTi4liMkguYQWi/fBZGTbUj7WnBII03D4ld+nQuFXpevcqRtoxZM2m5/WKO3FhA+4Uq9nQfT3Pin3ctVhz9f0Fabr8YfUl92rFi0boaIiXu9BX7p2t0vmIp4ku2j5ybKA24aMmE2yXc3sVxz85B2pYbRK5Z7WibiTLpBE+vKKfj+qWEi90bTIkWCC0vm5e26OmVFTTduoqBGmefdL2zNfSqqpT318vK0FYs5uC7Z9GzwMYKJG+f7VP0LLDZ//ZKGj+yPmV79AsW0bK2IKV9EyU0TaPv+otS3l8MA6swd4LnwxXB9BsRwb7sIhouL0A53VMX6J3tQy8tcbjhiZl0ghdZMTftMbtEsH3Qt3ZOWm0MrK5joNp5tz5Somi8uT4lkdGCQZresIT9byvFzE/fNmUoQjNsGt5Yj15WlvT+LReXO3/DnY2A0lO/ZrSSYnrmOiAyOYTauILGS5OYoEiSgSohuqzOncbHYXIJnqZj+zL3L4Wq9FiXLQWMmmqa17jXjRqoUaja5ARPy8+n6V2r6Jnn5Ih3jL7ZNifekXhXSwwD88rVGXl4QczL0+IBvMlid/dQfHTypGwSn5/ORalPUCRKy9r8lB6C6TB5BE8E+7IVdM/1ZeyQtgEDs0tSGv8ZWDELywEPajyOXl+a8PiZXlbGqbevpLfOdu1CD1cq9KULE9pWmz+XthWBjF2htg/sYGrXzmTz8KwNFxCa7v6DxswDjMzOm04awRPDR2d95i+6njk+tMLkx5jc9O5SYnoVPfPdEzsAK6BojUfhJ0SGY9q6FhfGAr49MkbP5fMyerxJI3jnE3r1tMyEMGhgTE9sYiVck5kbvXMpyNrlGTlWspQcGkgpxlJKnAt/mmr0zchs7KIneFmg86p5WHnuxyDZPkXLNQlMrGg6x6/JjMepDIVt5OZlJ9HUVid0r3ImRCkX0AoK6KmbPN3zs8nNK88jo/TctBbly1wQqB0Y/6kuhkH7utTDalJBLBArtcmaki2nHLYmdURB3ubDqe9fWEDfzMmbSdkTvDQJdtqoSO5kg0iFwTIto6sEjr7Cj1Yw9rinMk0qNrdlziCg4JSN2pJa9mDV4/xSw5RRYDucFGEy4QlemhQf6MXu78+2GecVlVuZeL2vncFlR4q0ljnZPX0UNpzfD72pgid4aVDQYqFeyN1kh7lKxzI5I8dfthELih/dnfL+KhrB1zngoEWpU7a5Ja2F+VZLKzXPOp98IlfwBC8NxCJrWR/OZwqPgYpEx9+oo5tge2a8vJKjJnZfX1ptaC2dlBzoR7KcXlImOq8ToRRaxPnA87Eo25+mvUkyaQRPmVEqt6d30SaDHoGC546mtG/5E0fQB90fGNaiwrQ/HZ9wuxm/P4kWzdxAdeX20ITZXKzWVvJa3X+YiAWFLzSnnbnDbDqFPL8HzSRrolfQFMU61TLxhjmC2OlNsKTCpBE8lEI/2YqvPzNXW9WTjVjNqV1c5qlmJANJivMbFWbDxDWUzOMNkKGHuq9Hw+hIbMwz2DqAuKx55XsjmEeOOdKWMk2Kf7eTvLbMe/35rSaBph5HciH6OkLoGVgpN/0fAxmvGzN5BI/YU7aw0f3B44JmC7st97MLV/85Qc9F2UzbkhnFKz6isPYdTGhbtfkFpm12b0JIH1Dk7XE2pESrqiBUlfk0k8Fn9mPtOeBIW9aufeS1ues4BDoV/oNNrh5jNCaV4AH4nt6N4eL4sb9Pkf/o9rSzHs/5lXthF2LB9KdM7CMTd2cBUIqSrS2ud7PFBn9fcsJq7D2OPujCzacg2KUwT5x0tFnzeANlv9pJxeNH0CPu9zY0C8q3dWI5nIW74jd78bkUbePrhZqf7cZsynz84qQTPHtwEHExk2rRsUFnUqg3NpPf6I7A1DxjEvjdpqQmVKyDR5j38x70AfdEr/J5KPj5s0ntY3V2Mv2RBnx9zn6nBU02Jb/a5mibANgWdn8/5qlmSv9+jOLDA66N6YmC0h0dWLv2OZ492OrsZMYDBx2fOAq2K2Y8cNDxAkqJMukED6B8U9tYWchTJr/VpuaPDcjTztQ5tbq6mf7AAQLtDgqMDdXPWQQefT6l3dWWXcx7sAcxnRc9saDir6l5U+bR41Q/egLNiQk9BfmnbEof2e16JTqz6RTy9HbKnzzueJxeYUOE8iePu1oD1mpuofpXhxz19IqOmymPfTvBpBQ8a99Bpv2tFd2hcCItCgW/2YJ59Lij1aCs1laKj1mplrE4g/wmYfpTJnkPb0rLRrV1Fwt+2oPR75zo6YPCvIcG0+o+midOMuPXx9Py9Hy9iqITFiUPbk67hkUymA2N6E9udUz0ik6G0Z/cmtCEVLpYzS3MuHcPhSdVWhMZ/i4o22cR+ENqD2OnmLRFfKx9BwkuLqe/2plsDMpyZ1q14KHN2L618epjyePrFaqfCxPYfMCxm1ht3UWddgGHbirGTnONrdgw53cDyD+2pW2XeeIk1Y/phOdU0LoymFT6KCOkqP7TScxjJ5x4viSPUhj/eIHyhXUoEbqWl6a0nK+wIYL+j51ksp601dlJ6f8+TfmKxZy4rjxpuwOdium/OpKVMbuzmbSCB2AM2PhCGpZfsJP4TzWT4QFnyycYYRcvLtui+KGtlP2llIbXzSdSAlZw4uNpUUEfgDn3HsVsaMRpOVbP78b3so2EK1L738WOjdlVPHHU0QvdPHIM/ehxal8op+/S+fTV6Fh5YyifAl+/onJbH9qB45hZXmOqopHYeBtQdrwYNGFgw0LM/JiCKA3MQOx/MQYVtk/QogpRULz1FKqzC7t/IGvB7vaOvcxuqiK0Zi6dC30oA6xxFsxoUTD6oeb+vZgZKsI9EZLJJ8VYFEu5Wi9Xuda+vnA+kdpYwZC+Gf4xi3IHO23y2qL4WkPYL8SKbht1c1BdPRmrmq4vqadrRQWRIqF3jJT/JfuhdH8IeXq7u7ZUT6P9mvl0LSbh+ha+Ho2SgwrfgJ30BEUq6JUVhNaOnkRSi9r4Hstu4edk0IqKsJbPQ0wbntuJXj8P++hJZ0tuOohRN4feC6uJ5mn01GmIHeu2Dk0aFhzsGb6PMslj6udblFJrRvtsSgjeSIzpNaiCPAC6L5pGydYRA6id3VjtuRFfpxcXo+bNHP3DvYddH3A/w5alC7HzE8uXp/UMYO0/5LJFHrmElp8P82YjluVYLGA6pCV4IvJD4BVAi1JqWfy9zwLvAlrjm31SKfX7+GefAN4BWMD7lVJ/mMjATAreSMQwvLWwHh6TjPEEL5Hhxx8D147y/teUUivjP0NitxS4Gbggvs9dIpLZHM5J4Imdh8fUYkLBU0r9FUi0n3cDcL9SKqyUOgIcBNalYZ+Hh4eHY6QTh/c+EdkhIj8UkaHikrXAiRHbnIy/dw4icquIbBaRzVEmb/4tDw+P3CFVwfs2MB9YCTQBX4m/P9r056iDhEqpu5VSa5RSa3zkTjJIDw+PyUtKgqeUalZKWUopG/gep7utJ4FZIzadCbgfDu7h4eGRACkJnohMH/HnK4EX4q8fBm4WkYCI1AH1wHPpmejh4eHhDBOuPxCRnwFXAJUichL4DHCFiKwk1l09CtwGoJTaJSIPALsBE7hdKZWBVJceHh45gaaj5Z2uayvBAMduXTzmcrS6e09gt3VgDww6uk59LKZc4LGHh4fzGHNmEZ1ZQfe8PFouPku4xlvzHJefmr9qFB0fxHesFfNkQ1q2jBeHN6nX0np4eLiMCJ1v3kDvXGFwugnJruqOi+Gpy21O4SevYQ5FR2dT+pOnHTcVPMHz8PBIAWN6DX2rZ9P4Ih2z2Lmu6ECtyUAtdCzfyMwnTPx/2OxoclNP8Dw8PBJGr6qi7+I6Gi/TsAptkvboEsQstjh6ozCjaB0luzodS3TqCZ6Hh8fEaDpaMMCxd9UTmm2SqTJ3jVcplF5O8aGAI6UVPMHz8PAYF/H56Xj9atrW2Sg98+vPmy63aV53EYvuasY6eCSttiZlincPDw/n6LppFa0bLZSepYgOATvf5uDba9AXLUirKU/wPDw8xqT/NetpvjhDVdonIFpu0be4HCT1eiue4Hl4eIyKXj2NrgV6TqnEiZdB9OrVKe/vjeF5TDrEiF3WyrKQVUtRusapi4sw82J1Fmof78bOM5Cn3E2Rfz4jgQDH3r6A0JzcyxnZeKmPOX+SlMJVPMHzmBSIYSDLFqJE2P/OQpTfpvZRjYbrLBAQYxARhVLCvqWxFP/16kLX64Ikg1ZQgFoSK2Sid/RhHj6aNVua3rs6J8UOIDzNou1dG5h23w7s/v6k9vUEz+P8Z8MKWi8soOvSWJ0PIYIATTee2xsTUYgvFjt24C0BqhZtBCC/2STwyKbM2Ryn96YNhEtiY1KRUsFeH6usNnCqmrLtsRwdFbucKXOZKPoFiwhVZ3/J6Xh0rLKo/sdMiFeBSxRP8HIQvawM/L6xN7AVVmvr2J9PIfSKcppHiF0yaAVR2q+KAtAa1pltrKPg7wdcr1CnFxdjLqvj4C1BjKoQPt+5wbt5NX0M1sReH7w4CDevB2DmY4rCvx90r9iUptO9tBSzNPdzfhy+qZw5n9WTSjrgCV4OoRUV0feSpZy8zqa6duybricUpOK+WGnCQFcU/c/ZreaeDYy5s+lfWs2x1yg0X/oV3LSAxcnXWdgvr2fxt9wpL6jl5xO6chknX6IRmNlHnvQltF9e0SAUxV63vUk4ccM8Fn91mis2GjNqaLwqt727ISKlyc8eT23BEwEZ0elRtqPr9pKh77XraVmtUbGileoJti3OHyT6rthN3tafh7riYub/uAHz6PGs2Z9RROi9sIaG10Qdn0DUCqLsf0cpi7630LHlTACDr1hHyxoDWdZDUFL/jkQU+SUD7L29mCVfm+98SUw9h6ZkJ0D5FKEb1pD/UOL1j6eU4OlVVdgzp6G27QalOPHJjQxOiz0lSuZ2EX2qnFmPdmJv35M5m+rn0bl2GoM3dVHhS36QuKRgANYOcHRZIebuDcz/+j7Xa+sa02uwZlYN/y3hKPaOzBRcNmqq2f/heZgVzovdMJVh9nyghCVfcUBQRAjduI7mmwZG7bqmSv60fnpWVFISNTGPHHOs3YPvnIlb62MdR6Bnjk5+MrtMlXx4XW/eSNtKxYILT3LqN7PRoiM+FCi5vpF8X4S+SIDe30yn5i8drldNl7XLOfABg6ryXsfa7Hy+inn/sR07FHKszSEGX7GOrnqDnqVRrlh++twc7yuj7XexouGFDTaFDzzj+LEBjJm1HHz3bMw5mSlCrjr9LPp+d1piLoEAh3+8GJ/fnRnPUGsBi+/qceyBc/iLGzFLzhPBA/ztOvN/3Ix14PDwe1M6H55eVkbz6xZT9OomFvkiANTecHTM7Qv9YQpffZTDL6rAPrSR+Z/bij3o/A2mLVvMgQ8aVJU5J3YAZata2fvVZUz/i0bR/ekLjxYMok2vZu8Xyplbc4pVheeOLc4u7GT2TbH3m0LFHLzhIur/cwCOnEg6bGAsxOdn/z/Nxp6RGbEDkLIInStKKdmZWswXwKnbVqMbzn7HI8mv6k/bxvOZSIXFwLxy/CMEbzzOnw57ClhXrCL0fyVU3XSc/LjYJcq8qnbmrT/Owc9fRPi6tWktZzkbuegCjn3WoNJhsRuienYH7csFvaI8rXb0inL2/+dKyu7r5pL5h5g9itidzfT8Hi6bf5CKu0+x9ysXYNTOSMuGYVYuwqpO7jt0gpZrIhh1c1La16ibQ88CC01zd2lWz419DFy/1tVjTBYmreBZL15F8wcGyfdF0FIcJNZEUb/2GPqHm+l8ywbHbDt+XQnF+e56KmUXtXLoQ4tA01NrQNPZ96mFvGjjLnyahZ7kOfRpFles3MPuz9bScvvFqdkwguPXFiF65td0iigaXpGaaHeum05ebWIzsekgojjx8vS9O/PK1Vj5ubFu1i0mpeDZl11E/8e6mVXa5Uh7Ad0k//VNhF61Pr2GNJ2eWzbgW+tunNcQJRe1cfKO5GwWw6Dtto30/34OGzekPy50xfK91N+yj/5H56EvqU+pjfDL1zIwL3vF2nsW5f6YVrBskFMfuhitoCDlNrrr/Cjf5O4WT0rBa/xghLLggKNt5vsinNqgoRUVpdyGXlKM9cZ28vzRiTd2AE0UoXkR9KULE96n7a1rueCtu6gvbcWnOXOjFxgR6ktbOXld1cQbj4IV0NCM88vz0EtL6FySudtL02zMS7tpePeFw2uJk6V8TwiJODd0k4tMLsHTdNrftZFpxe50I+rXHkMrLUl5fwkGHLQmMapndNF9QVlC24rPz8DLepLuviZK6TVNaMHgxBuOQK+eRuNl2b0JVb5J3+uSG9KQslK05d1ntqOEaDTFIYYECa/rQyspTmlfeWo7+sD5JwmNL/LFViclwPn3341D5OqLqLj5BHmGex5U34WpD8Lv+eSclMcT06Fnjo4ExhdbvbKCg3euYvWME67ZMbe4ncOfviipfSQYgMrsdWcBNMOmvzq5W6V/6bRz3pMtxVT9Is8ps0ZF120OfXiRq8fINSIV1vhLMUcwqQQPEXSXZ8QaX5/6TGG2MsYWXNmCXlkx7jbRJbO57JJdrnl3ALoofEt7kIsucO0YucKxG899b/bvOmhd7e4tJ6JQ7jqR5zWTR/BEGCx3/5uePa2D1vdsTHo/vawMjNwdEB6Y5s/IcdbOOE7/3MKMHCtb6BXloJ37Xdv5fowF7sXkTVVq/yRYre0JbTtpBE/8flpTT4SaMAHdJFqU/JhS82sXUz0zM7OzySI+P6X/dDxjx2teq03YxT6faXjTYvJLnZ00yxRleyB4ysDoPn/cRF+flXDGlMkjeLqOVZKbCQs9zmTN5XvRClMPn8gGPYsstAuXpNWG3hvG/2RqEwrJYM4IE31Jak//qsdPUHxYkddy/szWJjMKM6HgicgsEfmziOwRkV0i8oH4++Ui8icRORD/XTZin0+IyEER2SciL03ln0gFyeEuo8d5joDS0vMP9txeQtWOAQb63PVu8wrChKoTG8QfjXCpMOunhxEr90WvaL+B77GtCW+fyDdoAh9RSi0BNgC3i8hS4A7gcaVUPfB4/G/in90MXABcC9wlIq77x3YoxJz7M+Ow9i0Joy+oy8ixpjqqs5u8Xe7ObCZC8V4dtXVXWm3oJVFsXWPej6HkwSKi+9339pLF7uqm+JgJmkbFltzvAIpNUglAJ/yPlFJNSqnn4697gT1ALXADcE98s3uAG+OvbwDuV0qFlVJHgIPAuoQtOg9YMreJyMzE4n6GMAYgYubouIiyaepNPaDaTayeHsr25/5Kh5EYIYVlnXtrBYIRjr7NxuiLUnT/Myz48j5mf0ER6sgn1J7PrH8DeS71OM8hwkeLKP9dainO7N5e8n79HGZDIxXbe9K2xU0kKsy8P7n0XUlJuIjMBS4CngWqlVJNEBNFYCjwqBYYGcx1Mv7e2W3dKiKbRWRzlOzGWWWC0p88TefJ9C/mVGg5UIkKjT2IrkyT8i/l7phawYkQqjszs8hOUHn30wSeGv0BEsyP0LyuCDGMWN7CvYeZ9Vth1u+EttXF2GvTFxktKlhd3RNvOAF6ey/+1hx9SAPF+3XM5pak9klY8ESkEPgF8EGl1Hjfymgd/3MG15RSdyul1iil1vhwZkwjf/sJ9r4wy5G2xmPf1tn4dyUfoCt25sdEbCXM+JtyvU5DMpgqua6S2rSTYFP2bjw7ZDDjseRqiMz8dUNsX1vDts/8f0Mv6kP8fsIvW8uRT6yi7U0h2t/cz8DLepA04yAtS2Puw87kQjSPHqf0gCNNucKMJ9qTTomV0JUnIj5iYnefUuqX8bebRWR6/PPpwJDUngRGqs5MoDEpq1LEbDpFsNn9GyP/lJZSEZ0ld57EVpkVva6dlRT+euJBXaM3zN7Oc1cHuMGJ/6lPOivz3P/Zhe3ysqyxCDb4sPYkeecPhokcKmb2V4Tih0ePO+ydZaAv605b5EYSac5Hfz65Sl7jUfazLfg6c8/Lm/aUjrXnYNL7JTJLK8APgD1Kqa+O+Ohh4C3x128Bfj3i/ZtFJCAidUA98FzSlk1CVL/zWYgnQixQ0YlXh9jbdtP7l4mqaTiDMZj8DW719FH6fHa6tfPuTf55bTadYt7HnobndjEwLXMPufk/jziasFZFI0zbnFuJG/Q+jfLtXUlNVgyRiId3CfAm4EoR2Rb/uQ64E7haRA4AV8f/Rim1C3gA2A08CtyulMrYqLM+CJbt3uySZWvoKV5PVncP6ueVzho0DqGIjwU/aEp4e30Qwpa7SbCf3LyUor+kUBzHtqh+ujvjXp4d1sFO44a3LWq/s505/xJloLEQpYSS3xdgD4bRw4w6uZFr9MzNHQ9PIsLCH3akXHcmkVnavyulRCm1Qim1Mv7ze6VUu1LqKqVUffx3x4h9/l0pNV8ptUgp9UhKlqXIjC8/xcku9yYHjrRUUP3Np1Lb2bao2NFDS1tmwhEGd5diHk18rLHmG0+xtXGma/Z0R4JUPaelPJ6otuyi/JnU48uSxe7zUf8jM1YNLp12+vuxdu9nyRdPAtD1sn60YICye54m0pxMCZrxCbUU4Gt1JqX+SPxduRHfanTpLLq7O61qcrn/eEmBooeKHBkrO9ZRRs+3ZtHzrVkcf3QuthKqHkovJkxt2cXCb0boHXB/adW8h/qSdvvLHywgajv/RLeU0BwqovR/n06rneq/taF6/CiXx0KVLdTfG0H+sc3BRmPCoeuK9tddCMDsR2xH/helhJI9hqOlJYeoum8r5Vuz6+VJRFjw0860C2tNSsEr+ekmun4wi+5wcrnXziZyqJiCXzxLwS+eZfo/QvR+ZxaFDyZeA3Ms1OYXmP0FRXuXO4voByI+rAerYGvybn/hg89y5OuLaex31kve9vNllLwp/YXz1p4DLP7UXmb/TMcecL77bZsaWkMQoyGAvsXZqnVmYxNz392E/x9FtK212f+j1dg+Z4TbPFjE9B9sd6Sts7EHB6n68fMs+fQhAi2ZF77qv2ks/te9jlRmm9RlGntu2UDhOxtSytxrK0G7JYqVZJxPUmxYwaF/0h0v5mM9WEX5j9LzpPpfs55p7z9MiT+9AfCwZbD9t0uY8bcQ2t+3pdXW2USuXcvRm2xHsyFXPBak7J70zl0iGDNrab52NlZQCF+RfjjK3I/0pt31TgSjppqOF9fRshbsDNS/mPaUTvmObuxtuxPeZ7wyjZNa8BBB1izjyPWFVK5tpiSQ2M0btgw6fjmT6rufQ5nuJiTQVi7l6Kd08gIR/Ebqczu2Erp2VDLvF72wba8jdvfetIEZ7ztIkS/5wPCordMRzqf5Z3Oo/P5zKc2oJYK2bDGnriin68IoWjD5/9k2NRjUWfT9fiRqofYdQYUzFwgvhgHLF4EG+94XJL848QfMYMjPgv82kagNuw9m1G59QR3dq6ppfLE9euRtmkhYo/ZJRf6vNid97UxdwRtCJFax/kN15C3sYmbJ6FHo+5umISfzKNkHFT98JmN1PsUw6Hn1GtqXC5FpZtJppJqbSsk74mf2nc4LdP9r1tNwpeKyi/YmlBz0SE8Fx/dW4+vWqPvcJpRluX8eRdBLSznxriX0z7aQkonDcLSGIIFOoXJnlMCjz7smyMlgzJvLkTfMwDZAu2B8ry/UWsCSb3a5MmaXDKFXrufk1cqRwbHifQbYYAyotB6SnuCNwHrxKvqnnxnPdeolJkvqGml6cC7T7kpxBtYh9CX1dC8rp3eWTv5Lxu9O9/11GiWHLIr3dTtWeX40JBCg83WrQKDibceoDI5eM2Tz75ZRvSmC/w+bXbNlImTNMgZqJp75LNzVjHnkWAYsSh7x+Qm9fCVqnFrIhYd7Ug7NcBrzytW0rgxQ0GQTLRSUBoEuRdOLJ+7yagMasx81EUUs64kDDx5P8CZAr6xA8vJQ3T1YPbmxYFoCgQnTstvtHY4GmSaCMbMW9NEf53Zza8bt8cgNtIKCWJda1xER7EgUver09dt+zXwqnm2B7rPGqy0Lqy2xbMWJMp7guRtlep7g9Al3AhUOYzZkZEVeUpgnG7JtgkcOYvfH4/9Mc3jh/MgJv9KftJD9QYNJGpbi4eHhMRqe4Hl4eEwZPMHz8PCYMniC5+HhMWXwBM/Dw2PK4Ameh4fHlMETPA8PjymDJ3geHh5TBk/wPDw8pgxTeqXF4P9bR7j4XM0vOhlGezLxauYeHh7nB1NH8ESIXLOaYy8/ncDw4jX7qM3rOmfT5ztmcWDX+uG/tbDGgk9uSagYjoeHR+4y6QVPLy3Brp9N86ejrKrey7rA6Jk+RrKq/ASrLjtdC8JWwrE/l7PnV4uY+ccOVzOTTEb04mKkqDAn1wZ7TC0mteD13LKBlnXwmiueSasdTRR1Be3UveEpjtxYwZ5fXcysXzVhHTzikKWTE7XxQhquKGBguoUxbQDf9rnjbj/7Wzuxe53N/uzhMZLJmR5K0+l64zrq371n1C6rE/zx+GJmvLsLq6Mzo5lmcxm9uJiBixfRc3sswWpdaQeXlydewPqnx9cQerSa2vtihaTt3j7v3HokzZTLh9f51o1c/v5n0Bys6D4aYdvgt0+spf7zL3ieCXD4pyt5z4q/4pPUEwFFlY4Vzxn+3T9czcwnLAK/2+SUiVMGWbOM7oWJFYkqf+II5qlmly3KHFMmH56sWcbBm4q4/LKdrosdQEAzefVLnuYhayN1d7hf+CXXEc1OS+wAfGIxVHn2A9c+wtErKnjomg0s+mF3zmT47bllA6deMn4qfaPNx7yPZ/aaiFy7lqM3xh4Wy5cc5+MzfpXQfnfc+ErCHXOY+5Cd1WzVmWDSeHjassXk3dVOfVGrQ1Yljmlr/OZP61nwH7tyJmOy22gFBTTcNxv+Vkbt3Ts5/r7l3HLLE5ToA64cb1+oht/vvoDFHz2B1ZrZ71gMAy5cxMGP+Lhtxd+Y429jrq9t3H1CdoBNA3Xc/81rqP5LC9b+Qy4YJmgXLmH/W4u58bLnqAl0Ux9I3VM7EK7md43LCX68AO3QifP2Wp70XVq18UKin+9iXWV2axT88k8bmf+pqRO+oq1cSv8XB2jYXc0Hr3kkI8f82uarWPzho1jtHa4fS19Qx7HXTSdaqLj3lm+m3M697Rez54MXOF6msvMtG3nfJx6kWHc+rf6Hf/9GFn5ks+tV+9xgPME7/1daiNB0aUHWxQ7gZVduRisvdf04WkEBenExenEx9mUX4fvLdDp+uxDGKfriuA3BIIPV+cwtbs+Y2AF8aM3j7P1KnevHOfb5jRTf082P3vWNtMQO4I0VT7HiGzs4/NOVSCCQvnEidL5lIzd+5AlXxA7gP679Pw7+51rE55944/OICT08EZkF/C9QA9jA3Uqpb4jIZ4F3AUP9i08qpX4f3+cTwDsAC3i/UuoP4x0jHQ9Pu3AJi354gICWG0+iB3euov7Nz7vStlFTTefldbziU3/mhuJtAGgoSjWbw2Y+H/3Ue5ERhaI0U1Hwy+dcKZN47IHlvG3JM+Rrmfdmd/TN5ORtc5IqzpwskZeu4aP/cy9VunOTUbbSeP0j76X+9mdTbkNWX0DL2mI+8qEHKNDcncGOKJ07HrmFRZ/edV5NyqU7aWECH1FKPS8iRcAWEflT/LOvKaW+PHJjEVkK3AxcAMwAHhORhUopV2p4HLyllBU5InYAmuFONXYxDI58q4rH13151M/nGSF++cUzPzts5vOFhzegohEO/ddGyl+AsntSH0jvetNGKn6zm9DGhaybtS8rYgewovAkB75URfDjF6C27nKs3a43baR1Q+z7e/0lTzkqdgCa2Lx49S7+/M31LPrY9qQrvMna5eR/5RT/Ov3Xjto1Fn6x+Op19/JR843M/0h6sayj0f7OjXRcOvo1VLI5wLRvOV8ydULBU0o1AU3x170isgeoHWeXG4D7lVJh4IiIHATWAY5OWZlXrqbjA/1cPzP1p6UbXLVgH8+/fSPlP3Tm3xXDQFs4j8OfDfDHdd9Oat9ZRohrt7XwvXuvo/iw4kv/+l0+JrdRdk/yRcYHblzHiz70DH+31rP6Q1tZlH8qqf2d5tW1W7ln9XVUbBPHPNjKx45w7UdP8PK49+wGt1X/mXe94kneOfPNzL71VMIV8/SlC1n4nT1cUZz5VT6vuGIzB2qq0wpdMWpnYJcVD//dcnEZP/vUl1noKxh1+yMv7uOpf5oDwGd++1rqf9SF1t2HeeJkyjZAkmEpIjIXuAh4FrgEeJ+IvBnYTMwL7CQmhiMfBycZRSBF5FbgVoAgExdOPsfwJ7bQ84oNGLPd8ahSpdQ3QKTIubG0E/+8jsfe86WU9vUBNxW9wE3veWH4vXs/92XeqD6atKcXzdeYHejg9Z/K3HjdRLzq/U/w9weqHZlN1OvnceL6Gq7zOecxjoUmNj+86Me89T0fYNYXEvNiOr5sZ0XsAK4o3svDn3oD9f+UvOBJIMCJD6/m8lc9z121vz/r09HFDqDOV0idL/YweMMt34Fb4NMty3nogcuY/d+pr8hJeNJCRAqBXwAfVEr1AN8G5gMriXmAXxnadJTdz3kEK6XuVkqtUUqt8ZH8QK51xSrqV56YeMMskPfSFoy6OWm30/Thi/nRrd9wwKLTFIni05++h863bExqv/K/neR/dr3IUVvSJahFOfSxC9JuRwsGsb4T4fvv+wZr8w47YFliXHn9FvSF88ffSISuN2/k+pk7M2OUg4hhsO+u5ex437e4qzb9LvG/TdvJrvfdxaHv1cVChVIgIcETER8xsbtPKfVLAKVUs1LKUkrZwPeIdVsh5tHNGrH7TMDxVeOhaj8XluVmUejLpx/ELk7eax2JUVONfnkHs3TnB6bXBlq453NfofOtiYueeeIkkdb0/ien8YmFsSR97y66YSkfmTPuvJorvLny77RcPm3cbWTVUt7zyV+wNC+717pRNYBRU53w9nppCQd+tJz9134XXZwNBtl12Y84fv9i9KqqpPed0BIREeAHwB6l1FdHvD99xGavBIb6TQ8DN4tIQETqgHrguaQtGwetoICmq3Khjrk7iM/PkW9V8fuLvu/aMUo1m7d/7OHEbVqzjDkLsztu5waRl67hkm88S6keysrxX/+B8YX2wBuLsmbbSL60+pd0XTY34e33fn0Bh676ET7RJ944SXyis/viezlyVw1oybWfiPReArwJuFJEtsV/rgO+JCI7RWQH8GLgQwBKqV3AA8Bu4FHgdqdnaCU/n1et3uJkkzmFNqeWB9d8z/XjXFmwnyN3TuzlHfz6BprXFfOqGdtctylZXjl/B+3vSK57PoQYBo2X+VydpJiIVXlHOTzWdyDCTVc4P1PpNge+tZ49V3/H9eP8Yf23MWbNSGqfRGZp/87o43Jnj0CO3OffgX9PypIM8eDOVShT43UX5eiawXXLWfnd7ZRr7nuwRaJYvPEI5sL5Yy99Wreci1Yf5NKrD7puTypU+3oIl6U2SSQX1POTN6QXVJwu+VqYeWtPoC+px9pzZmaZ6NWrqfQ9kSXLkkfLz6fh3Su5bv0WAuKbeIc0mW0U0v89ncA1ie9zfq60UDZRlZqrPOtBg6WfPMHf7tzAto6ZDht2mn3vKp54o1E4fm0R/1SRuaf6d+t+Tvv6sceRTlxdxOXlB9DPnXfKOr1WkLsefHnK+ystNy7/L8x7iLb1lee8f+S1wrxASxYsSg2topwtH/lvvlWbuVCxf5n/G/peu37iDePkxjeeJHZ3L4//cm3S++3rqcbfE8WuLif6pg6WlbqXgVcrSz4oV1uxmHvf9nXnjZmAL3zm++ilJRk/bjrs6JvJHz55OdP/nvqkzpzvZm5GdipQ9n99rozZjcdVeRaNL1ZowWBC25+Xgic+g4Ha5Lt8B9srObU2D7X3MEVfL+JQX/KzPIlS/6Xk1zgqXWeGnvnVC7OMbnB4Js1ttrfNoOBIN+lkAZsV7HTOoClO6FXreVv137Jy7CM33o3MSay3dl7mw7NDIWr+KnDx+Nv98QcX07Uygt7pY8Hq4/BsCetes4NT91fie2wLfeYq2u7spzKBOhceuUV7ZyFVHU1Qk1iSSw93abxMuCove5ETZnnBqBMNZ3N+PdaTJFoAi969jfkfe4bG386h9otPseWnKzh+cywoWP/L8xz95CJXx/KSofHK7HQr/WLT9dJFWTl2KjRHi7H7DcxZ7nnoHucXr/rBYwltN6kF7yWve46m29eBUkz/amwioPqbTzHjy0/R99r1GHNmoVk2pnL2NDz41HrkZPLLcKwsZeLJF6h57/gJKn98eD3fOzCBS50hokqn6ikDnjv/Vh+MSe7NCZ3B5/e8nNIt41zTmctMNiqJZto+bwXP32NxIlQ27jYBzeSyN24h8GQN5lWrh9/XVi7Ff+sp8u4doPo/j7Cm4rijthXt11NKUDnr0W5H7XCCYIeizSykuzefmf8c5oX+5OKe3OCJb26kYmsn4vNjfLKZYEeOq8UEvPGZd1Lx4PZsmzEuXcdKMQ8fHXuD8+QrOG8FL/DIJp59duJuWIERZknxKao/f5jIS2MpsrSuPk60ljG/sM21qmaThapvP80jJ5fygQv/TOul1Zh2ZmfhzuZ/dr2I3jroXVhCz6tXcaS1POXMND967ApnjUuR6KCBHcr+aoqpwHkreABaRLBVYr70rPxOCj7RwKGfrqTxG/m8esk2V2z64/HFzPx1eilsMk1IQde/jZ3soOirxXz9+SuZ9qfjdEcTm/53i4XVrUTKbQp+/ixN15jM+Z/UBXjhD7vosrK7Pnjn4CwWf8OdOiBO8VzfPBZ/pyvbZjjCeS148z+9iZ9vGjWx6ahcUNLEq5ds45rZ7qTZsZUQ3lyOeTS1LrLe3c9/t2d+nCyiNIKbxh7DMx7fQv3bdmKebKD3n7Pbpb26cg+L7o53/RX4tqdeHMd+YS//+tl38PzAXGeMS4Gv7HrJmJmbi/b6aDezPwt9//a1WLv2jb9RlsfwEuW8Fjxlmiz+dn+2zRgmbBvM/cYLE284Bubho/zqF5c6aJFzDBVzkWh2kzZ89emrkRPO1VAtufcZ7jm2wbH2kuFtz7+VubePvZJi+lef5tDg+NlUMsHi/5o4bGvub6I83J9b2XRG47wWPACJmBzpr8i2GTQMlLLlS6ux0sz97++GxgxP1978tY9idXUltO3AjLGTNrpNc7SYqr/7sDpjAcNLP3Ui7fMNUPYB6LAy60m1WkX4nizBah5n6ZhSbOmYnTmjRmFraA5EohNuZzy+hWf6FmTAotG5758SW2J43guetXs/+36e/Riy555cQuEDyadOP5vq/36KN9/9QUIZmvX6attl1Dzbl7DdDVdo/OToOjb1pJ/gNFk2tc+hfNdpb8M81exIenf7yAk+sOWmtNtJlKjS+dgP3k71NydeMy13jB+J4DYP3XM51oHEluA9+KdLsFR2MpAHTyQW4XDeCx5A7e9O8cixJVk7/vbOWubf59wypdnf3M6pDAymPzU4g523LYNndiS8z8LP7abyn4WtpzIfrP2Kmp2oOzs5+HVnu6AqGmHBB1t486a3Yzsck3k2g8rHO37yPmb9V2IpIrUDx/nQE7e4atNYfPv4Fcz8TeI5EBd+7Qg9tjtlI8ciqizqHnkn6mRTQttPCsGzDhxm5m3tDFjup6Q5m783z0O7LYD9gnMTIXZ/P59+7238pn+hY22Oxn/suxa1KbngXaunB2v3fpcsGpufHl/D/SdWo2s2i+5qnXiHJDGbTjH3Tft5qHv1xBunwVueeCdzPvdswgWura5upv3D4At7ryOSYoagVBi0fRzZNCth7w5i5/CKL3/URavO5RV7b2DRbduw+xMby58Uggdgd3Tx9x+s4dcHlmfsmH89NZ+iT+cndVEkiv/RTdz3sVdw2YPuXEDX73g71W9P3SstfKCYrz1xrYMWjc13911K+e0WJe9TWB+vGDt3X5qocJjfPuDeLPnucC2zf62BndzET+n/Pk3Va47x8ccz1+3+1CM3Me/Tm5Leb/o/evhk8woXLDqXTitEx32zEn54QAKFuDNBOoW4z8aonUHTt4u4etYE0+hpsr2zFu3dQdduviH0BXW87rf/YFXwOFUO1N+1gFftfBuVb+8ef8A8EduKi1FzZzDw5UFeXbs1bdvO5tBgFTs/diHB3Q2YTZlJLy8+P8c/tob/etsPHatL22EV8nxoLn/8+IsIPJK8iAwxcMM6bvrPR6j1uZflpd8OxMoifjb14tv6gjquf/g53l3qXh2OI9E+Xvv5f6biB+cGnY9XiHvSCR6AMb2Gw9+s4voFzq+1bBgo5dm/LWHBTzod7cZOeNw7LqbkilP8fOn/ptzG19sv5YHn17DovTtRYeeKAxm1M9j7z7PZuG4v60uOONbuj795HZXfdbScccI0fuxi/vu275CvpXeeBpWP93zvvcz8T2eSuna8fSPtV4T56sYHHGlvJF88+FI6Nk9j7r+kf871hfM5+LlCfrT+R1wSdLYjuSMyyDs+/6ExV9hMOcED0BctoGtlJcs/sp1iYxAtncRpxGLsAJ77rzUU3e98FfZEMGpn0Hr1HMKlwq8+9CWCSQR7/r5/Af/3jpciT7m3ZtN68SoGqmIhNXUfTF78BpWBjsKKR7H+3zeuoeJ72RE8ROi5eT3dr+7jO6vuJSgTh2aMZFDFxpPfdd97mPuZ55Luxo6HXlrCnjsX8W8v/gVBiaJLejOjg7aPu45eQeH7dax9zqby77llA4/+19co0fIcaS+solzymfdT8f2xr4spKXhD6GVlNLx5CeFLeqkp7WV91dGE9+2IFPC3Y/OIhg0WffgkmGYsXi3b50yEjrdtYNE79/C52t+SP4bwDSr4TON1mLZO523VGfVI9SX1NN0ZG2QvLwhx4/TRhTZk+7n/8GpsJVTcVUDHYj8z7ovZaff1O+qJpoKWn4/MqYW7+rmxZhsrg8fG3X53uJYHmtagPlCMNLZid3UnNcaUsF3BIFpFOS3fLeTK2v1sLExOqCyl8Z0TlzMQ9RH4Uhn+TftT7sJORM8tG/jyv9+VlqcXsiPcceoSnvrOGip+MH7415QWvJHI2uU0vqgIgME1/bxy8bk3YUekgGcevBBREOhQlP8oSx5GIohw/F82YgVH/w71iDD788866l2kgjFvLsdeF1uS1r8wAqZQcDjmAemDUPONp7P/EEmA7jduoKv+zJt21Uv28MEZf+QTh15Nwz9mUnxYUXZPZq+Zwf+3jsZLde585X0TensffvQNBJtjD6I539jpmsidTfcbNtB8lcmRa5MrPfpoKMD7Hno7xgDM+Uxica6e4I2CMbMWq+bcoE4x7THXNnqkj15VBbaVUvqsXERfOB+zqghfQ0fKa6idQAIB7FWLJ9xO33Ew4RAOp9Hy84muO23j8dss7t0wugC+a/ubqfp6HkZvGLVlV1LH8QTPw8MjN5FxBqJT1KbxBO+8rGnh4eExSciwwzVpAo89PDw8JsITPA8PjynDhIInIkEReU5EtovILhH5XPz9chH5k4gciP8uG7HPJ0TkoIjsE5GXuvkPeHh4eCRKIh5eGLhSKXUhsBK4VkQ2AHcAjyul6oHH438jIkuBm4ELgGuBu0QyXI7cw8PDYxQmFDwVYygJmS/+o4AbgHvi798D3Bh/fQNwv1IqrJQ6AhwE1jlptIeHh0cqJDSGJyK6iGwDWoA/KaWeBaqVUk0A8d9DuahrgRMjdj8Zf8/Dw8MjqyQkeEopSym1EpgJrBORZeNsPlpgzTlzzyJyq4hsFpHNUbK7fMjDw2NqkNQsrVKqC/gLsbG5ZhGZDhD/PZRr6CQwa8RuM4HGUdq6Wym1Rim1xkcgecs9PDw8kmTClRYiUgVElVJdIpIH/BH4InA50K6UulNE7gDKlVIfE5ELgJ8SG7ebQWxCo14pNeaCThFpBfqBNif+KYeoJHfsySVbwLNnIjx7xsdte+YopapG+yCRlRbTgXviM60a8IBS6rci8jTwgIi8AzgOvBZAKbVLRB4AdgMmcPt4Yhffp0pENo+1HCQb5JI9uWQLePZMhGfP+GTTngkFTym1A7holPfbgVEXwCql/h3497St8/Dw8HAQb6WFh4fHlCGXBO/ubBtwFrlkTy7ZAp49E+HZMz5Zsycn0kN5eHh4ZIJc8vA8PDw8XCXrgici18aTDByMh7dkw4ajIrJTRLaJyOb4e2MmR3Dh+D8UkRYReWHEe1lLzjCGPZ8VkYb4OdomItdlwh4RmSUifxaRPfHkFR+Iv5+V8zOOPdk6PzmV3GMce7Jyfs5BKZW1H0AHDgHzAD+wHViaBTuOApVnvfcl4I746zuAL7p4/BcBq4AXJjo+sDR+ngJAXfz86Rmw57PAR0fZ1lV7iIVFrYq/LgL2x4+ZlfMzjj3ZOj8CFMZf+4BngQ1ZPD9j2ZOV83P2T7Y9vHXAQaXUYaVUBLifWPKBXGCs5AiOo5T6K3B2kYesJWcYw56xcNUepVSTUur5+OteYA+xtdlZOT/j2DMWbtujVA4l9xjHnrHIaLKRbAteriQaUMAfRWSLiNwaf2+s5AiZIheTM7xPRHbEu7xDXaSM2SMic4nFhOZE8oqz7IEsnR/JseQeY9gDWb5+IPuCl1CigQxwiVJqFfAy4HYReVEWbEiUbJ2zbwPzieVEbAK+kkl7RKQQ+AXwQaVUz3ibZsmerJ0f5UJyDxfsyer1M0S2BS+hRANuo5RqjP9uAR4i5lKPlRwhU6SVnMFplFLN8QvZBr7H6W6H6/aIiI+YuNynlPpl/O2snZ/R7Mnm+RlCOZjcw2l7cuH8QPYFbxNQLyJ1IuInlin54UwaICIFIlI09Bq4Bnghbsdb4pu9Bfh1Ju0a5/gPAzeLSEBE6oB64Dm3jRm6eeK8ktg5ct0eERHgB8AepdRXR3yUlfMzlj1ZPD9VIlIaf50HvATYS/bOz6j2ZOv8nINbsyFJzOpcR2ym6xDwqSwcfx6xWaLtwK4hG4AKYpleDsR/l7tow8+IuflRYk+8d4x3fOBT8fO1D3hZhuz5CbAT2EHsIp2eCXuAS4l1cXYA2+I/12Xr/IxjT7bOzwpga/y4LwD/OtH1myV7snJ+zv7xVlp4eHhMGbLdpfXw8PDIGJ7geXh4TBk8wfPw8JgyeILn4eExZfAEz8PDY8rgCZ6Hh8eUwRM8Dw+PKYMneB4eHlOG/w/5fRo6Q4TaVgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available number of cpu 16\n",
      "Total execution time 0.0860135555267334\n",
      "Available number of cpu 1\n",
      "Total execution time 0.00099945068359375\n"
     ]
    }
   ],
   "source": [
    "#Now let us try multiprocessing for splitting the jobs that requires multiple cpus\n",
    "\n",
    "if __name__ == '__main__':\n",
    "        starttime = time.time()\n",
    "        image = data.coins()\n",
    "        return_labels, label_img = threshold_and_show(image) \n",
    "        nthreads = os.cpu_count()\n",
    "\n",
    "        print(f'Available number of cpu {nthreads}')\n",
    "        with concurrent.futures.ThreadPoolExecutor(max_workers = nthreads) as executor:\n",
    "            futures = []\n",
    "            for new_label in return_labels:\n",
    "              futures.append(executor.submit(relabel_map, image = label_img, current_label = new_label ))\n",
    "            for future in concurrent.futures.as_completed(futures):\n",
    "                   newimage = future.result()\n",
    "              \n",
    "        endtime = time.time()\n",
    "\n",
    "        print(f'Total execution time {endtime - starttime}')\n",
    "\n",
    "        starttime = time.time()\n",
    "        \n",
    "        nthreads = 1\n",
    "        print(f'Available number of cpu {nthreads}')\n",
    "        with concurrent.futures.ThreadPoolExecutor(max_workers = nthreads) as executor:\n",
    "            futures = []\n",
    "            for new_label in return_labels:\n",
    "              futures.append(executor.submit(relabel_map, image = label_img, current_label = new_label ))\n",
    "            for future in concurrent.futures.as_completed(futures):\n",
    "                   newimage = future.result()\n",
    "                  \n",
    "        endtime = time.time()\n",
    "\n",
    "        print(f'Total execution time {endtime - starttime}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "import concurrent\n",
    "from tifffile import imread, imwrite\n",
    "inputdir = Path('/path/to/dir/')\n",
    "outputdir = '/string/path/to/dir/'\n",
    "pattern = '*.tif'\n",
    "files = list(inputdir.glob(pattern))\n",
    "nthreads = os.cpu_count()\n",
    "def channelizer(file):\n",
    "    image = imread(file)\n",
    "    if(len(image.shape)==2):\n",
    "          newimage = np.zeros([image.shape[0], image.shape[1], 3])\n",
    "          for i in range(3):\n",
    "              newimage[:,:,i] = image\n",
    "    else:\n",
    "        newimage = image\n",
    "\n",
    "    return newimage, file.name   \n",
    "with concurrent.futures.ThreadPoolExecutor(max_workers = nthreads) as executor:\n",
    "     futures = []\n",
    "     for fname in files:\n",
    "         futures.append(executor.submit(channelizer, fname = fname))\n",
    "     for future in concurrent.futures.as_completed(futures):\n",
    "                   newimage, name = future.result()\n",
    "                   imwrite(outputdir + '/' + os.path.splitext(name)[0] + '.tiff', newimage)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "e140276ae15c1be7b597ddfede76c3757c35dc6a4240f18994000df39384733e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}