recursion-examples.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oSWO0VYCoMBb"
      },
      "source": [
        "# Recursion examples\n",
        "\n",
        "adopted from: https://github.com/rasbt/algorithms_in_ipython_notebooks\n",
        "\n",
        "https://github.com/AbhishekSinhaCoder/Data-Structures-Concepts-through-Notebook"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V7FEW0bMoMBj"
      },
      "source": [
        "# Examples using Recursion"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "96FF1di-oMBk"
      },
      "source": [
        "**Important Note**\n",
        "\n",
        "For most cases, using function recursion should be avoided in Python are better be implemented using for/while loops most of the time (although, I must admit that recursive solutions do look elegant). One of the reasons is that stacking recursive calls can easily blow up memory or at least result in the popular yet nasty \"RuntimeError: maximum recursion depth exceeded\". Also, keep in mind that Python does not optimize tail recursion in favor of having the full tracebacks for debugging; related to that, please see Guido van Rossums blog posts \"[Tail Recursion Elimination](http://neopythonic.blogspot.com.au/2009/04/tail-recursion-elimination.html)\" and \"[Final Words on Tail Calls](http://neopythonic.blogspot.com.au/2009/04/final-words-on-tail-calls.html).\" If you do like to play around with recursion more efficiently, I highly recommend taking a look at [Haskell](https://www.haskell.org) or other functional programming languages. That being said, below are some examples of recursive function implementations in Python for illustrative purposes."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's pretend we are not aware of Python's x**n or math.pow(x, n)\n",
        "5**3"
      ],
      "metadata": {
        "id": "oF8JoeTQZzaH",
        "outputId": "116f0817-a616-4c2a-f25c-482e9fb5c9cf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "125"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "math.pow(5,3)"
      ],
      "metadata": {
        "id": "a1Xkj1QZZ7ek",
        "outputId": "b1770905-92e0-4700-d133-2df1df63ef67",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "125.0"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cuLUcT3qoMBl"
      },
      "source": [
        "## Review: Running time and big-$\\mathcal{O}$: Recursive Algorithms for Computing Powers\n",
        "\n",
        "As example of the use of linear recursion, we consider the problem of raising a number $x$ to an arbitrary nonnegative integer, $n$. That is, we wish to compute the power function, defined as $power(x,n) = xn$. (We use the name “power” for this discussion, to differentiate from the built-in Python function _pow_ that provides such functionality.) We will consider two different recursive formulations for the problem that lead to algorithms with very different performance.\n",
        "A trivial recursive definition follows from the fact that $x^n = x \\cdot x^{n−1}$ for $n > 0$.\n",
        "\n",
        "\n",
        "\\begin{equation}\n",
        "power(x,n) ==\\left\\{\n",
        "                \\begin{array}{ll}\n",
        "                        1 \\ if \\ n = 0\\\\\n",
        "                        x \\ power(x, n − 1) \\ otherwise.\n",
        "                \\end{array}\n",
        "              \\right.\n",
        "\\end{equation}\n",
        "\n",
        "This definition leads to a recursive algorithm shown below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XcCv162ToMBm"
      },
      "outputs": [],
      "source": [
        "# in case we did not know about Pythons x**n statement :)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "UG3HFVgwoMBn",
        "outputId": "7cce5b50-cf75-458f-e680-bdbc2e5a950d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "256"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "2**8"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ooRHr62joMBn"
      },
      "outputs": [],
      "source": [
        "# so the idea is to reduce the problem to a simpler instance of the same problem\n",
        "## to start with we need a base case\n",
        "## so base case for power would be x to 0 which is 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "_TvCtYc7oMBn",
        "outputId": "b889f0b0-84e3-40b2-c64c-3be618781b15",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "2**0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "6aikZtZPoMBo"
      },
      "outputs": [],
      "source": [
        "def basicpower(x, n):\n",
        "    '''Compute the value x**n for integer n.''' \n",
        "    if n == 0:\n",
        "        return 1 # base case without base case our recursive function will run forever\n",
        "    else:\n",
        "        return x  * basicpower(x, n-1) # our recursive call so we are calling the function on itself on a smaller problem space"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mbNXU95_oMBo"
      },
      "source": [
        "# How to make a recursive function in two easy steps\n",
        "* figure out the base case\n",
        "* figure out how to reduce problem to a subset of the same problem"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "iSC6d3ivoMBp",
        "outputId": "249da942-31eb-47a9-fef3-6120e0959eac",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "256"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "basicpower(2,8)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iHobhQwVoMBp"
      },
      "source": [
        "A recursive call to this version of power(x,n) runs in $\\mathcal{O}(n)$ time."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "xjNZM_oSoMBp",
        "outputId": "260b875f-a423-4d4f-f4b1-a7bd31dcb452",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "221 µs ± 9.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "basicpower(2,1000)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# https://stackoverflow.com/questions/3323001/what-is-the-maximum-recursion-depth-in-python-and-how-to-increase-it\n",
        "import sys\n",
        "print(sys.getrecursionlimit())"
      ],
      "metadata": {
        "id": "a3KGWkcOa9Ko",
        "outputId": "16d87fe6-7a9a-456e-a2e4-763bf0e3923f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sys.setrecursionlimit(9000)"
      ],
      "metadata": {
        "id": "1nG_CYeZbEA4"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "N5fBYZTGoMBp",
        "outputId": "53f87463-8780-4967-af31-e3ea24cb90ce",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "699 µs ± 258 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "basicpower(2,2000)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "basicpower(2,4000)"
      ],
      "metadata": {
        "id": "Oi0AmUPCbVct",
        "outputId": "c7e45aa2-6417-4139-ac38-ceeea6d37e60",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13182040934309431001038897942365913631840191610932727690928034502417569281128344551079752123172122033140940756480716823038446817694240581281731062452512184038544674444386888956328970642771993930036586552924249514488832183389415832375620009284922608946111038578754077913265440918583125586050431647284603636490823850007826811672468900210689104488089485347192152708820119765006125944858397761874669301278745233504796586994514054435217053803732703240283400815926169348364799472716094576894007243168662568886603065832486830606125017643356469732407252874567217733694824236675323341755681839221954693820456072020253884371226826844858636194212875139566587445390068014747975813971748114770439248826688667129237954128555841874460665729630492658600179338272579110020881228767361200603478973120168893997574353727653998969223092798255701666067972698906236921628764772837915526086464389161570534616956703744840502975279094087587298968423516531626090898389351449020056851221079048966718878943309232071978575639877208621237040940126912767610658141079378758043403611425454744180577150855204937163460902512732551260539639221457005977247266676344018155647509515396711351487546062479444592779055555421362722504575706910949376"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "basicpower(2,4000)"
      ],
      "metadata": {
        "id": "yTyLP_9nbRwt",
        "outputId": "9d238149-6455-4e22-ffcb-610bbf3a93de",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.57 ms ± 490 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "YLRy01SfoMBq",
        "outputId": "d3ff6c91-6e2d-459b-e9e0-d309199491e5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4.33 ms ± 1.37 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "basicpower(2,8000)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# if we set recursion limit to 9000 we do not get to run it 9000 times in Python\n",
        "# so 8961 but 8962 does not\n",
        "# same overhead of \"unused\" recursion calls exists on other recursion limits\n",
        "# TODO write a paper on where this 38 call overhead comes in in Python\n",
        "# I will give at least 1 point in the class for this!\n",
        "basicpower(2,8962)\n"
      ],
      "metadata": {
        "id": "nM4AlgH2byMK",
        "outputId": "ca081392-7eea-4108-b85f-4b5a654ba3e7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 350
        }
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "error",
          "ename": "RecursionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRecursionError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-19-e34003a15501>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# if we set recursion limit to 9000 we do not get to run it 9000 times in Python\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mbasicpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8962\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-5-4d2985c3e856>\u001b[0m in \u001b[0;36mbasicpower\u001b[0;34m(x, n)\u001b[0m\n\u001b[1;32m      4\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;31m# base case without base case our recursive function will run forever\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m  \u001b[0;34m*\u001b[0m \u001b[0mbasicpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# our recursive call so we are calling the function on itself on a smaller problem space\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "... last 1 frames repeated, from the frame below ...\n",
            "\u001b[0;32m<ipython-input-5-4d2985c3e856>\u001b[0m in \u001b[0;36mbasicpower\u001b[0;34m(x, n)\u001b[0m\n\u001b[1;32m      4\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;31m# base case without base case our recursive function will run forever\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m  \u001b[0;34m*\u001b[0m \u001b[0mbasicpower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# our recursive call so we are calling the function on itself on a smaller problem space\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded in comparison"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "32ymKx0YoMBq"
      },
      "outputs": [],
      "source": [
        "# not satisfied with performance of our basic power we have an improvement in mind"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "RGkt-jpwoMBq"
      },
      "outputs": [],
      "source": [
        "\n",
        "def power(x, n):\n",
        "    '''Compute the value x**n for integer n.''' \n",
        "    if n == 0: # this is our base case\n",
        "        return 1 \n",
        "    else:\n",
        "        partial = power(x, n // 2) # remember that x^4*x^4 == x^8\n",
        "        result = partial * partial\n",
        "    if n % 2 == 1:\n",
        "        result *= x \n",
        "    return result"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "HEtfv-YDoMBq",
        "outputId": "6c30bf73-9f7f-4353-fcb3-2fa053849728",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "256"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ],
      "source": [
        "power(2,8)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f8jzcIuDoMBr"
      },
      "outputs": [],
      "source": [
        "power(2,9)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ERmAozgKoMBr"
      },
      "outputs": [],
      "source": [
        "import math\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "sxGMW5seoMBr",
        "outputId": "c3e8b82c-892d-4145-9c55-d2d99b469e7c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10.0"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ],
      "source": [
        "math.log2(1024)  # because pow(2,10) == 1024"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "1024*1024 # so 1MB"
      ],
      "metadata": {
        "id": "x5DTZuswded9",
        "outputId": "73994c01-8153-430d-e0ff-f41ae65b522a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1048576"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "rEbLPzsDoMBr",
        "outputId": "7258ea02-a55b-49a0-c230-315de0a2de0f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "20.0"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ],
      "source": [
        "math.log2(1024*1024) # so for 1 million we will only need "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "T1FUC0MmoMBr",
        "outputId": "0918d0b8-66f4-4c93-96a0-4db004b51a53",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "332.19280948873626"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ],
      "source": [
        "math.log2(10**100) # log n of googool more than atoms in the universe\n",
        "# https://en.wikipedia.org/wiki/Googol"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W8LcuM4QoMBr"
      },
      "outputs": [],
      "source": [
        "# so if we were playing the guess the number with yes and no questions we could figure out any number up to googool in 333 questions\n",
        "\n",
        "# not bad when we consider that number of atoms in Universe is something 10**80"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "BqofiscKoMBs",
        "outputId": "b1a873a0-b6fe-4505-8aa2-4cf801951750",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5.44 µs ± 1.46 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "power(2,1000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "3_ghzsDGoMBs",
        "outputId": "6b89d1e8-5bf8-415d-9bc8-480961320691",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4.42 µs ± 137 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "power(2,2000)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "power(2,4000)"
      ],
      "metadata": {
        "id": "WrqMD5FweIKT",
        "outputId": "a8503066-4e68-4a24-de54-0f56cf06c20f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7.36 µs ± 153 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "power(2,8000)"
      ],
      "metadata": {
        "id": "yUOj-U7jeR0j",
        "outputId": "5064477e-9625-4b25-9ab1-649fc8305da2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19.6 µs ± 5.08 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "2**8000"
      ],
      "metadata": {
        "id": "AOOjpCZQeuEm",
        "outputId": "ddce4e3a-1bfd-43c5-f5eb-13ae5e88c5f9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "18.3 µs ± 6.39 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "math.pow(2,1000) # math.pow can not work with huge floating numbers"
      ],
      "metadata": {
        "id": "7DcXPOjSe6mP",
        "outputId": "72201286-7789-440c-98fd-d7b05b799497",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "337 ns ± 6.53 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "FcwzzvuNoMBs",
        "outputId": "828086ef-c680-4536-aad0-b2c9b21d91ae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8.29 ms ± 2.2 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "power(2,2_000_000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pn9pPcELoMBs"
      },
      "source": [
        "To analyze the running time of the revised algorithm, we observe that the exponent in each recursive call of function power(x,n) is at most half of the preceding exponent. As we saw with the analysis of binary search, the number of times that we can divide $n$ in half before getting to one or less is $\\mathcal{O}(log n)$. Therefore, our new formulation of the power function results in $\\mathcal{O}(logn)$ recursive calls. Each individual activation of the function uses $\\mathcal{O}(1)$ operations (excluding the recursive calls), and so the total number of operations for computing power(x,n) is O(logn). This is a significant improvement over the original $\\mathcal{O}(n)$-time algorithm.\n",
        "\n",
        "**Exercise:** Test the two functions with a timer and see the difference. Identify the base case and stopping conditions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QoMcXI9ZoMBt"
      },
      "outputs": [],
      "source": [
        "# so we got the famous stack overflow\n",
        "# technically we could adjust the recursion depth in Python but it would not really help in the long run"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5rbQ--VaoMBt"
      },
      "outputs": [],
      "source": [
        "%%timeit\n",
        "power(2,100_000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r0Y1hn6aoMBt"
      },
      "outputs": [],
      "source": [
        "%%timeit\n",
        "2**100_000"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KhQekXV5oMBt"
      },
      "outputs": [],
      "source": [
        "%%timeit\n",
        "power(2,1_000_000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jSfJtWcnoMBt"
      },
      "outputs": [],
      "source": [
        "%%timeit\n",
        "2**1_000_000"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cTiSTCU8oMBt"
      },
      "source": [
        "# We humans operate better on visual data - 1 picture and 1000 words"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "A6jf59QFoMBu"
      },
      "outputs": [],
      "source": [
        "# in python we can pass functions as arguments\n",
        "import matplotlib.pyplot as plt # very popular visualizaiton library\n",
        "import time\n",
        "def automatic_time(input_array, func_name):\n",
        "    # input_array contains all elements of input,\n",
        "    #   preferably sorted from small to big,\n",
        "    #   each element could also be a tuple, which is requried\n",
        "    #   for functions that need more than 1 input\n",
        "    # func_name is the name of the function (as object, not str)\n",
        "    # this function also suppresses printing output from the {func_name}\n",
        "    ret = []\n",
        "    for val in input_array:\n",
        "#         print(time.process_time_ns())\n",
        "#         start = time.process_time()\n",
        "        start = time.time()\n",
        "        from IPython.utils import io as iuio\n",
        "        with iuio.capture_output() as suppressed:\n",
        "            if isinstance(val, tuple):\n",
        "                _ = func_name(*val) #unrolling the tuple to pass multiple arguments to our function\n",
        "            else:\n",
        "                _ = func_name(val) # just a single argument function\n",
        "                \n",
        "        ret.append((time.time() - start)) # 10e9 converts unit from second to nanosecond\n",
        "    return ret\n",
        "\n",
        "# my_input_arr = [(2,1_000),(2,2_000)]\n",
        "# print(\"testing function_1 with the automatic measure\")\n",
        "# print(F\"run-time for function 1 result in nanoseconds: \\n{automatic_time(my_input_arr, basicpower)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "LKHvPpbfoMBu",
        "outputId": "426c7601-a261-4d35-ee62-48d9f01a3e00",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(2, 100),\n",
              " (2, 200),\n",
              " (2, 300),\n",
              " (2, 400),\n",
              " (2, 500),\n",
              " (2, 600),\n",
              " (2, 700),\n",
              " (2, 800),\n",
              " (2, 900),\n",
              " (2, 1000),\n",
              " (2, 1100),\n",
              " (2, 1200),\n",
              " (2, 1300),\n",
              " (2, 1400),\n",
              " (2, 1500),\n",
              " (2, 1600),\n",
              " (2, 1700),\n",
              " (2, 1800),\n",
              " (2, 1900),\n",
              " (2, 2000),\n",
              " (2, 2100),\n",
              " (2, 2200),\n",
              " (2, 2300),\n",
              " (2, 2400)]"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ],
      "source": [
        "# create some inputs\n",
        "input_arr = [(2,i) for i in range(100, 2_500, 100)]\n",
        "input_arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "9hHMDCdvoMBu",
        "outputId": "816a597f-3f2c-4f82-f27f-26c36d747022",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "\n",
        "\n",
        "# input_arr_t = [(i,i) for i in range(1, 1000)]\n",
        "\n",
        "# fun1 = automatic_time(input_arr, function_1)\n",
        "results = automatic_time(input_arr, basicpower)\n",
        "# fun3 = automatic_time(input_arr, function_3)\n",
        "# fun4 = automatic_time(input_arr_t, function_4)\n",
        "# fun5 = automatic_time(input_arr_t, function_5)\n",
        "\n",
        "plt.plot([el[1] for el in input_arr], results) # we only want to see the i as x\n",
        "plt.xlabel(\"input size\")\n",
        "plt.ylabel(\"running time in seconds\")\n",
        "plt.show() # again we only run each call once so our results are not quite representative\n",
        "# we might see peaks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "WkcUASMyoMBu",
        "outputId": "6fc6bf4d-a38e-4609-93bd-725ece40627a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "input_arr = [(2,i) for i in range(100_000, 20_000_000, 100_000)]\n",
        "\n",
        "results = automatic_time(input_arr, power)\n",
        "# mathpow_results = automatic_time(input_arr, math.pow) # math.pow does n ot like large powers\n",
        "\n",
        "plt.plot([el[1] for el in input_arr], results)\n",
        "# plt.plot([el[1] for el in input_arr], mathpow_results)\n",
        "plt.xlabel(\"input size\")\n",
        "plt.ylabel(\"running time in seconds\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lin_numbers = list(range(1,200))\n",
        "log_numbers = [math.log2(n) for n in lin_numbers]\n",
        "log_numbers[:5]"
      ],
      "metadata": {
        "id": "0kLV8VubhLMK",
        "outputId": "1798262a-f5f9-4b7a-fb59-969dbc97be6c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.0, 1.0, 1.584962500721156, 2.0, 2.321928094887362]"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(lin_numbers, log_numbers)\n",
        "plt.plot(lin_numbers, lin_numbers)\n",
        "# plt.plot([el[1] for el in input_arr], mathpow_results)\n",
        "plt.xlabel(\"linear numbers\")\n",
        "plt.ylabel(\"log of number\")\n",
        "plt.show() # we can clearly see that logn will increase much slower than simple n"
      ],
      "metadata": {
        "id": "0kEX2Sexhbdm",
        "outputId": "d6e5bfb8-7608-4e59-f6ed-3d954c1445fa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hLU_RUzZoMBv"
      },
      "outputs": [],
      "source": [
        "math.pow(2,800_000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NjMsWChHoMBv"
      },
      "source": [
        "# so it certainly looks linear but the jumps in our speed indicates how OS and computer hardware might affect an algorithm in real life"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HPt4DNCIoMBv"
      },
      "source": [
        "## Factorial"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n9sX47EVoMBv"
      },
      "outputs": [],
      "source": [
        "# so again base case for stopping will be 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "OgcptqjLoMBw"
      },
      "outputs": [],
      "source": [
        "def factorial(x):\n",
        "    if x <= 1:\n",
        "        return 1 # not x! as factorial of 0 is considered 1!\n",
        "    else:\n",
        "        return x * factorial(x-1) # so we want to be sure that our problem space keeps getting smaller"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "NRHEyFZuoMBw",
        "outputId": "8eb93a07-e51d-4f7d-82e7-a5e8808acf6a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ],
      "source": [
        "math.factorial(0) # there is a built in solution already for our base case"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "id": "xguLD70RoMBw"
      },
      "outputs": [],
      "source": [
        "# regular loop based algorithm should need less memory\n",
        "def factorial_loop(x):\n",
        "    res = 1\n",
        "    while x > 1: # so we start at the end - bottom down\n",
        "        res *= x\n",
        "        x -=1\n",
        "    return res"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "1VSCEM5loMBw",
        "outputId": "2adce0d4-5f6a-4c08-a4e9-560b55a7a5e4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "120"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ],
      "source": [
        "factorial_loop(5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "id": "J06IAFiPoMBw",
        "outputId": "f4f2ebc9-af07-4a1e-d23d-97e931e7e6b3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "120"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ],
      "source": [
        "factorial(5)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "math.factorial(5)"
      ],
      "metadata": {
        "id": "asGDUe_6jlQT",
        "outputId": "202d8072-0485-474f-c5c0-a5f7920de10e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "120"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pViB5m8JoMBx"
      },
      "outputs": [],
      "source": [
        "factorial(1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NxGEbc1YoMBx"
      },
      "source": [
        "5! = 5 x 4 x 3 x 2 x 1 = 120"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I0mNcnMXoMBx"
      },
      "outputs": [],
      "source": [
        "factorial(5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "id": "aT09mvQVoMBx",
        "outputId": "dfd3ddcd-a3c8-4ab7-b549-42c46f989bf0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.65 µs ± 485 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "factorial(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "id": "iqZ_drYqoMBx",
        "outputId": "84a29f74-a2e9-4b78-838a-1de6310d6e89",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19.6 µs ± 3.45 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "factorial(100)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "id": "4KKUhxe6oMBy",
        "outputId": "0a8c970a-7ecd-45ad-e888-ac849398445a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "21.6 µs ± 4.76 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "factorial_loop(100)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "math.factorial(100)"
      ],
      "metadata": {
        "id": "WggKdkfVkGUD",
        "outputId": "e1e1da06-3a4d-4a70-c865-65c398184acd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.24 µs ± 403 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "id": "i1g8hCEEoMBy",
        "outputId": "b80a7c80-08ba-4d18-fbb7-0dde3ca658b8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "574 µs ± 166 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "factorial(1000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "id": "4R6VTQscoMBy",
        "outputId": "b4892b82-0620-4332-8006-ef199f58ca10",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.63 ms ± 411 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "factorial(2000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "id": "Sl0ODIzFoMBy",
        "outputId": "f14ccff7-0e3b-48bc-a58c-19e27ba7c820",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "324 µs ± 11 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "factorial_loop(1000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "id": "VE0oz8bIoMBy",
        "outputId": "3227bc93-2e3a-4b6e-da1a-f53b70dc37c1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.25 ms ± 310 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "factorial_loop(2000)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "math.factorial(2000)"
      ],
      "metadata": {
        "id": "GWPKE5EUkf4g",
        "outputId": "e19740ed-f035-4537-efd8-f8ca6d76b690",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "162 µs ± 35.6 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eJtdQHPloMBz"
      },
      "outputs": [],
      "source": [
        "factorial(5000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Yg6noxqOoMBz"
      },
      "outputs": [],
      "source": [
        "%%timeit\n",
        "factorial(5000) #"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DibPzEG4oMBz"
      },
      "outputs": [],
      "source": [
        "input_arr = [i for i in range(1_000, 30_000, 1_000)]\n",
        "\n",
        "fun2 = automatic_time(input_arr, factorial_loop)\n",
        "plt.plot(input_arr, fun2)\n",
        "plt.xlabel(\"input size\")\n",
        "plt.ylabel(\"running time in seconds\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "id": "uTSpwOE1oMBz",
        "outputId": "18a496ed-5fa8-4a6f-d8c8-1c2cb0e9a8af",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3ib53Xw/+/hAvcGRWqL1JZl2dawPON4xI7t2M2wY2c5q37bOm+bOKNZ7S+/tOnbpG9Wm9E4cZo4yytLcRw73iO2JVHDQ5uSqEWJW9wACOB+/7gfkBDFAZJ4SAI4n+viBfDBg4c3IAqH9zjnFmMMSimllBvSprsBSimlkpcGGaWUUq7RIKOUUso1GmSUUkq5RoOMUkop12RMdwOmQnl5uVm4cOF0N0MppRLGtm3bWowx3sleJyWCzMKFC6mtrZ3uZiilVMIQkSPxuI4OlymllHKNBhmllFKu0SCjlFLKNRpklFJKuUaDjFJKKddokFFKKeUaDTJKKaVco0FGqRS2u6GT2vq26W6GSmIaZJRKYf/x+F4+/9vXp7sZKolpkFEqhTV3+2ns9E93M1QS0yCjVApr6w7Q0dePPxia7qaoJKVBRqkUZYyhpScAQEt3YJpbo5KVBhmlUlRPIEQgGAaguUuHzJQ7NMgolaJauwcDS1OnbxpbopKZBhmlUlRrz+AQWXO39mSUOzTIKJWi2qLmYXS4TLlFg4xSKaq1xwYWEQ0yyj0aZJRKUZHhsvmluRpklGs0yCiVolq7A+RmpTO/NJcmDTLKJRpklEpRbT0BSvOy8OZ7tCejXKNBRqkU1doToCzfg7fQQ3O3H2PMdDdJJSENMkqlqNZuP2VOTyYQDNPpC053k1QS0iCjVIoaGC4r8ADQ3KUJmSr+NMgolYKMMbR2ByjLHwwyOvmv3OBqkBGR60Rkn4jUichnh3ncIyIPOI9vFpGFUY99zjm+T0SuHfK8dBHZISKPuNl+pZJVtz9IIBSmLC+LioGejAYZFX+uBRkRSQe+C7wVWAncLiIrh5z2EaDdGLMY+CbwVee5K4HbgFXAdcD3nOtF/AOwx622K5Xs2pwcmbI8D96CbECDjHKHmz2ZDUCdMeaQMSYA3A/cPOScm4GfOvcfBq4SEXGO32+M8RtjDgN1zvUQkbnADcCPXGy7UkktUtq/ND+LwuwMsjLStH6ZcoWbQWYOcCzq++POsWHPMcYEgQ6gbIznfgv4DBAe7YeLyJ0iUisitc3NzRN9DUolpcGeTBYiYnNldIdM5YKEmvgXkRuBJmPMtrHONcbcY4xZZ4xZ5/V6p6B1SiWOSJn/snw7H+Mt8GhPRrnCzSBzApgX9f1c59iw54hIBlAEtI7y3EuAm0SkHjv8dqWI/NyNxiuVzFqjejLgBBmdk1EucDPIbAWWiMgiEcnCTuRvGnLOJuAO5/67gKeNTTveBNzmrD5bBCwBthhjPmeMmWuMWehc72ljzPtcfA1KJaW2ngB5WelkZ9r1NBUaZJRLMty6sDEmKCIfAx4H0oEfG2N2iciXgVpjzCbgXuBnIlIHtGEDB855DwK7gSBwlzEm5FZblUo1rd1+SvOzBr73Fnho7QnQHwqTmZ5Qo+hqhnMtyAAYYx4FHh1y7J+j7vuAW0Z47leAr4xy7WeBZ+PRTqVSTWtPgNI8z8D3kYTM1u4AlUXZ09UslYT0TxalUlBrd4DyvKieTL4mZCp3aJBRKgVF6pZFDNQv69b6ZSq+NMgolWKMMbQ5Zf4jKgo161+5Q4OMUimmK6puWUS5swigSRMyVZxpkFEqxbRFSspEBRlPRjpFOZmakKniToOMUimmtSeS7Z91xnFNyFRu0CCjVIpp7R6swBxNEzKVGzTIKJViBopjDteT0eEyFWcaZJRKMZG6ZdFzMmBzZZo6/djKTkrFhwYZpVJMa/eZdcsivAUe+vpD9AS0gpOKHw0ySqWY1h7/GTkyEV7dhlm5QIOMUilmaLZ/RIVuw6xcoEFGqRTT2h0YSL6MFunJNHVpaRkVPxpklEoxrT3+YXsyOlym3KBBRqkUEqlbVpp39pxMcU4mGWmiQUbF1ZhBRkTyRCTNub9URG4SkUz3m6aUirdOX5D+kBl2uCwtTSjP14RMFV+x9GSeB7JFZA7wZ+D9wE/cbJRSyh1tI+TIRFQUakKmiq9YgowYY3qBdwDfM8bcAqxyt1lKKTe0DdQtO3u4DAYTMpWKl5iCjIhcBLwX+KNzLH2U85VSM1TLQN2y4XsyWlpGxVssQebjwOeA3xpjdolINfCMu81SSrlhrOEyb4GH1m4/obCWllHxkTHWCcaY54Dnor4/BPy9m41SSrmj1emljDgnU+AhbGwwiixpVmoyRgwyIvIHYMQ/Z4wxN7nSIqWUa1p7AuR7Ms6qWxYRnSujQUbFw2g9mf/r3L4DqAR+7nx/O9DoZqOUUu5o6wmcVeI/WnTW/0oKp6pZKomNGGScYTJE5OvGmHVRD/1BRGpdb5lSKu5au4evWxbhzdf6ZSq+Ypn4z3Mm+wEQkUVAnntNUkq5pbUnMOLKMogaLtMVZipOxpz4Bz4BPCsihwABFgD/y9VWKaVc0drt59w5RSM+npOVToEnQ3syKm5iWV32mIgsAZY7h/YaY/Q3UKkEY4yhvTdA6ShzMmB7M00aZFScxNKTAVgLLHTOXyMiGGPuc61VSqm4i9QtG224DKC8QOuXqfgZM8iIyM+AGmAnENmX1QAaZJRKIJEcmdFWl4Htyexp6JyKJiW89p4AJWME7VQXS09mHbDSGKMpwEolsMFs/9HzX7z5Hp7XnsyYXjrYwvt+tJk/f+JyFlcUTHdzZqxYVpe9gc2TUUolsLHqlkVUFHro8gfpC4RGPS/VPbe/mbCB1090THdTZrRYejLlwG4R2QIM/HmjGf9KJZZIT2bM4bL8waz/+WW5rrcrUdXWtwNwsKlnmlsys8USZL7kdiOUUu6LlPkfLRkTonNlfBpkRuDrD/Ha8dMAHGrpnubWzGwxFcgUkVnAeufQFmNMk7vNUkrFW0t3gAJPBp6M0XfqiK5fpob32vEO+kOG3Kx07cmMIZbtl28FtgC3ALcCm0XkXW43TCkVX209Y+fIgAaZWGytbwPghtVVHG7t0a0RRhHLxP8XgPXGmDuMMR8ANgD/5G6zlFLx1trjH3PSH6Asz0OaaJAZTW19G0sq8lm3sIRAMMyJ9r7pbtKMFUuQSRsyPNYa4/OUUjOILY45dvn+9DShLF+z/kcSDhtqj7SzbmEp1d58AA4267zMSGIJFo+JyOMi8kER+SB2C+Y/udsspVS8tfUEKI9huAzsCjPtyQxvX2MXXb4g6xeWUKNBZkxjBhljzKeBHwDnOl/3GGM+E8vFReQ6EdknInUi8tlhHveIyAPO45tFZGHUY59zju8TkWudY9kiskVEXhWRXSLy/8f2MhVAfyjMJf/+NL/dcXy6m6KmmDHGzsnEmJ3uLfBoJeYR1DrzMesXllKal0VJbiYHm3XyfySxTPwvAh41xtxtjLkb27NZGMPz0oHvAm8FVgK3i8jKIad9BGg3xiwGvgl81XnuSuA2YBVwHfA953p+4EpjzBrgPOA6EdkYywtVdoz9xOk+dh49Pd1NUVOssy9IMGxiDjIVWr9sRFvr25lV6GFuSQ4A1d587cmMIpbhsoeAcNT3IefYWDYAdcaYQ8aYAHA/cPOQc24Gfurcfxi4SkTEOX6/McZvjDkM1AEbjBX518x0vnRZR4waO30ANHT4prklaqq1ODky5fmxbansdYJMWFdNnaW2vo11C0uxH1VQ483jkAaZEcUSZDKcIAGAcz+WP4fmAMeivj/uHBv2HGNMEOgAykZ7roiki8hOoAl4whizebgfLiJ3ikitiNQ2NzfH0NzkF5nIPdmhK2FSzWDdstiHy4Jhw+m+fjeblXBOnO6jocPHhoWlA8dqvPm0dAfo6NX3ajixBJlmERkoISMiNwMt7jVpdMaYkDHmPGAusEFEzhnhvHuMMeuMMeu8Xu/UNnKGanJ6Mqe0J5NyWrtjKykTobkyw4vMx6xbWDJwbGCFmWb+DyuWIPM3wOdF5JiIHAX+kdh2xjwBzIv6fq5zbNhzRCQDKMIukR7zucaY08Az2DkbFYPGTvuB0dIdwB/U4oeppNUZLiuLYQkznFm/TA3aWt9GvieD5ZWFA8dqvHY3+oNNGmSGE8vqsoPGmI3ACmzJ/4uNMXUxXHsrsEREFolIFnYif9OQczYBdzj33wU87WwpsAm4zVl9tghYAmwREa+IFAOISA5wDbA3hrYoBudkQHszqabN6cmU5GXGdH5FYTZg65epQVsPt3PBghLS02Tg2LzSXDLThUMtusJsOLGsLpslIvcCDxljukVkpYh8ZKznOXMsHwMeB/YADxpjdonIl6OG3+4FykSkDrgb+Kzz3F3Ag8Bu4DHgLmNMCKgCnhGR17BB7AljzCPjfM0pqzHqr9KG0/rhkUpaewIUZI9dtywiMlzW1Kk9mYiO3n72NXaxfkHJGccz09OYX5qrPZkRxFKF+SfA/2DLywDsBx7ABohRGWMeBR4dcuyfo+77sDXRhnvuV4CvDDn2GnB+DG1Ww2jq9FHjzeNgc49O/qeY1p5ATCVlIvKy0snJTNfhsijbjkbmY0rPeqxGlzGPKJY5mXJjzIM4y5idHooO6Cegxk4f582zf4Wd1OGylNLW46csxuXLACKiCZlDbK1vJzNdOG9e8VmP1VTkc7Stl/5QeJhnprZYgkyPiJTh5KM4yY+6FVyC8QdDtPf2s7Asl+LcTO3JpBhbt2x8e9F7NSHzDLX1bZwzp4icrLOHHKvL8+gPGY619U5Dy2a2WILM3diJ+BoR+QtwH/C/XW2VirvIh8WswmyqinI4qXMyKWW8w2WgWf/RfP0hXj3WwfphhsrA9mQALS8zjFg2LdsuIm8ClgEC7DPGaNZRgoksX64o9FBVlK1Z/ykkHLZ1y2LNkYnwFnh46WCrS61KLG+c6CAQCrNuyKR/RE25DTI283/WFLZs5otlddktQI6z4uuvgAdE5ALXW6biKpKIaXsy2TpclkI6ff2EwiamMv/RvPkeOvr6NacK2OIkYa4dIcgU5WZSnp+lk//DiGW47J+MMV0icilwFXZV2ffdbZaKt0iOTEWBh9nFOZzu7acvoB8eqaDVKSkTa5n/iMgy5pbuwBhnJr/a+nZqvHmjLp6whTJ1uGyoWIJM5JPoBuCHxpg/ElvtMjWDNHb5yUwXSnKzqCqyiXYN2ptJCZGSMuOd+K8o1Kx/cDYpq28bcT4mosabr4UyhxFLkDkhIj8A3g08KiKeGJ+nZpDGTh8VBdmkpQlVRbZEuWb9p4Y2p6TMuFeX5ds/Rpo6U/v35EBTN52+4LD5MdFqvHm09/YPFCNVVizB4lZs1v61Tr2wUuDTrrZKxV1Tp3/gL9PZxU5P5rT2ZFJBZLgr1jL/EQNFMlM8V2arMx+zIYaeDOgumUPFUrus1xjzG2PMAef7k8aYP7vfNBVPjZ0+ZhXY4DLLqUulCZmpIfKXdUnu+HoykdVoqT5cVlvfRkWBh3mlOaOeFwkyOmR2Jh32ShFNXX5mOT2Z7Mx0yvKydIVZimjrCVCYnUFWxvj+u2emp1Gal5XyQWZrfTvrozYpG8mckhyyMtJ08n8IDTIpwNcfoqOvf6CyLkBVcbYWyUwRLd3jKykTLdUTMhtO93HidN8Z+8eMJD1NWFSWp4Uyh9AgkwIilXRnRQeZohyd+E8RbT3jLykT4S3wDOyomooi8zFjrSyLqKnI05L/Q8SSjPkOETkgIh0i0ikiXSLSORWNU/HR2DWYIxMxuyhblzCniNbu8ZeUifDmp3ZPpra+nbysdJZXFsR0fo3XFsrUBNZBsfRkvgbcZIwpMsYUGmMKjDGFYz5LzRiNUdn+EZVFOXT5gnT7g9PVLDVFWidQUiYiUonZ7iWYerbWt3HBghIy0mMb9Kn25hEKG462aqHMiFjeuUZjzB7XW6Jc0zgwXBbVk3GWMZ/UZcxJLRw2tPcGYt52eShvgYdAMEynL/X+GOnoczYpi3GoDKKXMeuQWUQsm5bVisgDwO+AgX6zMeY3rrVKxVVTp4+sjDSKcga33o0kZDZ0+FgyK7ahAJV4Ovoidcsm3pMBaO7ynfH7kwq2H23HGGKa9I+o1lyZs8QSZAqBXuAtUccMoEEmQTR2+phV6DljCWaktIz2ZJJbpG7ZZIbLwC6BX1yRWn+M1Na3kZE2/CZlI8n3ZDCr0KNBJkospf4/NBUNUe5p7PQPJGJGVBZlI6IJmcmu1cnWn+hwWUVB6tYv23q4nVVzisjNiuVv8UG2hpkOl0WM+O6JyGeMMV8Tkf/C2RUzmjHm711tmYqbpi4fyyvPXKuRmZ6GN9+jCZlJLpLtP+HhMqd+WaoFGX8wxM7jp/nAxgXjfm6NN5/f7TyBMWbMBM5UMFqIjkz2105FQ5R7mjr9XL707L9k7b4y2pNJZhMt8x9RmGMrBaRa/bI3TnQQCIbHLIo5nGpvHl2+IM3dfiqGjCCkohGDjDHmD87tT6euOSreevxBuvzBYX/Zq4pyONDUNQ2tUlMlUua/ZII9GRGxuTKdqRVktta3A+Ob9I8YrGHWo0EGzfhPepFs7ejlyxFVxbYnk6o5EKmgrcdPYXYGmTHmeQwnkiuTSmrr26j25o27cjVATYWuMIumQSbJDZeIGTG7KIfeQIjOvtTLgUgVLT2BCX1QRvOmWP2ycNhQe6Sd9QvGP1QGUFWYTXZmGgebdPIfNMgkvcEgM3xPBuBkp07+J6u27onXLYtItSBzsLmb0739ExoqA0hLE6rL8znUoj0ZiK122VIReUpE3nC+P1dEvuh+01Q8RIpjVgzTk4kkZJ7UasxJq20SJWUiKgo8tPUG6A+F49SqmW3LOItiDqemIl+Hyxyx9GR+CHwO6AcwxrwG3OZmo1T8NHb6yMlMp8Bz9hqPSEKmFspMXq09fkonmCMT4S3wYMzgIoJkV1vfTnm+hwVluRO+RnV5Hsfb+/D1a6HMWIJMrjFmy5BjOoifICKblQ23Xr+iwEOaaE8mWYXDxvZkJjtclp9aCZlb69tYv7BkUjkuNRX5GAP1rTovE0uQaRGRGpyETBF5F3DS1VapuGns9A07VAaQkZ7GrEIt+Z+sTvf1EzYTLykTMVC/rDv5/xg52dHH8fa+CeXHRKvx5gHo5D+x1S67C7gHWC4iJ4DDwPtcbZWKm6YuP6tmj7wzQ1VRtm5elqTaemzPIx4T/5AaPZlaJz9mwySDzKJyJ8jovExMtcsOAVeLSB6QZozR7L0EYYyhsdPHlcsrRjynqjiH3Q26B10yisyhxGMJMwwuIklmtfVt5Gals6JqcsVAc7MymFOcwyENMmMHGREpBj4ALAQyIuOUWrts5uv2B+kNhIZdvhwxuyibJ3c3ap2lJNQ6ybplEZ6MdIpyMlMiIXNrfTsXzI99k7LRVHvzdF8ZYpuTeRQbYF4HtkV9qRlucLOykUtbVBbl4A+Gae/tn6pmqSkyUOZ/kkEGUiNXptPXz55TnRPOjxnKVmPuTvmKGrHMyWQbY+52vSUq7pqcRMzR6ifNjixjPt036b941TTb9ycoXwplNcBgmf+J1i2L5s1P/iCz/YjdpGwy+THRarx59ARCNHb6qSxK3RpmsfRkfiYify0iVSJSGvlyvWVq0hq7Rs72j6gqdhIydfI/sQX98OAH4JmvDBxq6wlQlJM5qbplEalQv6y2vp30cW5SNpoa3SUTiC3IBID/AF5mcKhMy/8ngNGy/SMiPZlTuow5sTXuglAAjg2mtLXGIds/oqLAQ1OnP6mHfrbWt7FqdiF5wyQuT4RuxWzFEmQ+CSw2xiw0xixyvqrdbpiavMZOP3lZ6eSP8p+mPN9DZrrQoD2ZxNaww952HIOOE4AdLovHfAzYnkxff4ieQHJmsAeCYXYeOx23oTKwIwh5Wekpv0tmLEGmDuidyMVF5DoR2ScidSLy2WEe94jIA87jm0VkYdRjn3OO7xORa51j80TkGRHZLSK7ROQfJtKuVNHY5Rt10h9sMb9ZhdmcPK09mYTWsANwVgce2wzY4bJ4zbMle67MGw0d+INh1sdp0h/sXjxawyy2INMD7BSRH4jIf0a+xnqSiKQD3wXeCqwEbheRlUNO+wjQboxZDHwT+Krz3JXY+mirgOuA7znXCwKfNMasBDYCdw1zTeVo6vRRMcp8TERVUbb2ZBJdw05YdBlk5g4MmbV2ByibZI5MRDIHmf5QmF9tPgrA2gmW9x9JdXkeB5s0yIzld8BXgJcY3xLmDUCdMeaQMSYA3A/cPOScm4HIzpsPA1eJTda4GbjfGOM3xhzG9qY2GGNOGmO2AzhJoXuAOTG0JSU1dvrH7MmArcZ8UudkEld/HzTthrkbYM5aOLaZcNjQ3jv5umURkRWKyRZk6pq6ecf3XuKhbcf5wEULBoJpvNR482no8NEbSN1yj7Fk/E90++U5wLGo748DF450jjEmKCIdQJlz/JUhzz0jmDhDa+cDmyfYvqQWyfaPKcgUZ/OnN3yEw4a0NE3ITDin3gATgtnnAwb+8m1Od3bYumVxHi5r6kqOHq8xhvtePsK/PbqH3Kx0vv/eC3jr6qq4/5zILpmHmns4Z05R3K+fCEYMMiLyoDHmVhF5Hac4ZjRjzLmutmwUIpIP/Br4uDFm2JooInIncCfA/Pnzp7B1M0NnXxB/MExFDH+ZzS7KoT9kaO0JxP0vOTUFGrbb29nnQ3oWhL9O72E7ZFYap+Gy4pxMMtIkKXoyjZ0+PvXQq7xwoIUrlnn52jvPHXUF5mRUewdrmGmQOVtkUv3GCV77BDAv6vu5zrHhzjkuIhlAEdA62nNFJBMbYH5hjPnNSD/cGHMPtrAn69atS951lyMYzJGJZbjM2SGzo0+DTCJq2AF5FVA4GzJt3lP46Gbggrj1ZNLShPIkSMj842sn+cLvXsfXH+Jf/uoc3nfhfFfLKS0sy0OElF5hNuKcjDEmUs7/74wxR6K/gL+L4dpbgSUiskhEsrAT+ZuGnLMJuMO5/y7gaWMX4m8CbnNWny0ClgBbnPmae4E9xphvxPoiU1FTDCVlImY7CZkNuq9MYmrYYXsxIpBbCuXL8JzcCky+zH+0RE7I7Ojr5xMP7OSuX25nQWkuj/79Zbx/4wLX6/VlZ6YzryQ3pVeYxTLxf80wx9461pOMMUHgY8Dj2An6B40xu0TkyyJyk3PavUCZiNQBdwOfdZ67C3gQ2A08BtxljAkBlwDvB64UkZ3O1/UxvIaU0zhQUmbsnkllVE9GJRh/NzTvc+ZjHPMvpLh1J0I4rqWCIgmZieblg6289VvPs+nVBj5+9RIe/tuLBxIlp0KqF8ocbU7mb7E9lmoReS3qoQLgL7Fc3BjzKLbAZvSxf4667wNuGeG5X8Guaos+9iIDyQBqNJHhsliWMJflZZGVkaalZRLRqdcAA3MuGDw270I82++jWk5SmhvfnsxrJzridj23+fpDfP3P+/jRi4dZWJbHw39zEefPj18eTKxqvPm8cqg1ZRfWjDYn80vgT8D/welhOLqMMW2utkpNWlOnn4LsDHKzxi6RISJUFWVrkElEkUz/qvMGj82zizgvyz4Yl5L1Ed4CD63dfkJhQ/oM/7Dcc7KTTzywk72nunjfxvl8/voVMf1fcEONNx9ff5iGjj7mluROSxum04jvujGmA+gAbp+65qh4iXX5ckRVkWb9J6QT26FwDhTMGjxWtpjutEI2pNfF9Ud5CzyEja0kMFMXiHT7g9z7wmG++0wdRbmZ/M+H1vPmZSNv2jcVBleY9WiQUcnDBpnYPwhmF+Ww+bB2UBNOZNI/mgh7M1dwbnBfXH+UN38w63+mBZneQJD7Xj7CD547SHtvPzesruJf/uqcGbF9RaQa86Hmbt601DvNrZl6GmSSVGOnnwsXxV4io6o4m1OdvoQYClGOvtPQdhDOO3uwYSfL+GhoM/S22RVncRCZ32vq8rGSwrhcc7J8/SF+/soR/vu5g7R0B3jTUi+fuGZp3Mr1x0N5fhaF2Rkpu8JMg0wSMsbQ3OUfV4JZZVEOobB9XipvsJRQTr5qb4f2ZIBX+hfzUbB1zJZdF5cf582fOaVlfP0h7t9ylO8+e5DmLj+XLi7nE9csiXvtsXgQEaq9+RxsSs0VZmMGGRHp4uyM/w7snjKfNMYccqNhauJO9/YTCIXHOVzm7JDZ0adBJlFEJv1nX3DG4VDY8GLffELZ6aQf2xy3IFNeYIeepjNXJhAM82DtMb77TB0nO3xsWFTKf91+Phury6atTbGo8ebzYl3zdDdjWsTSk/kWtnbYL7HLh28DaoDtwI+BK9xqnJqYgeXLo2y7PFRVkU3IPKUrzBJHww4oXnDWcNjp3gA+k0VbwQq8UZuYTVZuVgb5noxp6cn0h8L8ettx/uvpOk6c7mPtghK+fssaLqopcz2hMh5qKvL49fbjdPn6KcjOnO7mTKlYgsxNxpg1Ud/fIyI7jTH/KCKfd6thauIaB7L9x9GTKXZ6MrrCLHE0bD+rFwN2R0yALu8FeI88BKF+SI/PB5u3YGpLywRDYX674wT/+fQBjrX1sWZeMf/2jtVcvqQ8IYJLRHX5YKHMNTNovmgqxLKIvldEbhWRNOfrViDy527K1QRLBJFs//EsYS7KySQnM11zZRJFTyucPjrsfExrtw0y/bM3QLDPSdiMD2+Bh6YpCjLbj7Zz7bee59MPv0ZRTiY//uA6fvd3F/Ompd6ECjAAiyvsMuZDLak3+R9LT+a9wLeB72GDyivA+0QkB1s2Rs0wTU6QGc8y08GETO3JJISTkfmYs4NMm9OTSV+4EV7ATv7PWRuXH+st8LCnYdjC53ETCIb59lP7+f6zB6kqyuG/37eWa1fNSrjAEm1+aR7paZKSk/+x7CdzCHjbCA+/GN/mqHho7PRTnJtJdmb6uJ5XVZytRTITxUCm/5qzHmrtsT2Noor5UDQfjr4CG/82Lj/Wm+/heRd7MntOdnL3g6+y52Qnt6ydyz+9bSWFSTCHkZWRxoLS1CyUGcvqMi/w18DC6PONMR92r1lqMho7fcwax6R/RFVRDtrTd9kAACAASURBVC8eaHGhRSruGnZC2WLIOXt8PzJcVpKbCfM2wJG/gDG2SvMkeQs8dPmD9AVC5GSN74+Y0YTChh88f5BvPrGfopwsfvSBdVy9ctbYT0wg1d68lCz5H8tw2e+xne4ngZC7zVHx0Njlj6kw5lCzi7Jp6vIRDIXjWvNKuaBhByy4eNiHWnv8lORm2n/D+RvhjYeh4zgUzxv2/PGIVPVu7vIzvyw+JVIOt/TwyQd3sv3oaa5fXcm//tXqGZGpH2813nye398ytQnPcfrjYjJiCTK5xph/dL0lKm6aO30sqSgf9/OqinMIGxuk5jh7zKgZqKsROk8MOx8Ddk5m4EN63gZ7e2xzXIJMZJ6vuds36SATDht+vvkI/+fRvWSmC9++7TxuWjM7oedeRlPjzScQCnO8vZcFZXnu/aBAD9Q9BXv+AF0n4YOPuPezYhBLkHlERK53yvarGS4cNjR1+WPaR2aogR0yT/dpkJnJGkae9Ac7XFYW2Xa5YhVk5tkgs/pdk/7R3qiezGQ0nO7jMw+/xot1LVy+1G6BnOxJwJFCmYeae+IfZPpOw/7HYc8mG2CCfZBTAstuiOsS9omIJcj8A/B5EfED/diETGOMmRnFi9QZ2noDBMNmXMuXIyIJmQ26jHlma9gBCFSeO+zDrT0BllQ4m3KlZ8DcdTbIxMFkg4wxht9sP8GX/rCLUNjwlbefw3s2uLsF8kwRKZR5sLmbNy+PQ2Xo7ibY+0fbYzn8HISDUDAbLng/rHgbzL/Y/vtPs1hWlxVMRUNUfAzmyEygJ1M82JNRM1jDDvAuA8/wuzueMVwGdn+ZF75ud9Ec4TmxKsvzkCYTCzIt3X4+/5vX+fPuRtYvLOH/3rLG3WGjGaYkL4vSvKzJrTBrPwJ7H4E9j8DRlwEDpdVw0V2w4iabnJuWRkdfP5u2nqC+pYd/unFl3F7DRIy2M+ZyY8xeETk7pRgwxmx3r1lqoiLb446nOGZEYXYm+Z4MTcicyYyxQWbx1cM+HAob2nujhsvABhkTghPboPpNk/rx6WlCWX7sCZmhsGFrfRuPvXGK3+88QY8/xOevX85HLq1OyWrf1eXj3Io5HIZTr8KBJ2xwiRRFnbUarvgcrLgRKlaCCMYYtta3c//Wozz6+kl8/WFWzynCHwzhyYjfSsDxGq0nczdwJ/D1YR4zwJWutEhNykSy/aNpQuYM19kAPU0jzse09wYwxm6pPWDuOkBsUuYkgwzYXJnRejL+YIiXDrby+BuneGJ3I609ATwZaVy+1Mun3rKMZZWpOzhS483nqb2No5/U1w4Hn4YDT0LdE9DTDIj9d7zmX2xgKa0eOL2l289vth/n/q3HONTcQ74ng3deMJfb1s/nnDmF0z4UOdrOmHc6t2+euuaoyYrULfPmT2xTqariHO3JzGQNzgDCKCvLAMryo4JMTjFUrIjrvMzQSsy9gSDP7WvmsV2neHpPE13+IPmeDK5cXsF151TypqVe8jzTPz8w3Woq8nigNkBHbz9Fuc5kvDG29M+BJ+zX8S1gwnbivuYqWPIWWHwV5A2uGA2FDS/WtXD/lqM8sbuRYNiwbkEJf/uuGm44t2ratpoeTkwtEZGLOTsZ8z6X2qQmobHLR1leFlkZE8tzmV2UzW6Xy4aoSWjYAZIOlecM+3CL8+F/Vp7JvA2w67d2+CVtcjlQ3gIP+xu76Ojt58k9jTy26xTP72/GHwxTmpfF9auruO6cSi5eXDatwzQzUaRQ5uGGBs7z77BBpe5J6D5lT6g6Dy77FCy5xpYCSjvz/Ttxuo+Hao/xUO1xTpzuozQviw9dspB3r5/H4oqZ2UOMJeP/Z9jS/jsZTMY0gAaZGaipc3yblQ1VWZRNS7d/2sdx1Qgadtgx+Mzhl5gP9GTyhvRk510I234CLftsr2YSvAUeTnb4WPuvTxAMG6qKsrl9w3yuXVXJ+oUlmsg7VDgMbYegYQfrD23loaxnWP3zOiBMT1o+u3PXsbfyg9QVbiSQXUZWVxpZr6WRuesAWRlpZGWkkZEm/KWulecP2D1pLl1czuevX8HVKytm/P/TWHoy64CVxhituJwAmrp8E8qRiZjtLGNu7IhfRreKk8ik//IbRzwlUlLmjOEysEEG7JDZJIPMZYvLeamuhYsXl3PdqkrOnVs07eP+M4Yx0H7Y/js17LDlf06+Cn47OlCYkU1FXg2b0m+lNnMtb8gyfCGhvzuM/3SYQKiJQDBMfyhMIBgmGB782K0szOZ/v3kxt6ybx7zSxPm/GUuQeQOoBE663BYVB42dPpZPYmJ1YBlzR58GmZnm9BE7KTxn2AWfgM2REYGS3CFBprQacsvh6GZY+8FJNePixeX8/mOXTuoaSeP0UTixfTConNwJvg77WLrHDmuee6sdBpt9PuJdzoL0DBYAb4/h8uGwIRAKEwiFyc/KIC0BV+TFEmTKgd0isgUYmO0zxtzkWqvUhITChuYu/4RXlsFgQqZO/s9AY2T6A7T1+CnJzTp7ebCI7c3EafI/5XWehD9/Ad74tf0+LRNmrYJV77D/PrPPA+8KyJhcDba0NCE7LX3cFdVnkliCzJfcboSKj9ZuP2EzsRyZiIEdMnUZ88xzYjukZ9k5mRG0dgdGLi45/0LY90foaTljpZIah1AQtv4Qnv4KhAJw+adh+Q323yRj4sPUySyWjP/npqIhavIGtl2exJxMblYGRTmZnNR9ZWaehh32r+VRPsxah2b7R4uel1l+gwsNTHJHN8MfPwmNr9tk2Ov/44x8FTW8MZeBiMg7ROSAiHSISKeIdImIrnGdgSabiBmhCZkzUDhsJ5BHGSoD25stHzrpH1F1nu0J6ZDZ+PS0wu8/Bj9+C/S1wa0/g/c+rAEmRrEMl30NeJsxZo/bjVGT09gVzyCjPZkZpe2QXaE0RpA5q25ZtMxsG2iObXGhgUkoHIYd98GTXwJ/F1zyD3D5ZyZd/y3VxBJkGjXAJIamTj8ijPyXbIyqinN49XhHnFql4mJg0n/klWXBUJjTff1n58hEm7cBtvwQgoFJT0ontZOvwiN3w4laWHAJ3PD1SS/9TlWxBJlaEXkA+B1nri77jWutUhPS1OWjLM8z6WS42UXZtPUE8PWHEnpVS1Jp2AEZ2eBdPuIp7b39tm7ZaH9kzLsQXv6O/RCdt96FhiY4X4ed1N/6Q8gtg7f/AM5997TvLpnIYgkyhUAv8JaoYwbQIDPDNHb6J1Tif6joZcyLylOnFPuM1rDd7h8zyv4gI2b7R4ue/NcgM8gYeP0hePwLtiDl+o/ClV+0dd/UpMSyuuxDU9EQNXmNnb5Jz8fAmfvKaJCZAcIh2/M4//2jntY6Ut2yaAWzoGShM/n/sfi1MRGFw3B8q91Ncu8j0F5vhyPf++CYc18qdrHULvsfbM/lDMaYD7vSIjVhjZ1+zp1bNOnr6A6ZM0zLfujvHXtl2XAVmIcz70I49Kz96z3VhoFC/VD/gt1Ncu8fobvRJlJWX2H3Z1l9y1lFKdXkxDJc9kjU/WxsNYQGd5qjJqo/FKa1x09FQRx6Ms5e66d0GfPMEEOmP0QPl40VZDbAaw/YMjUlC+PQwBku0Gv3Z9nzB9j/JzvvkpkHS662u0kuuQayJ//HmRpeLMNlv47+XkR+BbzoWovUhLR0+zFm8suXAbIz0ynNy9KezEzRsAOy8qF8yaintXbb1YXFQ+uWDTVvo709tiV5g0zfaTjwZxtY6p60PcHsYlh2A6x4G9S8ecRK1iq+JrKzzRKgIt4NUZMzkO0fh4l/cHJlTmtPZkZo2AFVa8YcxmntCVA6XN2yoSpWQFYBHH3FFm9MRP5u6DppdwqN3EbfP/U6hPshvxLOe48NLAsugfTM6W55yollTqaLM+dkTgH/6FqL1ITEK9s/oqooh+PtvXG5lpqEUL/9wFz/0TFPHbVuWbS0dLuV70xPyuxuttsPtx48O5D4hyk64imCwioonA0b/8YOhc1ZN+lN2tTkjBpkxG4SscoYc3QiFxeR64BvA+nAj4wx/z7kcQ9287O1QCvwbmNMvfPY54CPYDdK+3tjzOPO8R8DNwJNxpjhtwdMQU3OnuuT2Usm2uzibLYcbo3LtdQkNO2BoC+m1U6jZvsPNX8jPPdV8HVCduEkGxlH7UfshPyeP8CxV+w2xJIO+bNsAClfYifpC6ugYPaZt1m6EnImGjXIGGOMiPwRWD3eC4tIOvBd4BrgOLBVRDYZY3ZHnfYRoN0Ys1hEbgO+CrxbRFYCtwGrgNnAkyKy1BgTAn4CfAfdmfMMTZ0+0gTK8uMTZCqLsun0BenxB3Vv9ukU46Q/QGuPn+WVMQaMeRvsB/iJbXZ+YroYYwPp3kdsYDn1mj1esWqwwvGsc3TFVwKL5dNju4isN8ZsHee1NwB1xphDACJyP3AzEB1kbmZwK4GHge84vaebgfuNMX7gsIjUOdd72RjzvIgsHGdbkl5jpw9vgWfs8fgYzY5KyFxcobWapk3DDjsMVLJoxFPeONHBj144xOGWHq5aMSu2685ZB4jNl5nqIBMO23Ite/5gg0vbIduWeRvgmn+xgaWsZmrbpFwTS5C5EHiviBwBegDBdnLOHeN5c4BjUd8fd6417DnGmKCIdABlzvFXhjx3TgxtHSAidwJ3AsyfP388T01INts/PvMxMLiM+WRHnwaZ6dSww26ANWRewRjDs/ub+eHzh3jpYCt5Wel8+JJF3HXF4tium11otw2YqorM/X1w5CUbVPY+Ct2nbH7Kosvh4v9tV30VxBggVUKJJchc63orXGCMuQe4B2DdunVnJZMmm8ZOH3NL4rdd8uxipyej+8pMn6AfGnfBRXcNHPIHQ/x+ZwM/euEQ+xu7qSzM5nNvXc5tG+ZTlDPOlVPzLrSlVMKh+A9HhfrtJmuHn4fDz9lFBiE/ZObavVgi+SlatiXpxZInc2SC1z4BzIv6fq5zbLhzjotIBlCEXQAQy3NVlKYuP2sXlMTterMKsxHRHTKnVeMbdhnu7PPp6O3n55uP8JOX6mnu8rO8soBv3LqGG8+dTVbGBFdPzbsQau+1cyKVk1xDEw7b9kaCypGXINBtH6tcDRv+Gha9CRZdpvkpKcbNGd2twBIRWYQNELcB7xlyzibgDuBl4F3A085ig03AL0XkG9iJ/yXADF9vOX38wRBtPYG4DpdlZaRRnu/Rnsx0cib9v7U7n3seeIreQIjLlpTzjVvXcOnicmSyJWHmbbC3xzaPP8gYY5cWH37WCSwv2A29AMqW2MrF1W+CBZdCXtnk2qkSmmtBxplj+RjwOHYJ84+NMbtE5MtArTFmE3Av8DNnYr8NG4hwznsQu0ggCNzlrCyLVBy4AigXkePA/2eMudet15EImrvim4gZUVWUzclODTITFQiG+dMbJ3nhQAsZaUJ2ZjqezDSyM9LJzkwnOzNt8NY55slMIycznb5ACF54kuUmn+/s8HPTeXP468uqWVEVx+XGJQvt0uDXHoRAjx2eC/rssFbkftAf9eV8H/JD50nocqpLFc6BpdfZoLLwMiga1/SpSnKurk01xjwKPDrk2D9H3fcBt4zw3K8AXxnm+O1xbmbCG8yRiV9PBmyQOdTcE9drpoJTHT5+ueUov9x8lJZuP2V5Ngvf1x/CFwwTCIZjus7jnt2cLj6HFz585UDR0rgSsfMjO39hc1LsQTucleGBdI+9zch2bp37WSV26+EFF9shsNLq1Cu0qWKmCRBJoMnpbVTEvSeTw1/qNCEzFsYYthxu476Xj/DYrlOEjeHNyyr4wEULuHyJl7SopeXhsMEXDOHrD9vA0+/cD9r7/v4w4UAvS397HFlzK7gRYCJu+g5c8+XBAJKWoQFDxZUGmSQwWLcsvj2Z2cXZdPuDdPr6KczWmk/D6Q0E+d2OBu57uZ69p7ooysnkI5cu4n0XLmB+2fCr/dLShNysDEatY3lsC5iQ+/uapKVBXrm7P0OlNA0ySaCx00dGmlA6VvXdcRrYIfO0j8JKDTLRDrf08LOXj/DQtmN0+YKsrCrkq+9czU1r5pCTFYflwCe221vdPEslOA0ySaCx009FgeeMIZl4iCRkNnT0sayyIK7XTkShsOG5/U389KUjPLe/mYw04frVVXzgogWsXVAy+dVe0Rp22En5gqr4XVOpaaBBJgk0dfmoiPNQGUCVk5B5KoX3leny9fPigRae2tvEM3ubaO0JUFHg4RNXL+X2DfNced8BJ9P/fJ0fUQlPg0wSaOz0sag8/hVoZxV4SBNSbl+ZI609PLWniaf3NrH5cCv9IUNRTiZXLPNy7apKrlk5i8x0F8vHn3rDbrl8zjvc+xlKTRENMkmgsdPPxur4J7xlpKdRUZCd9DtkBkNhao+08/TeJp7a08hBZ9n24op8PnzJIq5aMYsL5heT4WZgMQYOPQMvfQcOPmXLryy/wb2fp9QU0SCT4Hz9ITr6+uO2j8xQVcXZnEzC0jIt3X7+UtfCU3uaeHZfE52+IJnpwsbqMt63cQFXLq9gQdkU7E8S9Nv6YS9/F5p2Q14FXPlFWPthzZRXSUGDTIKLZPu7NTcwuyiHPSeH2YUwQRhjONbWx+6THexq6GR3Qye7Gjo55eQWlednce2qSq5aUcGlS7zkT9XeOb1tsPVe2HIP9DTZ/VNu/h6sfpfNWVEqSWiQSXDx3nZ5qMqibJ7e24QxJr6rp1wQCIapa+pmV0MHu0/aYLKnoZMufxCANLFDYBurS1k1u4h1C0tYM7c47qvyRtVSB698F3b+CoJ9NuP+orug+s06ya+SkgaZBDeYiOnScFlRNn3OkFxxnPNwJqvT189fDrTw/IFmXjvewYHGbgIhW7IlJzOd5VUF3Hz+bFZWFbFqdiHLKgvIzpyGHRaNgSN/sfMt+x+D9ExbQPKiu6BixdS3R6kppEEmwQ30ZOJctywisq9Mw2nftAcZYwx1Td08s8+u/KqtbycYNhRkZ3DevGI+dOlCVs0uYmVVIYvK8+K2S+iEhENw8lVb9n7Xb+393DJ402dg/Uchv2L62qbUFNIgk+Aau3xkpadRnOtORn70DpkrZ8exAnCM+gIhXj7UwtN7m3hmbzMnnOXUyysL+OvLq3nzsgr3V37FIlL6/tAzNrAcfgF8p+1js86BG78Fa27TvVRUytEgk+CaOv1UFHpcmy8Z6MlM4TLmo629A72Vlw+1EgiGyclM55LF5dz15sVcscw70K5p1XnSBpRDz9nbTmdfvaJ5sPxGW/p+0eVQUDm97VRqGmmQSXCNnT7XJv0ByvM9ZKSJqwmZ4bDh1eOneXxXI0/sPjWQp7KoPI/3XjifK5dXsGFRKZ6MaZhPidbTYjf4OvSsDSwt++zxnBIbTBZ9Eqqv0NL3SkXRIJPgmrr8LKnId+366WnCrMJstta3se1IO+fMKYzLh30wFGbL4TYe23WKP+9q5JRT5HNjdRnvvXABb15e4UoVg5iEw9B+GE69fuZXZJOuzFyYfxGc/167n0rlubaasVLqLBpkElxjp49LF7tbqv3imjIe2nacd37/JbLS0zhnTiEXzC9h7QL7FWuOjq8/xIsHWnhs1yme3NPI6d5+sjPTuHyJl8+cs4yrls+iyKW5pRH1+2wSZHQwaXxjcH96SQfvcttTqVxt64nNXae5LErFSIPMKJ7Y3ciaeUVx33EyXnoDQbp8wbhvVjbUf9yyhk9ft4ztR06z/Wg724+0c98rR/jRi4cBmFOcMxBwLphfwvKqgoHaXl2+fp7e28SfdzXyzL4megMhCrIzuHrFLK5dNYvLl3rJzXL51zAUhM7j0F4P7Uec23po2mNrhNmdvSGrwO51f957bECpXA3eFZA5M//9lUoEGmRG0N4T4O4HdjKnJIf779w47ct3h9MUyZGZgiBYUZDNdedUct05dhLbHwyxu6GTbUfa2X60nc2HW9n0qh1OyslM59y5RWRnpvPywVYCoTDeAg9vP38O166qZGN1GVkZcRxeMsZm0LfXw+n6wSASCSgdxwcDCdjdH4vmQflSWHHjYEApXqjDXkrFmQaZEZTkZfHf71/Lh/5nK3f8z1Z+8dELp67kSIzczvYfjScjnfPnl3D+/BLA5rA0dPjYfqSdbUfa2XG0neZuP3dcvIDrzqnk/Hkl8c2s72yAuqeg7gk7CR9ZLhyR54WShTB3Pay+xd4vWWBvC2ZD+sz6t1QqWen/tFFcsric7773Av7m59v46E+38pMPbZiejPERNHa5m+0/HiLCnOIc5hTn8LY1s+P/A4IBOPoy1D1pg0vTLnu8oMouF648B4qdIFI8HzzuLYZQSsVOg8wYrlk5i2/cuoaPP7CTv/vFdn7w/rXu7iUyDk1OT8a1jbOmW3v9YFA59Bz090BaJszfCNd82db9qlipy4WVmsE0yMTg5vPm0OMP8fnfvs4nHtjJt287f3pLljgaO31kZ6ZRmJ3g/4zGgK8Depqh7TAcfNoOg7XW2ceL59ts+cVXw6LLwKNbQSuVKBL802nqvOfC+XT7+/m3R/eSl5XBv79z9bRXJW7q8lNRkD3t7RiWMXaepLvJfvU0QXezc9tkA0r0bcg/+NyMbFh4qa3xtfhqKFusvRWlEpQGmXG48/IaunxB/uvpOvKzM/jiDSum9QPeZvtP/3zMgHAYTtTCnj/A3keg7dDZ50i6nZTP99oNurzLnO8r7PeFVXayXmt8KZUUNMiM093XLKXLF+TeFw9TkJ3Bx69eOj0NMYa+jhbmznZhkn08ggGof8EGlb2PQvcpO2+y6HJY+yEonH1mEMkp0WXCSqUQDTKj6W62f3FHERH++caVdPuDfOvJA+R7MvjoZdVT055Q0NbO2vco7PsTv+85SM/hYvjFBpizDuauhTlr7Qe5mwI9dkJ+zyOw/3Hwd0BmHiy5Gpa/DZZcAznF7rZBKZUQNMiMJNQP37/Y/iV+wQdsrkW2LXWflib8+ztW0xsI8q9/3EO+J4PbNsx3px3+Lru6at+f4MDj0NcO6VkEF1zGNxrXcVNlH8tP74cDTwDGPqdsiS19MmetHXqatcpulDUZvW22DXsfsRPzQZ8NZitutEuIa96sQ1xKqbNokBlJOASXfwq2/RT+eDf8+Yuw6u024My7kIz0NL717vPp8dfyud++Tp4nI375IR3H7Qf6vj/ZoahQwH6gL70Olr0Vaq6kvgO+t/t5ll54HsvPn2NXZ53YbudEjm+zPY1Xf2Wvl5ENVec5gecCyMiB/l7bI+nvtXW6Ar1DjvWceb/lgM2aL5wDF9xhg8v8izWpUSk1KjHGTHcbXLdu3TpTW1s7sScbAw3bYft98PrD9gO5fKkNNmtupy+zhDt+vIXtR9v5wfvXctWKWeP/GeGQLcy47092KOzUa/ZHl9bQu+haDpddzmuylEOtfg619HCouZtj7X2EwoYH/9dFbFhUOny7Tx91go7zdfLVM1dxRUvLsENeWbmQlWcrDQ/c5trXvPxGWyBSV3oplfREZJsxZt2kr6NBZhz83XYr3e33wfEtdoJ7+Q30rn4vtz+ZzZ7GHn7yofVcXDNCVWRjoOMYNO2Fpt2Y5j2Yxj1Iy34k2IdBaChcw1bPRh7rP58X20vo9gcHnp6dmcbCsjxqvPlUe/NYVlnAW8+pij1nJxiA5r0QDkJWvg0embn2fsbMq82mlJo+GmTGIW5BJlrTHtj+Mzsk1ddGqHAeP/Nfxn19l/LR6y8l299EZut+ck/vp7C7jvLeg1T6j5BjegcuccqUsD88l/1mLrvCC3kuvIZ2KWROcQ7V3nyqy/Oo9uZRXZ7PIm8eVYXZ8a3/pZRSI9AgMw6uBJmIoN9Ohm+/Dw49S4g0ukwOxdIzcEo7hdSnz+dE5iKacxbRnr+YnsLFZBWUUZidSVFOJqV5mSwqz2dBWe6Mqo+mlEpN8QoyOms7WRkeOOed9qvtMOFtP4f2U3TOWoGnahVZs1dRkl9BCXD+dLdVKaWmmAaZeCpdROY1/4RmiCillKWp10oppVyjQUYppZRrNMgopZRyjatBRkSuE5F9IlInIp8d5nGPiDzgPL5ZRBZGPfY55/g+Ebk21msqpZSaOVwLMiKSDnwXeCuwErhdRFYOOe0jQLsxZjHwTeCrznNXArcBq4DrgO+JSHqM11RKKTVDuNmT2QDUGWMOGWMCwP3AzUPOuRn4qXP/YeAqsRu03Azcb4zxG2MOA3XO9WK5plJKqRnCzSAzBzgW9f1x59iw5xhjgkAHUDbKc2O5JgAicqeI1IpIbXNz8yRehlJKqYlK2ol/Y8w9xph1xph1Xq937CcopZSKOzeTMU8A86K+n+scG+6c4yKSARQBrWM8d6xrnmXbtm0tInIEKAdaxvEakpW+D5a+D5a+D5a+D1bkfVgQj4u5GWS2AktEZBE2ENwGvGfIOZuAO4CXgXcBTxtjjIhsAn4pIt8AZgNLgC2AxHDNsxhjvAAiUhuPWjyJTt8HS98HS98HS98HK97vg2tBxhgTFJGPAY8D6cCPjTG7ROTLQK0xZhNwL/AzEakD2rBBA+e8B4HdQBC4yxgTAhjumm69BqWUUpOTElWYI/QvFUvfB0vfB0vfB0vfByve70PSTvyP4J7pbsAMoe+Dpe+Dpe+Dpe+DFdf3IaV6MkoppaZWqvVklFJKTSENMkoppVyTEkEm1Ypqiki9iLwuIjtFpNY5VioiT4jIAee2xDkuIvKfznvzmohcML2tnzgR+bGINInIG1HHxv26ReQO5/wDInLHdLyWyRrhvfiSiJxwfi92isj1UY8lXUFaEZknIs+IyG4R2SUi/+AcT7nfiVHeC/d/J4wxSf2FXep8EKgGsoBXgZXT3S6XX3M9UD7k2NeAzzr3Pwt81bl/PfAnbA7SRmDzdLd/Eq/7cuAC4I2Jvm6gFDjk3JY490um+7XF6b34EvCpYc5d6fy/8ACLnP8v6Yn+fweoAi5w7hcA+53XmnK/E6O8F67/6hm/pQAABHZJREFUTqRCT0aLalrRxUh/CvxV1PH7jPUKUCwiVdPRwMkyxjyPzbeKNt7XfS3whDGmzRjTDjyBrQSeUEZ4L0aSlAVpjTEnjTHbnftdwB5srcOU+50Y5b0YSdx+J1IhyMRcVDOJGODPIrJNRO50js0yxpx07p8CZjn3k/39Ge/rTvb342POUNCPI8NEpMB7IXavqvOBzaT478SQ9wJc/p1IhSCTii41xlyA3XfnLhG5PPpBY/vDKbd2PVVfd5TvAzXAecBJ4OvT25ypISL5wK+BjxtjOqMfS7XfiWHeC9d/J1IhyMRSqDOpGGNOOLdNwG+xXdzGyDCYc9vknJ7s7894X3fSvh/GmEZjTMgYEwZ+iP29gCR+L0QkE/uh+gtjzG+cwyn5OzHcezEVvxOpEGQGCnWKSBa2PtqmaW6Ta0QkT0QKIveBtwBvMFiMFOf29879TcAHnJU1G4GOqKGEZDDe1/048BYRKXGGDt7iHEt4Q+ba3o79vQD7Xtwmdjv0RQwWpE3o/zsiItj6iHuMMd+IeijlfidGei+m5Hdiulc9TMUXdtXIfuyqiC9Md3tcfq3V2BUfrwK7Iq8XuxncU8AB4Emg1Dku2C2tDwKvA+um+zVM4rX/Ctvl78eOFX9kIq8b+DB2orMO+NB0v644vhc/c17ra84HQ1XU+V9w3ot9wFujjifs/x3gUuxQ2GvATufr+lT8nRjlvXD9d0LLyiillHJNKgyXKaWUmiYaZJRSSrlGg4xSSinXaJBRSinlGg0ySimlXKNBRqkxiMhLLlxzoYi8Z5zPeVREiuPdFqXcpEuYlZoGInIFtvrtjdPdFqXcpD0ZpcYgIt3O7RUi8qyIPCwie0XkF04mdWQPn6+J3cdni4gsdo7/RETeNfRawL8Dlzl7eHxiyM+rEpHnncfeEJHLon5GuYj8TdT+H4dF5Bnn8beIyMsisl1EHnLqVCk1rTTIKDU+5wMfx+63UQ1cEvVYhzFmNfAd4FtjXOezwAvGmPOMMd8c8th7gMeNMecBa7DZ2QOMMf/tPLYem83/DREpB74IXG1scdRa4O6JvECl4iljuhugVILZYow5DiAiO4GFwIvOY7+Kuh0aOMZjK/Bjp6Dh74wxO0c479vA08aYP4jIjdjA9xenc5UFvDyJNigVFxpklBoff9T9EGf+HzLD3A/ijBiISBr2w39Uxpjnne0ZbgB+IiLfMMbcF32OiHwQWAB8LHIIu7HW7bG/FKXcp8NlSsXPu6NuI72IemCtc/8mINO534XdBvcsIrIAaDTG/BD4EXYb5ejH1wKfAt5nbIl2gFeAS6LmgvJEZOlkX5BSk6U9GaXip0REXsP2diI9ih8CvxeRV4HHgB7n+GtAyDn+kyHzMlcAnxaRfqAb+MCQn/Mx7H7zzzhDY7XGmI86vZtfiYjHOe+L2Gq5Sk0bXcKsVByISD22NHzLdLdFqZlEh8uUUkq5RnsySimlXKM9GaWUUq7RIKOUUso1GmSUUkq5RoOMUkop12iQUUop5Zr/B1vRxXRYv5XkAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "input_arr = [i for i in range(100, 2_500, 100)]\n",
        "\n",
        "fun2 = automatic_time(input_arr, factorial_loop)\n",
        "plt.plot(input_arr, fun2)\n",
        "fun1 = automatic_time(input_arr, factorial)\n",
        "plt.plot(input_arr, fun1)\n",
        "plt.xlabel(\"input size\")\n",
        "plt.ylabel(\"running time in seconds\")\n",
        "plt.show()\n",
        "# the peaks are from the fact that we run the experiment only once\n",
        "# and our virtual CPU has better things to do at times..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YPVTnvN5oMB0"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yyfqqXLnoMB0"
      },
      "source": [
        "# Exercise: Fibonacci\n",
        "\n",
        "The sequence, in which each number is the sum of the two preceding numbers is known as the Fibonacci sequence: $1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, \\cdots$ (each number is the sum of the previous two, e.g., $144=55 + 89$).\n",
        "\n",
        "You probably have seen Fibonacci before, this should be familiar. The twist is we are going to look at a variety of ways of implementing it and the complexity of execution for each.\n",
        "\n",
        "A direct implementation of the description above would lead to pseudo code like this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "id": "BXpLO10ZoMB0"
      },
      "outputs": [],
      "source": [
        "def bad_fibonacci(n):\n",
        "  \"\"\"Return the nth Fibonacci number.\"\"\"\n",
        "  if n <= 1:\n",
        "    return n\n",
        "  else:\n",
        "    return bad_fibonacci(n-2) + bad_fibonacci(n-1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "id": "ASpEODTcoMB0",
        "outputId": "fdee6176-df37-434c-ddb7-ec1ebf057def",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n"
          ]
        }
      ],
      "source": [
        "for n in range(10):\n",
        "    print(bad_fibonacci(n))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {
        "id": "4ymZZOkQoMB1",
        "outputId": "a76dac6e-df50-4251-fa55-2412a6d10f9b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "43.3 µs ± 7.77 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "bad_fibonacci(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {
        "id": "3-1AurwHoMB1",
        "outputId": "0e3a9312-6557-4856-957d-114e577a4e25",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "81.4 µs ± 26 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "bad_fibonacci(12)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {
        "id": "F8ZKTRrtoMB1",
        "outputId": "6d23c00b-0025-4bd8-be92-9489d5bbeb09",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "418 µs ± 9.66 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "bad_fibonacci(16)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {
        "id": "bukSJt_FoMB1",
        "outputId": "19764949-abdd-4ffb-e0dc-064f227cf122",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.9 ms ± 62.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "bad_fibonacci(20)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 66,
      "metadata": {
        "id": "h2qHS4ufoMB1",
        "outputId": "313d7bb6-dee5-402a-91e6-e1e22ac29442",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "21.6 ms ± 3.22 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "bad_fibonacci(24)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "id": "aBfas4yGoMB2",
        "outputId": "2d975bc3-20db-48e2-9feb-e87a3eecd93d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.06 s ± 336 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "bad_fibonacci(32)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "id": "veZFc6deoMB2",
        "outputId": "b3f23683-74d5-42b7-b4a1-86d3f4604d0f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "input_arr = [i for i in range(1, 35, 1)]\n",
        "\n",
        "fun2 = automatic_time(input_arr, bad_fibonacci)\n",
        "plt.plot(input_arr, fun2)\n",
        "plt.xlabel(\"input size\")\n",
        "plt.ylabel(\"running time in seconds\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QJmjhfx1oMB2"
      },
      "outputs": [],
      "source": [
        "# so bad_fibonacci looks like an exponational complexity"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "id": "WQLAvSzroMB2",
        "outputId": "18eb0235-6490-49d4-d68e-4f8f4e636dd9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 276
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "arr = [2**n for n in range(30)]\n",
        "plt.plot(list(range(30)), arr)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JlR0D9hpoMB3"
      },
      "outputs": [],
      "source": [
        "# sure smells like exponential"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EFXxMqhkoMB3"
      },
      "outputs": [],
      "source": [
        "# what is so bad about bad fibonacci ?\n",
        "# so for each recursive call you get new 2 recursive calls\n",
        "# it is like that story of inventor of chess in India\n",
        "# he asked for 1 grain of rice on first square\n",
        "# 2 on 2nd , 4 on 3rd, 8 on 4th,\n",
        "# the story modification is that king realized the problem\n",
        "# to get out of it king said ok, you have to count the rice \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "id": "6vmUpXeQoMB3",
        "outputId": "c58277f3-5ade-4c13-968d-a0fc9e1ebd45",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4294967296"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ],
      "source": [
        "2**32 # he could count half a board"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {
        "id": "Zy_s3r8SoMB3",
        "outputId": "3c4e8f13-ea42-4643-e4a3-58fa250040e0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "18446744073709551616"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ],
      "source": [
        "2**64 # not likely for a human..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {
        "id": "Iuiu8gf4oMB3"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "def good_fibonacci(n):\n",
        "  \"\"\"Return pair of Fibonacci numbers, F(n) and F(n-1).\"\"\"\n",
        "  if n <= 1:\n",
        "    return (n,0)\n",
        "  else:\n",
        "    (a, b) = good_fibonacci(n-1) # looks linear here\n",
        "    return (a+b, a) # we return a tuple (two heterogenous values)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "id": "s14A0JNMoMB3",
        "outputId": "f46ddab4-73c6-4380-c50d-c73f172c7d29",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.92 µs ± 295 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "good_fibonacci(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "id": "0LoU_ANboMB4",
        "outputId": "4d4cb16c-f076-4c22-eee6-613084983915",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4.02 µs ± 187 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "good_fibonacci(20)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "id": "l5vbj7v4oMB4",
        "outputId": "4939bf81-81ad-4672-88fe-9b8caabf9de2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8.14 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "good_fibonacci(30)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "id": "080jmIgloMB4",
        "outputId": "d242f4ec-478c-4a42-d705-1405760e133e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ0AAAEGCAYAAAC+fkgiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhV1bn48e+bOUDCGCAmjBJUVGQSZ2ydcKpYR7S1trVVW/2pba+32Fqv9dZ7q7dqJ1vrVKy1IuKESotjwREIiMggEGUew5gTwknO8P7+2PuEQ8iwk5x9kpO8n+c5T/ZZe8jaHjxv1lrvXktUFWOMMSYZ0tq6AsYYYzoPCzrGGGOSxoKOMcaYpLGgY4wxJmks6BhjjEmajLauQFvq06ePDh48uK2rYYwxKWXhwoU7VLWgJed26qAzePBgSktL27oaxhiTUkRkXUvPte41Y4wxSWNBxxhjTNJY0DHGGJM0FnSMMcYkjQUdY4wxSWNBxxhjTNJY0DHGGJM0FnRMrUhUeW7BekKRaFtXxRjTQVnQMbUWrtvNT1/4jI++2NnWVTHGdFAWdEytPVU1zs/9oTauiTGmo7KgY2pVVocBqLCgY4zxiQUdUysQdINO0IKOMcYfFnRMrYAbbCr2h9u4JsaYjsqCjqkVqLaWjjHGXxZ0TK3a7jUb0zHG+MSCjql1YEzHuteMMf6woGNqVbrdagHrXjPG+MSCjqll3WvGGL9Z0DG1ap/Tse41Y4xPLOiYWtbSMcb4zYKOqRVLla4ORwmGIm1cG2NMR2RBxwCgqlRWh+nZJRM40OoxxphE8jXoiMi5IrJSRMpEZEo9+7NF5Dl3/zwRGRy37w63fKWITHTLckRkvoh8KiLLROSXcccPca9R5l4zy89762j21URQhcN65AL2gKgxxh++BR0RSQceBs4DRgBXiciIOoddB+xW1WHAQ8B97rkjgMnA0cC5wJ/c61UDZ6jqccAo4FwROdG91n3AQ+61drvXNh5Vui2b2qBj4zrGGB/42dIZD5Sp6peqWgNMAybVOWYS8JS7PQM4U0TELZ+mqtWqugYoA8aro9I9PtN9qXvOGe41cK95sV831hHFns0pcoOOda8ZY/zgZ9ApAjbEvd/oltV7jKqGgb1A78bOFZF0EVkMbAfeVNV57jl73Gs09Ltwz79eREpFpLS8vLwVt9exxNKki6x7zRjjo5RLJFDViKqOAoqB8SJyTDPPf1RVx6nquIKCAn8qmYJiz+gU9Yx1r1lLxxiTeH4GnU3AgLj3xW5ZvceISAbQHdjp5VxV3QO8izPmsxPo4V6jod9lGhHrXrNEAmOMn/wMOguAEjerLAsnMWBmnWNmAte625cB76iquuWT3ey2IUAJMF9ECkSkB4CI5AJnA5+757zrXgP3mq/4eG8dTmwMpyAvm8x0sUQCY4wvMpo+pGVUNSwiNwOzgXTgSVVdJiL3AKWqOhN4AnhaRMqAXTiBCfe46cByIAzcpKoRESkEnnIz2dKA6ar6mvsrfwpME5FfAZ+41zYexbLX8nIyyM/JtJaOMcYXvgUdAFWdBcyqU3ZX3HYQuLyBc+8F7q1TtgQY3cDxX+JkzJkWCARDiEC3rAzycjJsTMcY44uUSyQw/ghUh+mWlUFampCfay0dY4w/LOgYwBnT6ZbjNHzzczJtTMcY4wsLOgZwutfyYkEnN8MeDjXG+MKCjgGc53TycpzJPi2RwBjjFws6BnC717JjLZ1MSyQwxvjCgo4BnJTp2u61nAz2hyLUhKNtXCtjTEdjQccAztxrB8Z0YmvqWBebMSaxLOgYIJZI4ASbWPCpsGQCY0yCWdAx1ISjVIej5GUfSJkGW1PHGJN4FnRM7QzT3ep0r1kGmzEm0SzomNqxm/iUaafcuteMMYllQcfUBpf4h0PButeMMYlnQcccCDp1x3Sse80Yk2AWdEztmE6se61LVjrpaWIPiBpjEs6Cjqkd04klEogI+TkZ1tIxxiScBR1zyJiOs20zTRtjEs+CjonrXjsQdPJzM+zhUGNMwjUZdESkq4ikudvDReQiEcn0v2omWSqCIbLS08jOSK8tszV1jDF+8NLSmQvkiEgR8AZwDTDVz0qZ5Iqf7DPGljcwxvjBS9ARVa0CLgH+pKqXA0f7Wy2TTPGrhsbYQm7GGD94CjoichLwDeB1tyy9keNNiolfNTTGuteMMX7wEnRuA+4AXlLVZSIyFHjX32qZZKqsDpOXffAwXX5uJvtqIoQjtqaOMSZxMpo6QFXnAHPi3n8J3OJnpUxyBYJhBvTqclBZvtvyCQTD9Oya1RbVMsZ0QA0GHRF5FdCG9qvqRb7UyCRdoL5EgriZpi3oGGMSpbHutd8ADwBrgP3AY+6rEvjCy8VF5FwRWSkiZSIypZ792SLynLt/nogMjtt3h1u+UkQmumUDRORdEVkuIstE5Na44+8WkU0isth9ne+ljsYZ04nNtxaTV7umjiUTGGMSp8GWjtuthog8oKrj4na9KiKlTV1YRNKBh4GzgY3AAhGZqarL4w67DtitqsNEZDJwH3CliIwAJuNkyR0GvCUiw4Ew8BNVXSQiecBCEXkz7poPqepvPN67AVSVyuow3bLrJhLEVg+1ZAJjTOJ4SSTo6iYPACAiQ4CuHs4bD5Sp6peqWgNMAybVOWYS8JS7PQM4U0TELZ+mqtWqugYoA8ar6hZVXQSgqgFgBVDkoS6mAVU1EaJKw91rlsFmjEkgL0HnR8C/ReTfIjIHJ3PtNg/nFQEb4t5v5NAAUXuMqoaBvUBvL+e6XXGjgXlxxTeLyBIReVJEetZXKRG5XkRKRaS0vLzcw210bLFncQ59TscWcjPGJF6TQUdV/wWUALfiZK0doaqz/a5YY0SkG/ACcJuqVrjFfwYOB0YBW3DGow6hqo+q6jhVHVdQUJCU+rZndVcNjbHuNWOMH5pMmXaNBQa7xx8nIqjq35o4ZxMwIO59sVtW3zEbRSQD6A7sbOxcd963F4BnVPXF2AGqui22LSKPAa95vLdOLVDPZJ8AXbMySBPrXjPGJJaXCT+fxslkOxU43n2Na/QkxwKgRESGiEgWTmLAzDrHzASudbcvA95RVXXLJ7vZbUNwWlrz3fGeJ4AVqvpgnXoWxr39OrDUQx07vbqrhsakpYmzvIF1rxljEshLS2ccMMINBp6palhEbgZm40yb86Q7o8E9QKmqzsQJIE+LSBmwCycw4R43HViOk7F2k6pGRORUnAlHPxORxe6v+pmqzgLuF5FROM8WrQVuaE59O6vK4MGrhsbLz82wlo4xJqG8BJ2lQH+ccZJmcYPBrDpld8VtB4HLGzj3XuDeOmXvA9LA8dc0t37m0FVD4+Vl20zTxpjE8hJ0+gDLRWQ+UB0rtBkJOob6Vg2NcVo61r1mjEkcL0Hnbr8rYdpOLJGgW1Y9QScnk/W7qpJdJWNMB+Zpwk8R6YeTQAAwX1W3+1stkyyBYIhu2RmkpR3aa5mfm2nP6RhjEspL9toVwHycsZcrgHkicpnfFTPJUd9knzG2po4xJtG8dK/9HDg+1roRkQLgLZxpa0yKq2+p6pj83AwC1WEiUSW9npaQMcY0l5dpcNLqdKft9HieSQGB6tAhk33GxGaerrQuNmNMgnhp6fxLRGYDz7rvrwT+6V+VTDJVBsP06FL/ejnxa+p073LoczzGGNNcXhIJbheRS3BmJAB4VFVf8rdaJlkCwTDFdVYNjYl1u+3dHzpoTiJjjGmpJoOOOw3NrNg8ZyKSKyKDVXWt35Uz/qsIhmsn96wr1r1mD4gaYxLFy9jM80A07n3ELTMdQGV1qN4pcMBJJABbPdQYkzhegk6GuwgbAO52/YMAJqWEIlGCoWiTiQTW0jHGJIqXoFMuIrVT3ojIJGCHf1UyyVLZyBQ4YAu5GWMSz0v22o3AMyLyMM4MzhuBb/laK5MUgUZmmAZnuQOxNXWMMQnkJXvtC+BEd7VOVLXS91qZpIh1mzXUvZaWJnTLzrDuNWNMwniZBqefiDwBPK+qlSIyQkSuS0LdjM8q3ck+G8pec/ZlWiKBMSZhvIzpTMVZiO0w9/0q4Da/KmSSJ9a9Vt9aOjF5OdbSMcYkjpeg00dVp+OmTatqGCdt2qS42AJuDY3pgJNMYGM6xphE8RJ09olIb5wkAkTkRGCvr7UySRHrXmsoew3c7jXLXjPGJIiX7LUfAzOBw0XkA6AAsKUNOoDa7rUGEgnAeUB0xRZr6RhjEsNL9toiETkdOAIQYKWq2rdQBxAIhslKTyMnM73BY/JzMmu74YwxprW8ZK9dDuSq6jLgYuA5ERnje82M7wLBUKNJBOCuHlodJhrVJNXKGNOReRnT+YWqBkTkVOBM4Angz/5WyyRDY6uGxuTnZKAKlTU2rmOMaT0vQSeWqXYB8Jiqvo7NvdYhVFZ7CDqxNXUsg80YkwBegs4mEfkLzuJts0Qk2+N5pp0LBBteNTQm9uCoPSBqjEkEL8HjCpyHQyeq6h6gF3C7l4uLyLkislJEykRkSj37s0XkOXf/PBEZHLfvDrd8pYhMdMsGiMi7IrJcRJaJyK1xx/cSkTdFZLX7s6eXOnZmTvda4yuC2kzTxphEajLoqGqVqr6oqqvd91tU9Y2mzhORdOBh4DxgBHCViIyoc9h1wG5VHQY8BNznnjsCmAwcDZwL/Mm9Xhj4iaqOAE4Eboq75hTgbVUtAd5235tGeBrTse41Y0wC+dlNNh4oU9Uv3TV4pgGT6hwzCXjK3Z4BnCki4pZPU9VqVV0DlAHj3YC3CEBVA8AKoKieaz2Fk2lnGhEIhshrsnst1tKx7jVjTOv5GXSKgA1x7zdyIEAccow7vc5eoLeXc92uuNHAPLeon6pucbe3Av3qq5SIXC8ipSJSWl5e3rw76kBU1U0kaKJ7rXb1UGvpGGNaLyUTAtxlFl4AblPVirr7VVVxp+2pZ9+jqjpOVccVFBT4XNP2q6omQlQbn+wTDsxWYAu5GWMSwcvDoZe4g/N7RaRCRAIicsgXfT02AQPi3he7ZfUeIyIZQHdgZ2PnikgmTsB5RlVfjDtmm4gUuscUAts91LHTCjSxamhMRnqaraljjEkYLy2d+4GLVLW7quarap6q5ns4bwFQIiJDRCQLJzFgZp1jZgLXutuXAe+4rZSZwGQ3u20IUALMd8d7ngBWqOqDjVzrWuAVD3XstCqrm55hOiY/J8O614wxCeFlws9tqrqiuRdW1bCI3IyTbp0OPKmqy0TkHqBUVWfiBJCnRaQM2IUTmHCPmw4sx8lYu0lVI+6sCNcAn4nIYvdX/UxVZwG/Bqa7C8ytw0n1Ng2IJQY0lUgATmCylo4xJhG8BJ1SEXkOeBmojhXW6dqqlxsMZtUpuytuOwhc3sC59wL31il7H2fS0fqO34kzTY/xoNJj9xo4yQT2cKgxJhG8BJ18oAo4J65MgSaDjmm/vKwaGpOfk8nWiqDfVTLGdAJeljb4TjIqYpLLy6qhMfm5mazaHvC7SsaYTqDBoCMi/6mq94vIH6gn/VhVb/G1ZsZXXlYNjXESCax7zRjTeo1948SSB0qTURGTXLFEgq5ZXsZ0nIXcVBUngdAYY1qmwW8cVX3V/flUQ8eY1FUZDNMtO4P0tKaDSH5OJlGFfTWRJmelNsaYxqTkjASm9QLBkKeuNbCpcIwxiWNBp5MKuC0dL/JseQNjTIJY0OmkvKwaGlM707QlExhjWsnL3GvDReRtEVnqvh8pInf6XzXjp0AwRDcP6dJg3WvGmMTx0tJ5DLgDCAGo6hLc6WpM6vKygFuMrR5qjEkUL0Gni6rOr1Nm/SwpLlAdJt9zIoGtHmqMSQwvQWeHiByO+4CoiFwGbGn8FNPeBYKhZiQS2Jo6xpjE8PKtcxPwKHCkiGwC1gDf9LVWxlehSJRgKOppChyAzPQ0umSlW/eaMabVvMy99iVwloh0BdJU1SbhSnHNmWE6Jj8n07LXjDGt1uS3joj0AL4FDAYyYtOg2Nxrqat2hulmzC6Ql2OrhxpjWs/Lt84s4GPgMyDqb3VMMgSasWpoTH6uLeRmjGk9L0EnR1V/7HtNTNIEWtS9lsGOyhq/qmSM6SS8ZK89LSLfF5FCEekVe/leM+ObFo3pWEvHGJMAXr51aoD/A37OgXV1FBjqV6WMv1rUvZaTac/pGGNazUtL5yfAMFUdrKpD3JcFnBTWkkSC/NwMKoJhVA9Zz88YT4KhCNc8MY93P9/e1lUxbchL0CkDqvyuiEmelo3pZBKJKvtDEb+qZTq4mYs3897qHfz0hSW1y6WbzsdL0NkHLBaRv4jI72Mvvytm/BMIhslMF7IzvE8yfmAqHHtWxzSfqvLXD9fSPz+H8spqfvvW6raukmkjXv7Ufdl9mQ7CWcAts1lLT8daRRXBEP275/hVNdNBzVuzixVbKvj1JceyZNNepn64lsvGFnNUYX5bV80kWZN/6qrqU/W9vFxcRM4VkZUiUiYiU+rZny0iz7n754nI4Lh9d7jlK0VkYlz5kyKyPbbUQlz53SKySUQWu6/zvdSxM2rOWjoxB9bUsW4R03xTP1hLjy6ZXDy6iP+ceATdczO58+WlRKOtHyPcvGc//zNrBUHr+k0JDQYdEZnu/vxMRJbUfTV1YRFJBx4GzgNGAFeJyIg6h10H7FbVYcBDwH3uuSNwlk84GjgX+JN7PYCpbll9HlLVUe5rVlN17Kyas2poTG33mvXFm2basKuKN5Zv5arxA8nJTKdHlyymnHckC9ftZsaija26djAU4fqnS3l07pe8YwkKKaGxls6t7s8Lga/V82rKeKBMVb9U1RpgGjCpzjGTgFiraQZwpjh9PpOAaaparaprcJIZxgOo6lxgl4ffbxpQ2Yy1dGJiyyDYmI5prqc/XoeIcM2Jg2rLLhtTzLhBPfnfWSvYva9lDx2rKj976TOWbqogKyONOSvLE1Vl46MGg46qxpYv+KGqrot/AT/0cO0iYEPc+41uWb3HqGoY2Av09nhufW52W2JPikhPD8d3ShXumE5zWEvHtERVTZhp89dz7jH9OaxHbm15Wprw3xcfQ0UwzP2zV7bo2k99uJYXF23iR2cN58wj+zJ3dbml9KcAL+lLZ9dTdl6iK5IAfwYOB0bhrPfzQH0Hicj1IlIqIqXl5Z3zL6NAMExeM7vXahMJbEzHNMOLizZREQzznZMHH7LvqMJ8vnPyYKYtWM8n63c367off7mT/359BWcd1Y//d8YwJgwvYMveIGXbKxNUc+OXxsZ0fiAinwFH1BnPWQM0OaYDbAIGxL0vdsvqPUZEMoDuwE6P5x5EVbepakRVozhLbI9v4LhHVXWcqo4rKCjwcBsdT0sSCbIz0snJTLOF3IxnqsrUD9dybFF3xg6qv+PhtrOH0zcvmztfXkrEY1LB5j37uemZRQzq3YUHrzyOtDRhwnDn/+U5qzrnH5KppLGWzj9wxm5mcvBYzlhV9bKI2wKgRESGiEgWTmLAzDrHzASudbcvA95Rp308E5jsZrcNAUqAuktmH0RECuPefh1Y2tCxnZmqUlkdplszgw64U+FY95rx6P2yHZRtr+TbJw9uMD2/W3YGd114NMs2V/D3j9c1ec1gKMIP/r6Q6nCUR68ZV5tVWdQjl2F9u1nQSQGNjensVdW1qnpVnTEdT4P47hjNzcBsYAUwXVWXicg9InKRe9gTQG8RKQN+DExxz10GTAeWA/8CblLVCICIPAt8hNMC2ygi17nXuj+WaQd8FfhRs/5LdBL7QxEiUW32mA64a+pYIoHx6K8frKVPt2wuPK6w0ePOP7Y/p5X04TezV7I9EGzwOFXlFy8v5dONe3ngiuMY1rfbQfsnlBQwf80uS51u57w/kt4CqjpLVYer6uGqeq9bdpeqznS3g6p6uaoOU9Xx7iqlsXPvdc87QlX/GVd+laoWqmqmqhar6hNu+TWqeqyqjlTVi+ISIUyclkyBE2MzTRuv1uzYxzufb+cbJwwkOyO90WNFhHsmHUN1OMr/vL6iweP+Pm89zy/cyC1nDGPi0f0P2T9heB+qw1HmrbHk1vbM16Bj2p/YnFfNfU4HbKZp491TH64lM134xokDPR0/pE9Xbjx9KC8v3syHX+w4ZP+Ctbv45cxlfPWIAm47a3i91zhxaG+yLXW63bOg08nEWjr5Lehec1o61r1mGhcIhpixcCMXjjyMvnnep0z64VeHMaBXLr94eSk14QOLFG/dG+QHf19Ecc9cfjt5NGlp9Y8P5WSmM35IL+autqDTnjUZdEQkICIVdV4bROQlEbElDlJM7bIGLUokyLCWjmnSjIUbqawO8+160qQbk5OZzj0XHcMX5ft44v01AFSHI/zgmYVU1YR59Fvj6J7b+B9Lpw8voGx7JZv27G9p9Y3PvLR0fgvcjvNwZjHwHziZbdOAJ/2rmvFDIsZ07AE805BoVHnqw7WMGdiD4wb0aPb5Xz2yLxOP7sfv317Nxt1V3D1zOZ+s38MDlx/H8H55TZ4fS52ea1ls7ZaXoHORqv5FVQOqWqGqjwITVfU5wJ76TzGVLVg1NCY/J5NQRAmGok0fbDqlf6/aztqdVXznlCEtvsZdXzsagKsfm8ez89fzw68cznnHNp4BF1PStxuF3XMs6LRjXoJOlYhcISJp7usKIJbXaH/yppiWrBoak5+b4V7DuthM/f76gbNmzrnHHJpd5lVRj1xuPauE9buqmDC8gJ+cc4Tnc0WECSUFvF+2g3DE/jhqj7wEnW8A1wDbgW3u9jdFJBfnORyTQloTdGKtI0ubNvVZvS3Ae6t3cM1Jg8hMb12O0nWnDuGBy4/jj1ePJr2BxIGGTBheQCAYZvGGPa2qg/FHk9887rMzDc0q/X5iq2P8FlvWoLn/I8OBmab32gOiph5TP1xLVkYak48f0PTBTchMT+PSscUtOvfUYX1IE2dcZ9zgXq2ui0msJoOOiBQA3wcGxx+vqt/1r1rGL4FgqEWtHLCZpk3D9laFeHHRJi4edRi9u2W3aV26d8lk1IAezFm9gx83o2vOJIeXb59XgPeAtwCbXyLFtWSyzxhbPdQ05LnS9ewPRfj2yS1PIEikCcML+N3bq9m1r4ZeXbPaujomjpeO1y6q+lNVna6qL8RevtfM+CIQbNlkn3AgkcAeEE1Nv3ptOVc88hHbKhqe36wlwpEoT324jhOG9GLEYfkJvXZLnT68AFVn0lHTvngJOq+JyPm+18QkRaA63KJ0abCWTipbuG4Xj7+/hvlrd3HJnz5k9bZAwq791optbNqzv1Vp0ok2srgHPbpkWup0O+Ql6NyKE3j2u7MRBESkwu+KGX8EgqEWd6/lZKaTlZFmYzopJhJVfvHyMgq75zD9hpOoiUS59M8fMu/Lna2+9t6qEH/69xcU9cjl7BH9ElDbxEhPE04Z1oe5q2w10famyaCjqnmqmqaquaqa775vH21o02wtWTU0Xn5Opi3klmKembeO5VsquPOCEYwf0osXf3AyBXnZXPPEfF5bsrnF133n822c89s5LNtcwe0Tj2hRRqSfTh9ewPZANZ9vTVyrzrReYyuHHun+HFPfK3lVNIlUGWx5IgHY/GupZkdlNf83eyWnDuvD+cc6D2wO6NWFF35wMscN6M7N//iEx+Z+2azWQEUwxO3Pf8p3p5bSIzeLV246hYtHF/l1Cy02ocSmxGmPGvv2+TFwPfBAPfsUOMOXGhnfhCJR9ociLR7TAcizmaZTyn3//JxgKMLdFx190OqdPbpk8fR1J/CT6Z9y76wVbNqzn19cOKLJ1srcVeX89IUlbKsIctNXD+eWM0uaXC+nrfTvnsMR/fKYs6qcG04/vK2rY1wNBh1Vvd79+dXkVcf4qbIVsxHEWEsndSxct5vnF27kxtMPP2SVTXDG6P5w1WgKu+fw+Ptr2Lo3yG8njyIn89AgUlkd5n9mreAf89ZzeEFXXvzhKYxqwYSeyXb6EQVM/WAtVTVhumS1/N+9SRxPc1WIyMkicrWIfCv28rtiJvEqq1s+w3SMrR6aGpzkgaUUds/h/50xrMHj0tKEOy8cwS8uHMHs5Vv5xuPz2LWv5qBjPizbwcSH5vLs/PXcMGEor99yWkoEHHC62GoiUT5OQNJEe1cTjqZE0oSXGQmeBg4HFnPg4VAF/uZjvYwPYsGidWM6mVTYNDjtXix54OGrx9DVQ8v2ulOHUNg9h9ueW8xlf/6Qqd8ZT5+8LH79z8/520frGNKnKzNuPImxg1JrWplxg3uSk5nG3FU7OOPI9pNdlyh7qmp4Y9k2Xv9sCx+U7SArI42BvbowoFcXBvXqwsDezvbAXl0o7pnbLrpCvXz7jANGaCqEUNOoytq1dFo+ppOfm2EtnXZuR2U1v5m9klOG9a5NHvDi/GMLKcjL5vt/K+WSP39A1+wM1u+q4runDOH2iUeQm9X2X1jNlZOZzklDezOnAyUTxALNa59t4cOyHYSjyoBeuXz75MFEFdbvqmLdzn28t7r8oGVIRKAwP6c2CH331CEcVZj8RGQvQWcp0B/Y4nNdjM9as4BbTH5OJjXhKMFQpN6+f9P27vvn5+wPRfjlRccclDzgxfGDezHjxpP5ztT5qMK075/ICUN7+1TT5JgwvIB3X13Ohl1VDOjVpa2r0yK799XwxvKtvP7Z1tpAM7BXF7532lAuOLaQY4ryD/msVZXyymrW76xi/S735W7PWVXO5eNaPzFrS3j59ukDLBeR+UB1rFBVL/KtVsYXAXcBt1YlEriTfgaCYQs67VAseeCG04fWmzzgxbC+3Xjrx6eTLkJGK5coaA9iq4nOWVXON08c1Ma1gfJANet3VRGORAlFlFA0SigcJRxVQrGySJSwm236ftnOQwLNhSMLOfqwQwNNPBGhb14OffNy2tVs216+fe72uxImORLSvZYTm38tREFe284mbA4WiSp3vbKU/vk53HJGSauu1R76/hNlaJ+uFPfMbfOgs2FXFX/69xfMWLiBUMT7aMXAXl34/gSnRdNUoEkFXtbTmZOMihj/VSSoew1s/rX26B/z1rFscwV/vHq0p+SBzkJEmDC8gJmLNxOKRFu9wFxzfVleyZ/+/QUvfbKJdBEmHz+QM47qS3Z6GhnpaWSmC5npaWD8ZfEAABfwSURBVO7rwHaGu52fk5HygSael+y1S4D7gL6AuC/1MhWOiJwL/A5IBx5X1V/X2Z+NkwU3FtgJXKmqa919dwDX4WTM3aKqs93yJ4ELge2qekzctXoBz+Gs+7MWuEJVdzdVx86ksjpMZrqQndHy/+lspun2aac788Apw3pzwbGFbV2ddmdCSQH/mLeeRet2J22MatW2AH98p4zXlmwmKyONa08azA2nD6Vffk5Sfn975eXPofuBr6nqiuZcWETSgYeBs4GNwAIRmamqy+MOuw7YrarDRGQyTnC7UkRGAJOBo4HDgLdEZLiqRoCpwB85NGV7CvC2qv5aRKa473/anDp3dM5kn5mt+qvJWjrt033/annyQGdw8rDeZKQJc1aV+x50lm+u4I/vruafS7eSm5nO9ycM5XunDrXuaJeXoLOtuQHHNR4oc5e7RkSmAZOA+KAziQNjRjOAP4rzf8wkYJqqVgNrRKTMvd5HqjpXRAbX8/smAV9xt58C/o0FnYPElqpuDVs9tP1ZuG4300tblzzQ0eXnZDJmYE/mri7nP8890pffsWTjHn7/dhlvrdhGXnYGN391GN89ZQg9bRG5g3j5BioVkeeAlzk4e+3FJs4rAjbEvd8InNDQMaoaFpG9QG+3/OM65zY1o2A/VY2ldW8F6n0STESux5lTjoEDBzZxyY6ltZN9QnxLx7rX2oNEJg90dBOG9+E3b6xiR2U1fRK4pHYkqtzx4hKml26ke24mPzprON8+ZTDdc1uesNOReenczweqgHOAr7mvC/2sVGu5D7LWmx6iqo+q6jhVHVdQUJDkmrWtQAKCTk6mM9hpLZ22V1UT5u6Zy1i2uYI7LzzKkgeaEEudfm914h4UjUaVKS8sqW1pvv/Tr3LrWSUWcBrhJXvtOy289iYg/umjYresvmM2ikgG0B0nocDLuXVtE5FCVd0iIoXA9hbWu8OqCIYo7tm6h+NExJ0Kx4JOW3pr+Tb+a+YyNu3Zz7dOGmTJAx4cc1h3enXNYu6qHXx9dHGrr6eq3DVzKc8v3MgtZ5bw47OHJ6CWHZ+X7LW/Uk+rQVW/28SpC4ASERmCEzAmA1fXOWYmcC3wEXAZ8I6qqojMBP4hIg/iJBKUAPOb+H2xa/3a/flKE8d3OpXV4drnbFojLyfDFnJrI5v27OeXM5fxxvJtDO/XjedvPInj29GDf+1ZWppwWomzmuje/aFWtUZUlV+9voK/f7yeG04fyo/Osq5Nr7x8A70Wt50DfB1ocrlBd4zmZmA2Tsr0k6q6TETuAUpVdSbwBPC0myiwCycw4R43HSfpIAzc5GauISLP4iQM9BGRjcB/qeoTOMFmuohcB6wDrvBwb51KIBimWwKCjs00nXyhSJS/frCGh95cDcCU847kulOHJP2Zk1R32dhiXluyhfN/9x5/uHo0Ywb2bNF1fvPGSp54fw3fPnkwU8490jIGm8FL99oL8e/dL/33vVxcVWcBs+qU3RW3HQQub+Dce4F76ym/qoHjdwJneqlXZ6SqVFa3fkwHsO61JFu4bhc/f2kpn28NcNZRfbn7oqNb3U3aWZ1WUsD0G07ilmc/4fJHPuI/zjmCGyYMJa0ZS23/4e3VPPzuF1w1fiD/9bURFnCaqSV/JpXgPChqUsj+UIRIVFs1BU6MM9O0da/5bU9VDXe8uIRL//wRFftDPHrNWB6/9ngLOK00dlBPZt16GhOP7sd9//qca/86n+2BoKdzH537BQ+8uYpLxhRx78X2TFRLeBnTCXDwmM5W7PmXlBNIwKqhMdbS8Zeq8uKiTdw7awV794e4fsJQbj2zxLLTEqh7biYPXz2GZ+dv4JevLuP8373Hg1eMqs1wq89TH67lf2Z9zoUjC7n/0pHNah2ZAxr9V+w+qHm0qq5PUn2MTxKxrEGMjen4Z9H63fz3a8v5ZP0exgzswb1fP7ZN1jzpDESEq08YyNhBPbn5H4v41pPzufH0w/nJOcMPGSubNn89/zVzGeeM6MdDV47qELNvt5VGv4HcTLLXgWOTVB/jk0ACVg2Nyc/JIBiKUh2OdKjZiNvShl1V3D97Ja9+upmCvGzuv3Qkl40ttr+mk+CI/nnMvPlU7nltOY/M+YJ5a3by+8mja9feeemTjdzx0md85YgC/nD1aEveaCUv30CLROR4VV3ge22MbyqrW7+sQUz8mjrZ3SzotEYgGOLhd7/gyQ/WkCZwy5kl3DBhqHWlJVluVjr/e8mxnDqsD1NeWML5v3+PX18yEoCfTP+Uk4b25pFvjrU/shLAy7/sE4BviMg6YB8HZpke6WvNTEIlsnstdo1AMJzQ6UQ6k3AkynOlG3jwjVXs3FfDJWOKuH3iERR2z23rqnVqF4wsZGRxd/7fs59w0z8WkSZO4sHj146zRQsTxMs30ETfa2F8F+teS1QiAdhM0zsrq1mwdhfdsjMp7plLYY8cT38Jz1lVzr2vL2fVtkrGD+nFXy84ipHFPZJQY+PFgF5deP7Gk/jtW6tYva2SB644ji5Z1vJMFC/P6axLRkWMvwIJWDU0prPONK2qfL41wDufb+ftFdv4ZMMeNC6vUwT65mVT1COX4p5dKOqZ6247r2Aoyv/NXsmcVeUM6t2FR745lolH97O023YoMz2N2yf6Mxt1Z2fhu5NIdMo0dI6ZpoOhCB99sZO3P9/GOyu2s3mv8zzHccXdufXMEk4rKaAmHGXTnv1s2r2fjbur2LRnP4s37OGfS7ccsixxfk4Gd15wFN86aTBZrVhMz5hUZUGnkwgEw3TNSic9AdlQB1YP7ZgtnW0VwdrWzPtlOwiGonTJSue0kj7cdtZwvnJEAX09rP4YiSrlgeraQFSxP8SFIw+z9VVMp2ZBp5OorA4lpGsNOuaYTiSqzF1VzjPz1vHO59uJKhT3zOXKcQM486h+nDC0V7Mzl9LThP7dc+jfPYdxPtXbmFRjQaeTSNRknwBd3BZTR2jplAeqmV66gWfnr2fj7v306ZbND75yOJNGFVHSt5uNtxiTYBZ0OolETfYJsTV1MlJ2TEdVmbdmF3//eB2zl20lFFFOGtqbKecdyTkj+ttYizE+sqDTSVQEwwldzTAvJ/WmwtlbFeKFRRt5Zt46vijfR35OBtecOJirTxjIsL7d2rp6xnQKFnQ6iUAwRHGPxD14mJ/b/hdyC0eirNwWYNG63cxfu5s3l28lGIoyakAP/u+ykXztuMPsgT9jksyCTidRGUxc9xq0z5mm91aFWLRhN4vW7Wbhut0s3rCHqpoI4Dw/8/XRRXzjhEEcU9S9jWtqTOdlQaeTCPgQdL7cUZmw67XE5j37eb9sR22QWb3dqU96mnBUYR6Xjy1mzKCejB3Uk6IeuZYUYEw7YEGnEwhHouwPReiWnbgxnfzctkkkCIYivLF8G8+XbuD9sh2oOg9cjh3Uk0mjDmPMoJ4cV9zDJsw0pp2y/zM7gQMzTCe4ey2JiQRLN+1leukGXv5kExXBMEU9crnljBIuGFnIsIJutgSAMSnCgk4nUDsFTiKDTm4mVTURQpGob+uL7N5XwyuLNzG9dCPLt1SQlZHGuUf354pxAzj58N4WaIxJQRZ0OoFY0MlPaEvHnQpnf4jeCVzeIBJV3i/bwfTSDby5bBs1kSjHFnXnvycdzUXHFdG9S+K6CI0xyWdBpxM4sGpo4r6w++Q5gebyv3zE1eMHcumY4lbNKbZhVxXPL9zIjNINbN4bpEeXTL5x4kAuHzuAEYfZcs3GdBQWdDqBRM4wHXPeMYU8cHmUZ+at41evr+D+2Su54NhCrj5hIOMG9fSUKVYdjvDm8m08t8BJCgA4raSAn11wFGeP6GerNBrTAVnQ6QT8SCRITxMuHVvMpWOL+XxrBf+Yt56XFm3ipU82UdK3G1efMJBLRhfX2x22cmuA5xZs4KVPNrK7KkRRj1xuPbOEy8YWU9yzS8LqaIxpf3wNOiJyLvA7IB14XFV/XWd/NvA3YCywE7hSVde6++4ArgMiwC2qOruxa4rIVOB0YK97+W+r6mI/7y9V1K4amsCgE+/I/vncM+kYppx3JK9+upln5q3nl68u575/fc6FIw/j6hMGMrxfHq99uplpCzaweMMeMtOFc0b054rjB3DqsD4JWXLBGNP++RZ0RCQdeBg4G9gILBCRmaq6PO6w64DdqjpMRCYD9wFXisgIYDJwNHAY8JaIDHfPaeyat6vqDL/uKVUFqmOJBP4OwnfJyuDK4wdy5fEDWbppL8/MW88rizcxY+FGMtKEcFQp6duNOy84iq+PLkpoAoIxJjX42dIZD5Sp6pcAIjINmATEB51JwN3u9gzgj+IMBkwCpqlqNbBGRMrc6+HhmqaOQDBMZrqQncTZk48p6s7/XnIsPzv/SF5ZvJkvy/dxwchCxgzsYTMDGNOJ+Rl0ioANce83Aic0dIyqhkVkL9DbLf+4zrlF7nZj17xXRO4C3gamuEHrICJyPXA9wMCBA5t5S6kpEAzRLTujTb7s83Iy+eaJg5L+e40x7VNHWjjkDuBI4HigF/DT+g5S1UdVdZyqjisoKEhm/dqMM9mnPd9ijGl7fgadTcCAuPfFblm9x4hIBtAdJ6GgoXMbvKaqblFHNfBXDnTHdXqJnuzTGGNays+gswAoEZEhIpKFkxgws84xM4Fr3e3LgHdUVd3yySKSLSJDgBJgfmPXFJFC96cAFwNLfby3lBKoDif0GR1jjGkp376J3DGam4HZOOnNT6rqMhG5ByhV1ZnAE8DTbqLALpwggnvcdJwEgTBwk6pGAOq7pvsrnxGRAkCAxcCNft3bwnW7+fjLndz01WF+/YqECrgTZBpjTFvz9c9fVZ0FzKpTdlfcdhC4vIFz7wXu9XJNt/yM1tbXq1c/3czUD9eSnZHG904bmqxf22KBYIi8nLy2roYxxtiMBC3xiwtHUB6o5levryA/N5Mrxg1o+qQ2VFltYzrGmPbBvolaID1NePDK46gIhpjywhLyczI595j+bV2teqmqJRIYY9qNjpQynVTZGen85ZqxjBrQg1ue/YQP3Akr25v9oQiRqCZ01VBjjGkpCzqt0CUrg79+ezxDC7ry/b+V8sn63W1dpVobdlXxyJwvuPIvzjO2PW0dGmNMOyBOhnLnNG7cOC0tLW31dbZXBLn8Lx+xd3+I6TecxPB+bTNov35nFa9/toVZn23hs03OvKfHFXfn/GMLueakQXTJsi42Y0zrichCVR3XonMt6LQ+6IDTsrj0zx8iAjNuPJkBvZIzRX9DgeaCkYWcd0xh0uphjOk8LOi0UCKDDsCqbQGu+MtH5OdkMuPGk+ibn5Owa8dEo8ryLRXMWVXOP5duYemmCgCOG9CDC47tb4HGGOM7CzotlOigA/DJ+t184/F5DOzVheeuP6neRcyaa+veIO+tLue91Tt4v2wHu/bVABZojDFtozVBxzr5E2z0wJ48es04vjt1Ad+ZOp+/f++EZo+l7K+JMH/tLt5b5QSaldsCAPTpls1Xhhdw2vA+nDKsD33zEt+SMsYYP1nQ8cGpJX34/VWj+OEzi7jh6YU8fu04sjPSiUaVQHWYiv0h9u4PUbE/REUwth1mz/4aPt2wl/lrd1ETjpKVkcb4wb24dGwRp5UUcGT/PFuLxhiT0qx7LcHda/GmL9jAf76whD7dsqgJRwlUh2nsP3eawLC+3ZhQUsBpwwsYP7gXuVnpvtXPGGNawrrX2qkrjh9AVkYac1aV0z03k/ycDPJzM8nPzXTfOz+7d3H2tdVCa8YYkywWdHx28egiLh5d1PSBxhjTCdiMBMYYY5LGgo4xxpiksaBjjDEmaSzoGGOMSRoLOsYYY5LGgo4xxpiksaBjjDEmaSzoGGOMSZpOPQ2OiJQD6+KK+gDtc93p1uuo92b3lXo66r11pvsapKoFLblYpw46dYlIaUvnE2rvOuq92X2lno56b3Zf3lj3mjHGmKSxoGOMMSZpLOgc7NG2roCPOuq92X2lno56b3ZfHtiYjjHGmKSxlo4xxpiksaBjjDEmaSzouETkXBFZKSJlIjKlrevTXCKyVkQ+E5HFIlLqlvUSkTdFZLX7s6dbLiLye/del4jImLat/cFE5EkR2S4iS+PKmn0vInKte/xqEbm2Le4lXgP3dbeIbHI/t8Uicn7cvjvc+1opIhPjytvVv1URGSAi74rIchFZJiK3uuUp/Zk1cl8d4TPLEZH5IvKpe2+/dMuHiMg8t57PiUiWW57tvi9z9w+Ou1a999wgVe30LyAd+AIYCmQBnwIj2rpezbyHtUCfOmX3A1Pc7SnAfe72+cA/AQFOBOa1df3r1HsCMAZY2tJ7AXoBX7o/e7rbPdvhfd0N/Ec9x45w/x1mA0Pcf5/p7fHfKlAIjHG384BVbv1T+jNr5L46wmcmQDd3OxOY534W04HJbvkjwA/c7R8Cj7jbk4HnGrvnxn63tXQc44EyVf1SVWuAacCkNq5TIkwCnnK3nwIujiv/mzo+BnqISGFbVLA+qjoX2FWnuLn3MhF4U1V3qepu4E3gXP9r37AG7qshk4BpqlqtqmuAMpx/p+3u36qqblHVRe52AFgBFJHin1kj99WQVPrMVFUr3beZ7kuBM4AZbnndzyz2Wc4AzhQRoeF7bpAFHUcRsCHu/UYa/8fVHinwhogsFJHr3bJ+qrrF3d4K9HO3U/F+m3svqXSPN7vdTE/GuqBI0ftyu11G4/zl3GE+szr3BR3gMxORdBFZDGzHCfBfAHtUNeweEl/P2ntw9+8FetOCe7Og03GcqqpjgPOAm0RkQvxOddrCHSI/viPdC/Bn4HBgFLAFeKBtq9NyItINeAG4TVUr4vel8mdWz311iM9MVSOqOgooxmmdHJmM32tBx7EJGBD3vtgtSxmqusn9uR14Cecf0bZYt5n7c7t7eCreb3PvJSXuUVW3uf/zR4HHONA1kVL3JSKZOF/Mz6jqi25xyn9m9d1XR/nMYlR1D/AucBJOV2eGuyu+nrX34O7vDuykBfdmQcexAChxMzeycAbKZrZxnTwTka4ikhfbBs4BluLcQywD6FrgFXd7JvAtN4voRGBvXDdIe9Xce5kNnCMiPd3uj3Pcsnalzlja13E+N3Dua7KbNTQEKAHm0w7/rbp9+08AK1T1wbhdKf2ZNXRfHeQzKxCRHu52LnA2zpjVu8Bl7mF1P7PYZ3kZ8I7bem3onhvWlhkU7emFk1GzCqdf8+dtXZ9m1n0oTgbJp8CyWP1x+lzfBlYDbwG99EDmysPuvX4GjGvre6hzP8/idFuEcPqIr2vJvQDfxRnYLAO+007v62m33kvc/4EL447/uXtfK4Hz2uu/VeBUnK6zJcBi93V+qn9mjdxXR/jMRgKfuPewFLjLLR+KEzTKgOeBbLc8x31f5u4f2tQ9N/SyaXCMMcYkjXWvGWOMSRoLOsYYY5LGgo4xxpiksaBjjDEmaSzoGGOMSRoLOsa0kIh86MM1B4vI1c08Z1bsmQtj2jtLmTamHRGRr+DMYHxhW9fFGD9YS8eYFhKRSvfnV0Tk3yIyQ0Q+F5Fn3KfZY+sc3S/OWkfzRWSYWz5VRC6rey3g18Bp7jotP6rz+wpFZK67b6mInBb3O/qIyI1yYI2XNSLyrrv/HBH5SEQWicjz7lxixrQJCzrGJMZo4Dac9UWGAqfE7durqscCfwR+28R1pgDvqeooVX2ozr6rgdnqTNJ4HM4T8rVU9RF33/E4Mx48KCJ9gDuBs9SZELYU+HFLbtCYRMho+hBjjAfzVXUjgDtd/GDgfXffs3E/6waS5lgAPOlOQvmyqi5u4Ljf4cyN9aqIXIgTCD9wG19ZwEetqIMxrWJBx5jEqI7bjnDw/1taz3YYt6dBRNJwgkGjVHWuu2TFBcBUEXlQVf8Wf4yIfBsYBNwcK8JZGO0q77dijH+se80Y/10Z9zPWylgLjHW3L8JZuREggLM08iFEZBCwTVUfAx7HWfo6fv9Y4D+Ab6oz7T7Ax8ApcWNJXUVkeGtvyJiWspaOMf7rKSJLcFpDsRbHY8ArIvIp8C9gn1u+BIi45VPrjOt8BbhdREJAJfCtOr/nZqAX8K7blVaqqt9zWz/Piki2e9ydODMeG5N0ljJtjI9EZC3O1P072rouxrQH1r1mjDEmaaylY4wxJmmspWOMMSZpLOgYY4xJGgs6xhhjksaCjjHGmKSxoGOMMSZp/j9BzkkJwmloGgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "input_arr = [i for i in range(100, 3_000, 100)]\n",
        "\n",
        "fun2 = automatic_time(input_arr, good_fibonacci)\n",
        "plt.plot(input_arr, fun2)\n",
        "plt.xlabel(\"input size\")\n",
        "plt.ylabel(\"running time in seconds\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ayr6mvV3oMB4"
      },
      "outputs": [],
      "source": [
        "import sys\n",
        "print(sys.getrecursionlimit())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KDGhaKD-oMB4"
      },
      "outputs": [],
      "source": [
        "#https://stackoverflow.com/questions/3323001/what-is-the-maximum-recursion-depth-in-python-and-how-to-increase-it\n",
        "sys.setrecursionlimit(100_000)\n",
        "print(sys.getrecursionlimit())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "id": "r2BKjwjboMB4",
        "outputId": "eb272da2-e9ec-44e5-9e4b-bbdd10dbe0bf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3878968454388325633701916308325905312082127714646245106160597214895550139044037097010822916462210669479293452858882973813483102008954982940361430156911478938364216563944106910214505634133706558656238254656700712525929903854933813928836378347518908762970712033337052923107693008518093849801803847813996748881765554653788291644268912980384613778969021502293082475666346224923071883324803280375039130352903304505842701147635242270210934637699104006714174883298422891491273104054328753298044273676822977244987749874555691907703880637046832794811358973739993110106219308149018570815397854379195305617510761053075688783766033667355445258844886241619210553457493675897849027988234351023599844663934853256411952221859563060475364645470760330902420806382584929156452876291575759142343809142302917491088984155209854432486594079793571316841692868039545309545388698114665082066862897420639323438488465240988742395873801976993820317174208932265468879364002630797780058759129671389634214252579116872755600360311370547754724604639987588046985178408674382863125,\n",
              " 2397334346100631452333336800023778743396400988090212332865227234032387117767626167465060795065595580850691237390963845987165478074085124644348902530685083246709423858342692329718110162972268152200857232686119638781547238020078362945470777668711057069618425746387920931255084621360135655698456629322111614827324455767748623844363426260372374195153577101298837831208580530677289982029527164306876024342838547454228388796380077029917639469963653048076473269452943584037848773158456736367057460079075603072996653089318046279296240100777360367200040226807430924334616931577257195085793060133817911514540227011756335999604550121968663793604830945238116686325506344893928776515696088851468818023735825546502317562957459506612704850760351077006532507519813600498603205937022956740021970327599548184626715032015801445754074519753924901317605013561516613650173445818028242577356369143977719495739428130191089993769093308407443558168431535751910046557480949313497996285124526992631353143367314930548703966553707195171094152730704138121243470432644848607501)"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ],
      "source": [
        "good_fibonacci(5_000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5SZMWLmxoMB4"
      },
      "outputs": [],
      "source": [
        "## Fibonacci Solutions\n",
        "\n",
        "1. timing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {
        "id": "zB8NX0IIoMB5"
      },
      "outputs": [],
      "source": [
        "def fibonacci_loop(n):\n",
        "    a, b = 1, 1 # we use tuple unpacking in Python\n",
        "    cnt = 3\n",
        "    while cnt <= n:\n",
        "        a, b = a+b, a # tuple unpacking again, no need for temp variables\n",
        "        cnt += 1\n",
        "    return a"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eKgHsBrJoMB5"
      },
      "outputs": [],
      "source": [
        "fibonacci_loop(2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3VUOhv45oMB5"
      },
      "outputs": [],
      "source": [
        "fibonacci_loop(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "id": "uH1IudS4oMB5",
        "outputId": "1d483f5b-db56-44e1-c442-68a03675cb77",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "input_arr = [i for i in range(1000, 200_000, 2000)]\n",
        "\n",
        "fun2 = automatic_time(input_arr, fibonacci_loop)\n",
        "plt.plot(input_arr, fun2)\n",
        "plt.xlabel(\"input size\")\n",
        "plt.ylabel(\"running time in seconds\")\n",
        "plt.show() # again we can see that it looks linear but also there is some extra complexity\n",
        "# from big numbers 200_000th Fibonacci is going to be quite large"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q8wY1JGQoMB5"
      },
      "outputs": [],
      "source": [
        "# 2. It is not tail recursive becuase there is something to do after returning the values (adding them together). We can use 2 accumulators to avoid this."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6vK-81NvoMB5"
      },
      "source": [
        "# Example: Binary Search"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EA-vfdA4oMB5"
      },
      "source": [
        "Binary search is a classic recursive algorithm to find a target value within a sorted sequence. This is among the most important of computer algorithms, and it is the reason that we so often store data in sorted order.\n",
        "\n",
        "e.g. For the sorted sequence below stored in a Python list with indexes above:\n",
        "\n",
        "<table>\n",
        "<tr><th>0</th><th>1</th><th> 2</th><th>3</th><th>4</th><th> 5</th><th>6</th><th>7</th><th> 8</th><th>9</th><th>10</th><th> 11</th> </tr>\n",
        "<tr><td>2</td><td>4</td><td> 5</td><td>6</td><td>8</td><td> 9</td><td>15</td><td>16</td><td> 17</td><td>22</td><td>30</td><td> 31</td> </tr>\n",
        "</table>\n",
        "\n",
        "If the sequence was unsorted a simple solution is a _sequential search algorithm_: use a loop to examine every element. You either reach the end of the list or find the target.\n",
        "\n",
        "It is linear complexity, running in $\\mathcal{O}(n)$ time as worst case it inspects every element in the sequence.\n",
        "\n",
        "A sorted sequence allows a much faster approach. Think about how you would accomplish this task by hand: divide in two, and choose the middle digit as a candidate to compare to the target. Everything to the left of the candidate is lower than it and everything to the right is higher. Compare the target to the candidate and discard the left if the candidate is lower and the right if it is higher. Then repeat your _binary search_ algorithm. This is much more efficient, running in $\\mathcal{O}($log$n$) time.\n",
        "\n",
        "Review the iterative and recursive binary search algorithm implementations below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {
        "id": "js3oMQE5oMB6"
      },
      "outputs": [],
      "source": [
        "def binary_search_iterative(data, target):\n",
        "    \"\"\"Return True if target is found in the given SORTED Python list.\"\"\"\n",
        "    low = 0\n",
        "    high = len(data)-1\n",
        "    while low <= high: # so while array/list pointers do not meet we keep going\n",
        "        mid = (low + high) // 2 # // meaning even half\n",
        "        if target == data[mid]:         # found a match\n",
        "            return True\n",
        "        elif target < data[mid]:\n",
        "            high = mid - 1                # only consider values left of mid\n",
        "        else:\n",
        "            low = mid + 1                 # only consider values right of mid\n",
        "    return False                      # loop ended without success"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "id": "_axJZbTKoMB6"
      },
      "outputs": [],
      "source": [
        "def binary_search(data, target, low, high):\n",
        "    \"\"\"Return True if target is found in indicated portion of a Python list.\n",
        "\n",
        "      The search only considers the portion from data[low] to data[high] inclusive.\n",
        "      \"\"\"\n",
        "    if low > high:\n",
        "        return False                    # interval is empty; no match\n",
        "    else:\n",
        "        mid = (low + high) // 2\n",
        "    if target == data[mid]:         # found a match\n",
        "        return True\n",
        "    elif target < data[mid]:\n",
        "        # recur on the portion left of the middle\n",
        "        return binary_search(data, target, low, mid - 1)\n",
        "    else: # target > data[mid]\n",
        "        # recur on the portion right of the middle\n",
        "        return binary_search(data, target, mid + 1, high)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8OiHKPOKoMB6"
      },
      "source": [
        "When a function makes two recursive calls, we say that it uses binary recursion. Clearly the binary_search above is a binary recursion. Drawing the English ruler and the bad fibonacci function are also examples of binary recursion."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {
        "id": "y1F7JT8EoMB6",
        "outputId": "ee65914e-ba2a-48ca-eed5-3b411a098d51",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ],
      "source": [
        "data=[2,4,5,6,8,9,15,16,17,22,30,31]\n",
        "iter_ans = binary_search_iterative(data,100)\n",
        "iter_ans"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {
        "id": "OjIimH7zoMB6",
        "outputId": "04c5365b-ce71-4de4-f936-6ffb231535e6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ],
      "source": [
        "binary_search_iterative(data,15)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jXcCj0VNoMB7"
      },
      "outputs": [],
      "source": [
        "binary_search_iterative(data,7)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 84,
      "metadata": {
        "id": "ldNBPQ7SoMB7",
        "outputId": "8a946ac9-bd68-4c60-c30c-40d6f3a59cc5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "45.7 ms ± 8.11 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "binary_search_iterative(list(range(1_000_000)), 9000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {
        "id": "d2G0XCYvoMB7",
        "outputId": "f7a93c31-b051-4559-e337-55168a9764dc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "52.3 ms ± 8.72 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "binary_search_iterative(list(range(1_000_000)), 999_000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "metadata": {
        "id": "ZQTOPG6toMB7",
        "outputId": "3bbb6751-44a1-4bbd-b13d-125363c7cc1f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "input_arr = [(list(range(i)), 9000) for i in range(100_000, 1_000_000, 50_000)]\n",
        "\n",
        "fun1 = automatic_time(input_arr, binary_search_iterative)\n",
        "plt.plot([len(el[0]) for el in input_arr], fun1)\n",
        "# fun2 = automatic_time(input_arr, binary_search) # the recursive one\n",
        "# plt.plot([len(el[0]) for el in input_arr], fun2)\n",
        "plt.xlabel(\"input size\")\n",
        "plt.ylabel(\"running time in seconds\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kapByez0oMB9"
      },
      "outputs": [],
      "source": [
        "# so binary search is in log n time we would need a trulyl large data sets to see difference\n",
        "# most of our time is spent linearly setting up our data sets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "23MmvHGRoMB-"
      },
      "outputs": [],
      "source": [
        "arr = list(range(1_000_000))\n",
        "big_arr = list(range(100_000_000))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SROdY9YuoMB_",
        "outputId": "0aa8fe45-11ee-4078-8843-79333dbffd91"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "9.56 µs ± 246 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "binary_search(arr, 9000, 0, len(arr)-1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xJ_B-g-NoMCA",
        "outputId": "f5f5d187-bdd8-4957-b0f4-e48fa4809c64"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "7.23 µs ± 120 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "binary_search_iterative(arr, 9000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XVtKP3_joMCB",
        "outputId": "6dc76454-5c83-4282-d7d1-7067249f1bc5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "17.3 µs ± 483 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "binary_search(big_arr, 9000, 0, len(big_arr)-1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fNTrbbbMoMCC",
        "outputId": "0b232d03-b22d-4649-b180-3ac0cef855b4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "16 µs ± 150 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "binary_search(big_arr, 50_000_000, 0, len(big_arr)-1) # so this should hit with 1 comparison"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Euhmq00WoMCD",
        "outputId": "e887c500-f93b-4608-872e-f114ee174d72"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "13.2 µs ± 513 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "binary_search_iterative(big_arr, 9000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xgnrq4tyoMCE",
        "outputId": "c75ca94f-303b-40d3-a147-e4124b3d0ff6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "12.6 µs ± 468 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "%%timeit\n",
        "binary_search_iterative(big_arr, 50_000_000) # so this should hit with 1 comparison"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zRN7kWfboMCE"
      },
      "outputs": [],
      "source": [
        "# so creating a recursive algorithm yourself\n",
        "# check if problem is already solved\n",
        "# otherwise reduce problem to simpler instance of the same problem\n",
        "# in other words Simplify and Delegate the problem"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Lyki5tzooMCF"
      },
      "outputs": [],
      "source": [
        "# all recursive algorithms can be transformed to regular loop based algorithms\n",
        "# worst case you build your stack for holding the function calls"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MS3HYAQ4oMCF"
      },
      "source": [
        "## Length of an array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FgipMFGAoMCF"
      },
      "outputs": [],
      "source": [
        "# in case we forgout about len() function ..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a4TBN_SBoMCF"
      },
      "outputs": [],
      "source": [
        "def array_len(x):\n",
        "    if x == []:\n",
        "        return 0\n",
        "    else:\n",
        "        return 1 + array_len(x[1:])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M0hjnmixoMCF",
        "outputId": "64b91794-c5a5-4b95-bc6a-fdf2202e0eb6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "array_len([])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wc4EGO1eoMCG",
        "outputId": "86614296-6a00-4822-da1e-e638a6b6db48"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "array_len([1, 2, 3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EOUxZ623oMCG",
        "outputId": "bfceddd8-5ae8-41e7-d1aa-9a809e8c15e2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2961"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "array_len(list(range(2961))) # so it looks like 3000 limit is actually 2961 (presumably stack needs space for other functions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HVJDqM8UoMCG"
      },
      "source": [
        "## Sum of the elements in an array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "metadata": {
        "id": "YfhSXvZroMCH",
        "outputId": "1515411c-2732-4f81-a161-154a93176318",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "23"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ],
      "source": [
        "# in case we forgot about sum() function ...\n",
        "sum([2,6,10,5])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "metadata": {
        "id": "X0jLxm_4oMCH"
      },
      "outputs": [],
      "source": [
        "def array_sum(x):\n",
        "    if x == []:\n",
        "        return 0 # our base\n",
        "    else:\n",
        "        return x[0] + array_sum(x[1:]) # so we sum the first element and then recursively call on slice form 2nd element and on"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "metadata": {
        "id": "0bWSXXi3oMCH",
        "outputId": "90d0f743-3bce-4410-efe2-7a8b774d2793",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ],
      "source": [
        "array_sum([])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {
        "id": "QnYf9VZ7oMCH",
        "outputId": "2571d0ea-44fa-4d9e-f4f8-fcaa77da2fd6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 91
        }
      ],
      "source": [
        "array_sum([5])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {
        "id": "Q-4aFrqxoMCH",
        "outputId": "14db2283-5206-4d4b-c44d-7b2fd275239c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ],
      "source": [
        "array_sum([1, 2, 3, 4, 5])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {
        "id": "cSw4pff6oMCH",
        "outputId": "ef538922-ff99-468e-ee62-28c5a9d30b62",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5050"
            ]
          },
          "metadata": {},
          "execution_count": 93
        }
      ],
      "source": [
        "array_sum(list(range(101))) # remember the formula for summing arithmethic series n(n-1)/2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NcquZpg2oMCI",
        "outputId": "44b92fe1-c428-4911-adb4-f3d95bdc9ae6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4382280"
            ]
          },
          "execution_count": 37,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "array_sum(list(range(2961)))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "first_1k = list(range(1,1001))\n",
        "first_5k = list(range(1,5001))"
      ],
      "metadata": {
        "id": "k7h3n1nyqsJ_"
      },
      "execution_count": 94,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "array_sum(first_1k)"
      ],
      "metadata": {
        "id": "LU9dy-xNq2Pn",
        "outputId": "2940e908-eaf0-4643-d717-3ec5d16bae08",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.54 ms ± 418 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "array_sum(first_5k)"
      ],
      "metadata": {
        "id": "eBMKj0Lqq7Tw",
        "outputId": "62544bb9-ff02-4d53-f393-a56da09a7ec5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "57.6 ms ± 4.36 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def array_sum_tail_first(my_list):\n",
        "    if my_list == []:\n",
        "        return 0 # our base\n",
        "    else:\n",
        "        return my_list[-1] + array_sum_tail_first(my_list[:-1]) # so we cut our values from tail first"
      ],
      "metadata": {
        "id": "qGIRDVgLrFMJ"
      },
      "execution_count": 97,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "array_sum_tail_first(first_1k)"
      ],
      "metadata": {
        "id": "5smUr2nXrhRs",
        "outputId": "1d69f1aa-1f88-47e8-8e49-611f2e133380",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.96 ms ± 323 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%timeit\n",
        "array_sum_tail_first(first_5k)"
      ],
      "metadata": {
        "id": "aKRMk1x2rpT-",
        "outputId": "f14b4c51-99b8-47c2-bb16-700b1fb27ba6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "66.9 ms ± 9.87 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# so in this particular case whether we start cutting our array/list from beginning or end did no make a significant difference\n",
        "# there are many cases where it does make a difference"
      ],
      "metadata": {
        "id": "nCZYqBnIr1SI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f3mABKIcoMCI"
      },
      "source": [
        "# Tower of Hanoi\n",
        "![tower](https://upload.wikimedia.org/wikipedia/commons/thumb/0/07/Tower_of_Hanoi.jpeg/600px-Tower_of_Hanoi.jpeg)\n",
        "\n",
        "* must not move more than one disc at a time \n",
        "* must place this disc on a needle so that there is no smaller disc below it"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def recursive_hanoi(n, src, dst, tmp):\n",
        "    '''\n",
        "    n - how many disks to move\n",
        "    src - source peg\n",
        "    dst - destination peg\n",
        "    tmp - temporary (middle peg in the picture above to be used for transfers)\n",
        "    '''\n",
        "    # base\n",
        "    if n == 0:\n",
        "        print(\"We are done\")\n",
        "        return\n",
        "    else:\n",
        "    # reduce\n",
        "        recursive_hanoi(n-1, src, tmp,dst) # we move the smaller dist to tmp peg\n",
        "        # TODO code to move the biggest peg to destination\n",
        "        recursive_hanoi(n-1, tmp, dst,src) # move the smallest disks to destination peg"
      ],
      "metadata": {
        "id": "9PMjyJptsVXj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kEHulOQeoMCI"
      },
      "source": [
        "## Quicksort - more about sorting later on"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fSRJZYWLoMCI"
      },
      "outputs": [],
      "source": [
        "def quicksort(array):\n",
        "    if len(array) < 2:\n",
        "        return array\n",
        "    else:\n",
        "        pivot = array[0]\n",
        "        smaller, bigger = [], []\n",
        "        for ele in array[1:]:\n",
        "            if ele <= pivot:\n",
        "                smaller.append(ele)\n",
        "            else:\n",
        "                bigger.append(ele)\n",
        "        return quicksort(smaller) + [pivot] + quicksort(bigger)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mx2Jei5toMCI"
      },
      "outputs": [],
      "source": [
        "quicksort([])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ycaZzYItoMCI"
      },
      "outputs": [],
      "source": [
        "quicksort([5])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "N4tgy3n1oMCI"
      },
      "outputs": [],
      "source": [
        "quicksort([5, 4])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n0gjcNvZoMCI"
      },
      "outputs": [],
      "source": [
        "quicksort([1, 2, 7, 5, 4])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5LdWJPRKoMCJ"
      },
      "outputs": [],
      "source": [
        "quicksort([5, 4, 3, 2])"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.3"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}