notebooks/02_Speeding_Python.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:24dd03bc62c4a2a35c252a823ae147398dfe499a679947b871e2844785fbcc6d"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<style>\n",
      "    h1{\n",
      "        text-align:center;\n",
      "    }\n",
      "    h2{\n",
      "        text-align:center;\n",
      "        font-variant:small-caps;\n",
      "    }\n",
      "</style>\n",
      "# Speeding Python\n",
      "# Python in HPC Tutorial\n",
      "\n",
      "## Supercomputing 2014\n",
      "\n",
      "Matt Knepley and Aron Ahmadia\n",
      "\n",
      "[![Creative Commons License](../figures/creative_commons_logo.png)](http://creativecommons.org/licenses/by/3.0/deed.en_US)  "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "\n",
      "## About This Tutorial\n",
      "\n",
      "### PyHPC Tutorial on GitHub\n",
      "\n",
      "These presentation materials are part of a continuously updated tutorial on Python for High Performance Computing.  Future versions of this presentation will be found at:\n",
      "\n",
      "https://github.com/pyhpc/pyhpc-tutorial\n",
      "\n",
      "Please set all permanent bookmarks to this URL.\n",
      "\n",
      "### \n",
      "Checkout from git\n",
      "\n",
      "```\n",
      "git clone https://github.com/pyhpc/pyhpc-tutorial.git\n",
      "git checkout sahpc2012\n",
      "```\n",
      "\n",
      "### Viewing the read-only version of this presentation on nbviewer: \n",
      "\n",
      "* http://nbviewer.ipython.org/urls/raw.github.com/pyhpc/pyhpc-tutorial/master/notebooks/02_Speeding_Python.ipynb"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "--- \n",
      "\n",
      "## Using the Texas Advanced Computing Center IPython Notebooks\n",
      "\n",
      "You will need a modern web browser to interact with the TACC nodes, there are no other requirements.\n",
      "\n",
      "### TACC IPython Notebooks\n",
      "* http://pyhpc01.tacc.utexas.edu/\n",
      "* http://pyhpc02.tacc.utexas.edu/\n",
      "* http://pyhpc03.tacc.utexas.edu/\n",
      "* http://pyhpc04.tacc.utexas.edu/\n",
      "* http://pyhpc05.tacc.utexas.edu/\n",
      "* http://pyhpc06.tacc.utexas.edu/\n",
      "* http://pyhpc07.tacc.utexas.edu/\n",
      "* http://pyhpc08.tacc.utexas.edu/\n",
      "* http://pyhpc09.tacc.utexas.edu/\n",
      "* http://pyhpc10.tacc.utexas.edu/\n",
      "\n",
      "The TACC nodes will not be available after this workshop, please contact the presenters for more permanent hosting solutions."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "\n",
      "## Interacting with the Tutorial Slides\n",
      "\n",
      "This tutorial is an interactive worksheet designed to encourage you to try out the lessons during the demonstration.  If you are looking at the PDF version of these slides, we encourage you to download the updated version (see previous slide) and try the interactive version.\n",
      "\n",
      "To run the interactive version of this notebook, you will need a Python 2.7 environment including: \n",
      "\n",
      "* IPython version >= 13.0\n",
      "* numpy version >= 1.6\n",
      "* scipy >= 0.10\n",
      "* matplotlib >= 1.0.0\n",
      "\n",
      "Move to the directory containing the tarball and execute:\n",
      "\n",
      "    $ ipython notebook --pylab=inline\n",
      "\n",
      "If you are installing the packages yourself, Continuum Analytics provides both free community as well as professional versions of the Anaconda installer, which provides all the packages you will need for this portion of the tutorial. The installer is available from the [Anaconda download page at Continuum Analytics](https://store.continuum.io/cshop/anaconda).\n",
      "\n",
      "You are also welcome to use Enthought's Python Distribution (free for Academic users), available from the [EPD download page at Enthought](http://www.enthought.com/products/epd.php).\n",
      "\n",
      "Unfortunately, you will need to upgrade your EPD's IPython to 0.13 if you go this route, and this may be non-trivial, please see the [Enthought discussion thread here](https://mail.enthought.com/pipermail/epd-users/2012-August/000800.html)."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Presentation mode\n",
      "The slideshow mode is only supported by an IPython development branch version. If you would like to write your own slideshows (the notebooks will work regardless of slideshow capabilities), you will need to install Matthias Bussonnier's slideshow_metadata branch.  Here are some sample command-line instructions.\n",
      "\n",
      "    #!/bin/bash\n",
      "    git clone carreau git://github.com/Carreau/ipython.git # Matthias' IPython fork\n",
      "    git checkout origin/slideshow_metadata                 # Select the right branch\n",
      "    python setup.py develop                                # Install the development version\n",
      "    ipython notebook                                       # Check out the slideshows!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Slideshow Setup Code"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# The below command starts pylab inline mode, which simplifies syntax for many common \n",
      "# scientific computing commands.  All commands starting with % are IPython extensions.\n",
      "%pylab inline\n",
      "\n",
      "import numpy as np\n",
      "import scipy as sp\n",
      "\n",
      "# The following two lines of code load the slideshow extension and start it,\n",
      "# you only need to run these if you are writing or running your own slideshow\n",
      "\n",
      "#%load_ext slidemode\n",
      "#%slideshow_mode"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Populating the interactive namespace from numpy and matplotlib\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## How Slow is Python\n",
      "<!--====-->\n",
      "\n",
      "Let's add one to a million number"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lst = range(1000000) # A pure Python list\n",
      "%timeit [i + 1 for i in lst] # A Python list comprehension (iteration happens in C but with PyObjects)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 194 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "##Why is Python Slow?\n",
      "<!--====-->\n",
      "\n",
      "Dynamic typing requires lots of metadata around variable. \n",
      "\n",
      "* Python uses heavy frame objects during iteration\n",
      "\n",
      "### Solution:\n",
      "* Make an object that has a single type and continuous storage.\n",
      "* Implement common functionality into that object to iterate in C."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr = np.arange(1000000) # A NumPy list of integers\n",
      "%timeit arr + 1 # Use operator overloading for nice syntax, now iteration is in C with ints"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100 loops, best of 3: 7.45 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## What makes NumPy so much faster?\n",
      "<!--====-->\n",
      "\n",
      "* Data layout\n",
      "  * homogenous: every item takes up the same size block of memory\n",
      "  * single data-type objects\n",
      "  * powerful array scalar types\n",
      "\n",
      "* universal function (ufuncs)\n",
      "  * function that operates on ndarrays in an element-by-element fashion\n",
      "  * vectorized wrapper for a function\n",
      "  * built-in functions are implemented in compiled C code"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Numpy Data layout\n",
      "<!--====-->\n",
      "\n",
      "* homogenous: every item takes up the same size block of memory\n",
      "* single data-type objects\n",
      "* powerful array scalar types\n",
      "\n",
      "![three fundamental](../figures/numpy/threefundamental.png)\n",
      "\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Numpy Universal Functions (ufuncs)\n",
      "<!--====-->\n",
      "\n",
      "* function that operates on ndarrays in an element-by-element fashion\n",
      "* vectorized wrapper for a function\n",
      "* built-in functions are implemented in compiled C code"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit [sin(i)**2 for i in arr]\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 9.08 s per loop\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit np.sin(arr)**2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 loops, best of 3: 58.6 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Other Numpy Features to be aware of\n",
      "<!--====-->\n",
      "\n",
      "* Reshaping"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr2 = arr.reshape((10,100000))\n",
      "print(arr2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[     0      1      2 ...,  99997  99998  99999]\n",
        " [100000 100001 100002 ..., 199997 199998 199999]\n",
        " [200000 200001 200002 ..., 299997 299998 299999]\n",
        " ..., \n",
        " [700000 700001 700002 ..., 799997 799998 799999]\n",
        " [800000 800001 800002 ..., 899997 899998 899999]\n",
        " [900000 900001 900002 ..., 999997 999998 999999]]\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Memory Views"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr2.view?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Index Slicing"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = np.arange(0, 20, 2); y = x**2\n",
      "((y[1:] - y[:-1]) / (x[1:] - x[:-1])) # dy/dx"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "array([ 2,  6, 10, 14, 18, 22, 26, 30, 34])"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Fancy Indexing"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "evens = arr[arr%2 == 0]\n",
      "print(evens)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[     0      2      4 ..., 999994 999996 999998]\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Compiling to C\n",
      "<!--====-->\n",
      "\n",
      "C is faster, and Python is easier to write.  We want both!\n",
      "\n",
      "## Cython\n",
      "* a programming language based on Python\n",
      "* uses extra syntax allowing for optional static type declarations\n",
      "* source code gets translated into optimized C/C++ code and compiled as Python extension modules\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Using Cython in IPython\n",
      "<!--====-->\n",
      "\n",
      "In IPython we can make any cell call out to Cython via the cell magic. The user must first install Cython\n",
      "```\n",
      "$ pip install cython\n",
      "```\n",
      "Then load the extension"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%load_ext cythonmagic"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now use `%%cython` at the begining of a code cell to call out to Cython."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "def f_cython(int i):\n",
      "    return i**4 + 3*i**2 + 10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now use Cython function in code:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "f_cython(100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 9,
       "text": [
        "100030010"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "\n",
      "## How much faster is Cython?\n",
      "<!--====-->\n",
      "\n",
      "The more you are able to provide type information the better the compile. For example f without type information:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "def f_slow(i):\n",
      "    return i**4 + 3*i**2 + 10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit f_slow(100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 356 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit f_cython(100)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000000 loops, best of 3: 121 ns per loop\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Declaring Cython variables for C level\n",
      "<!--====-->\n",
      "\n",
      "If you use a variable or function only at the Cython level you can keep it in C via `cdef`:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "cdef f(double x):\n",
      "    return x**2-x\n",
      "\n",
      "def integrate_f(double a, double b, int N):\n",
      "    cdef int i\n",
      "    cdef double s, dx\n",
      "    s = 0\n",
      "    dx = (b-a)/N\n",
      "    for i in range(N):\n",
      "        s += f(a+i*dx)\n",
      "    return s * dx"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit integrate_f(1.0, 2.0, 1000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10000 loops, best of 3: 57.1 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The pure Python version:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(x):\n",
      "    return x**2-x\n",
      "\n",
      "def integrate_f(a, b, N):\n",
      "    s = 0\n",
      "    dx = (b-a)/N\n",
      "    for i in range(N):\n",
      "        s += f(a+i*dx)\n",
      "    return s * dx"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit integrate_f(1.0, 2.0, 1000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 604 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "## Using NumPy with Cython\n",
      "<!--====-->\n",
      "\n",
      "You can also use fast accessors to NumPy arrays from Cython:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%cython\n",
      "import numpy as np\n",
      "# \"cimport\" is used to import special compile-time information\n",
      "# about the numpy module (this is stored in a file numpy.pxd which is\n",
      "# currently part of the Cython distribution).\n",
      "cimport numpy as np\n",
      "# We now need to fix a datatype for our arrays. I've used the variable\n",
      "# DTYPE for this, which is assigned to the usual NumPy runtime\n",
      "# type info object.\n",
      "DTYPE = np.int\n",
      "# \"ctypedef\" assigns a corresponding compile-time type to DTYPE_t. For\n",
      "# every type in the numpy module there's a corresponding compile-time\n",
      "# type with a _t-suffix.\n",
      "ctypedef np.int_t DTYPE_t\n",
      "# \"def\" can type its arguments but not have a return type. The type of the\n",
      "# arguments for a \"def\" function is checked at run-time when entering the\n",
      "# function.\n",
      "#\n",
      "# The arrays f, g and h is typed as \"np.ndarray\" instances. The only effect\n",
      "# this has is to a) insert checks that the function arguments really are\n",
      "# NumPy arrays, and b) make some attribute access like f.shape[0] much\n",
      "# more efficient. (In this example this doesn't matter though.)\n",
      "def naive_convolve(np.ndarray f, np.ndarray g):\n",
      "    if g.shape[0] % 2 != 1 or g.shape[1] % 2 != 1:\n",
      "        raise ValueError(\"Only odd dimensions on filter supported\")\n",
      "    assert f.dtype == DTYPE and g.dtype == DTYPE\n",
      "    # The \"cdef\" keyword is also used within functions to type variables. It\n",
      "    # can only be used at the top indendation level (there are non-trivial\n",
      "    # problems with allowing them in other places, though we'd love to see\n",
      "    # good and thought out proposals for it).\n",
      "    #\n",
      "    # For the indices, the \"int\" type is used. This corresponds to a C int,\n",
      "    # other C types (like \"unsigned int\") could have been used instead.\n",
      "    # Purists could use \"Py_ssize_t\" which is the proper Python type for\n",
      "    # array indices.\n",
      "    cdef int vmax = f.shape[0]\n",
      "    cdef int wmax = f.shape[1]\n",
      "    cdef int smax = g.shape[0]\n",
      "    cdef int tmax = g.shape[1]\n",
      "    cdef int smid = smax // 2\n",
      "    cdef int tmid = tmax // 2\n",
      "    cdef int xmax = vmax + 2*smid\n",
      "    cdef int ymax = wmax + 2*tmid\n",
      "    cdef np.ndarray h = np.zeros([xmax, ymax], dtype=DTYPE)\n",
      "    cdef int x, y, s, t, v, w\n",
      "    # It is very important to type ALL your variables. You do not get any\n",
      "    # warnings if not, only much slower code (they are implicitly typed as\n",
      "    # Python objects).\n",
      "    cdef int s_from, s_to, t_from, t_to\n",
      "    # For the value variable, we want to use the same data type as is\n",
      "    # stored in the array, so we use \"DTYPE_t\" as defined above.\n",
      "    # NB! An important side-effect of this is that if \"value\" overflows its\n",
      "    # datatype size, it will simply wrap around like in C, rather than raise\n",
      "    # an error like in Python.\n",
      "    cdef DTYPE_t value\n",
      "    for x in range(xmax):\n",
      "        for y in range(ymax):\n",
      "            s_from = max(smid - x, -smid)\n",
      "            s_to = min((xmax - x) - smid, smid + 1)\n",
      "            t_from = max(tmid - y, -tmid)\n",
      "            t_to = min((ymax - y) - tmid, tmid + 1)\n",
      "            value = 0\n",
      "            for s in range(s_from, s_to):\n",
      "                for t in range(t_from, t_to):\n",
      "                    v = x - smid + s\n",
      "                    w = y - tmid + t\n",
      "                    value += g[smid - s, tmid - t] * f[v, w]\n",
      "            h[x, y] = value\n",
      "    return h"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "N=100\n",
      "f = np.arange(N*N, dtype=np.int).reshape((N,N))\n",
      "g = np.arange(81, dtype=np.int).reshape((9, 9))\n",
      "%timeit -n2 -r3 naive_convolve(f, g)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2 loops, best of 3: 2.86 s per loop\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "# Numba -- A Python Compiler for Numpy arrays\n",
      "<!--===-->\n",
      "\n",
      "The user must install the Numba packages. If you're not using anaconda, you will need LLVM with RTTI enabled (\n",
      "See https://github.com/llvmpy/llvmpy for the most up-to-date instructions)\n",
      "\n",
      "First compile LLVM 3.3\n",
      "```\n",
      "$ wget http://llvm.org/releases/3.3/llvm-3.3.src.tar.gz\n",
      "$ tar zxvf llvm-3.3.src.tar.gz\n",
      "$ cd llvm-3.3.src\n",
      "$ ./configure --enable-optimized --prefix=LLVM_BUILD_DIR\n",
      "$ # It is recommended to separate the custom build from the default system\n",
      "$ # package.\n",
      "$ # Be sure your compiler architecture is same as version of Python you will use\n",
      "$ #  e.g. -arch i386 or -arch x86_64.  It might be best to be explicit about this.\n",
      "$ REQUIRES_RTTI=1 make install\n",
      "```\n",
      "\n",
      "Then install llvmpy and numba\n",
      "\n",
      "```\n",
      "$ LLVM_CONFIG_PATH=LLVM_BUILD_DIR/bin/llvm-config pip install llvmpy numba\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "from numba import autojit, jit, double"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Numba provides two major decorators:  `jit` and `autojit`.  \n",
      "\n",
      "The `jit` decorator returns a compiled version of the function using the input types and the output types of the function.   You can specify the type using `out_type(in_type, ...)` syntax.  Array inputs can be specified using `[:,:]` appended to the type.  \n",
      "\n",
      "The `autojit` decorator does not require you to specify any types.  It watches for what types you call the function with and infers the type of the return.  If there is a previously compiled version of the code available it uses it, if not it generates machine code for the function and then executes that code. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def sum(arr):\n",
      "    M, N = arr.shape\n",
      "    sum = 0.0\n",
      "    for i in range(M):\n",
      "        for j in range(N):\n",
      "            sum += arr[i,j]\n",
      "    return sum\n",
      "fastsum = jit('f8(f8[:,:])')(sum)\n",
      "flexsum = autojit(sum)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr2d = np.arange(600,dtype=float).reshape(20,30)\n",
      "print sum(arr2d)\n",
      "print fastsum(arr2d)\n",
      "print flexsum(arr2d)\n",
      "print flexsum(arr2d.astype(int))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "179700.0\n",
        "179700.0\n",
        "179700.0"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "179700.0"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit sum(arr2d)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000 loops, best of 3: 623 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit fastsum(arr2d)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1000000 loops, best of 3: 1.75 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "623 / 1.75 # speedup"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 6,
       "text": [
        "356.0"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit arr2d.sum() "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 5.14 \u00b5s per loop\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5.14 / 1.75 # even provides a speedup over general-purpose NumPy surm"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "2.937142857142857"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The speed-up is even more pronounced the more inner loops in the code.   Here is an image processing example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@jit('void(f8[:,:],f8[:,:],f8[:,:])')\n",
      "def filter(image, filt, output):\n",
      "    M, N = image.shape\n",
      "    m, n = filt.shape\n",
      "    for i in range(m//2, M-m//2):\n",
      "        for j in range(n//2, N-n//2):\n",
      "            result = 0.0\n",
      "            for k in range(m):\n",
      "                for l in range(n):\n",
      "                    result += image[i+k-m//2,j+l-n//2]*filt[k, l]\n",
      "            output[i,j] = result\n",
      "\n",
      "from scipy.misc import lena\n",
      "import time\n",
      "image = lena().astype('double')\n",
      "filt = np.ones((15,15),dtype='double')\n",
      "filt /= filt.sum()\n",
      "output = image.copy()\n",
      "filter(image, filt, output)\n",
      "gray()\n",
      "imshow(output)\n",
      "start = time.time()\n",
      "filter(image[:100,:100], filt, output[:100,:100])\n",
      "fast = time.time() - start\n",
      "start = time.time()\n",
      "filter.py_func(image[:100,:100], filt, output[:100,:100])\n",
      "slow = time.time() - start\n",
      "print \"Python: %f s; Numba: %f ms; Speed up is %f\" % (slow, fast*1000, slow / fast)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Python: 4.389855 s; Numba: 7.434130 ms; Speed up is 590.500176\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAQcAAAD9CAYAAACx1bJsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
       "text": [
        "<matplotlib.figure.Figure at 0x107875050>"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can call Numba-created functions from other Numba-created functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@autojit\n",
      "def mandel(x, y, max_iters):\n",
      "    \"\"\"\n",
      "    Given the real and imaginary parts of a complex number,\n",
      "    determine if it is a candidate for membership in the Mandelbrot\n",
      "    set given a fixed number of iterations.\n",
      "    \"\"\"\n",
      "    i = 0\n",
      "    c = complex(x, y)\n",
      "    z = 0.0j\n",
      "    for i in range(max_iters):\n",
      "        z = z**2 + c\n",
      "        if abs(z)**2 >= 4:\n",
      "            return i\n",
      "\n",
      "    return 255\n",
      "\n",
      "@autojit\n",
      "def create_fractal(min_x, max_x, min_y, max_y, image, iters):\n",
      "    height = image.shape[0]\n",
      "    width = image.shape[1]\n",
      "\n",
      "    pixel_size_x = (max_x - min_x) / width\n",
      "    pixel_size_y = (max_y - min_y) / height\n",
      "    for x in range(width):\n",
      "        real = min_x + x * pixel_size_x\n",
      "        for y in range(height):\n",
      "            imag = min_y + y * pixel_size_y\n",
      "            color = mandel(real, imag, iters)\n",
      "            image[y, x] = color\n",
      "\n",
      "    return image\n",
      "\n",
      "image = np.zeros((500, 750), dtype=np.uint8)\n",
      "imshow(create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 28,
       "text": [
        "<matplotlib.image.AxesImage at 0x10790a8d0>"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAXMAAAD9CAYAAABOd5eOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsnXl41NT6x79JZmihpdu0dIcie1EWZbkCglhAuVwWF8om\nFJBFFgV/VoGLV7xelYKyiAhSQcCFVWVRlEUBFVFQFBDKVrF0L9BpS9k67WR+f5TEzEwyk2QyM5lp\nPs/Tp5Pk5JyTM5lv3rznPecQFosFGhoaGhq+DentCmhoaGhouI4m5hoaGhp+gCbmGhoaGn6AJuYa\nGhoafoAm5hoaGhp+gCbmGhoaGn6AW8R89+7dj7Ru3fpsixYtLixYsGCWO8rQ0NDQ0PgbQuk4c7PZ\nTLVq1ercN9980yc+Pr6gc+fOv2zcuHFEmzZtzihakIaGhoYGi+KW+dGjR7s0b948OykpKUev11cP\nHz58044dOwYrXY6GhoaGxt8oLuYFBQXxiYmJecx2QkJCfkFBQbzS5WhoaGho/I1O6QwJgnDqtxGT\nRkNDQ0PDHovFQvDtV1zM4+PjC/Ly8hKZ7by8vMSEhIR8pcuRCkHwXr9oLBaL0zxcLUNpxNRZTUip\nr1qui6ZpUBQl61zbaxDa5u4nSRI6nQ4URWH48OH45JNPYDabrc4hSRJ6vR4mkwk6nQ7V1dWwWCww\nm82wWCyoqakBSVq/lNv2nXliziaxZci9j70575S7fnuOrklxN0unTp1+vXDhQoucnJwkk8lUb/Pm\nzcMGDRq0U+ly1IZaxMXfIQhCVW0tty5SzuP+gBlRrq6uxoYNG1BRUQGKokAQBHQ6HSorK7Fnzx5U\nVVWBpmmYTCaYzWZWyMUKnCfa2N1lqOk+8QSKW+Y6na5m+fLl0x9++OE9ZrOZeuqpp9Z4O5JFu2n8\nA7W1M0EQill/zqx0LkyZNE3jgQcewLvvvosbN25g8uTJCAsLQ0xMDGiaZtMxIu6ornzXouT1SSlX\n6fwB71rpnkLx0ERRhXrQZ66UAAi9NqlNYLj4i5tFjdfAFQk59eOeI+aauS4X5jNJkqzbhaZp1vq2\nFXLmP/chwFemkBZ42+Wi1H3sSa1zp5tFyGeujQAVia+IDBe118+WutLGSrtmSktL2c98gmW7jyRJ\nSXXwtstFqfI9eS954771azF3V4OqzW/rr6i1jV2plxh3ipj8mY7O2NhYq33usj69Lei+VIa38Gsx\ndwf+fDOoCbW2s5L1khK5Y+tmIQgCzz//PM6ePQsAKC4udtnI8LVoLbn4y3XY4rdi7o4vzF9vAjWh\n5rceV+vlzE/Ot58r3hRFsS4SgiCwePFifPjhhwCAsWPHomPHjrzhjI7yduUa3IGnvnu13mOuoHg0\ni7/ij1++2lBzGysp5GLS8FniEyZMwOXLl/Hll18CACiKQr169QAAe/bsYePNSZJkO+C4MehMflxX\njBzXjCciUDzRWempcjyFX1rmSouCmkXGX1BzGyst5I6sbz6XypEjR9CuXTv8/PPP+OSTT0BRFFq0\naIHS0lIMHz4cAGA0GtG4cWOQJIm2bdvi2LFjVnmIvR4prh93olno0vFLMVcSf/qy1Yqa29idQs4I\nLUmSdqNIuem6deuGGzduIDY2Frm5uTAajfj111/tyurbty8oisKGDRvQpUsXSfWSg7tdYpqgS8Pv\n4sy90UGlIQ+1t6+7hJy7nyRJTJw4EWvXrmXjxG3TM35ykiTRq1cv7Nixw2G5S5YsQVxcHM6fP4+M\njAyrGHOhYfu2o0yl4i4d8XRsuNpxFGeuibmb89HgR+3t6w4fua0ly2wHBQVhxYoVmDBhAq+gcztA\n8/PzERQU5LDs2NhY3Lx5EzRN8w4gss27pqZGkblZNEF3P3Vm0JAm5L6B2tvX3UJu6x+/ffs29u3b\nhwkTJvD6z5m5V8aOHetUyAHg3nvvZUXJUbmBgYF2fnpXr9vXo8jUfm86wq/EXAl8+cv0BdTevq7U\nT0jMuGKq0+nYWQ8vXLgAvV4Pna42qCwtLc3Kjz5v3jzMnTsX5eXloCgKhw4dElWPq1ev2l0LN9/0\n9HRQFAWapq1mT+SLppGDJujewW/EXCnLQsN9qLl9XbEqHZ3LFfLJkydjypQpoCgKPXv2xKFDh3Dp\n0iXMnTsXmZmZmD59OjvfCkEQeOONN5CamgoAWL16NX755RendTly5Aiqq6uh0+nwv//9zyo/RsxH\njhyJ/Px81K9f38qCVxJ3d466G1+su9/4zN3xaqyhHGpuX1dEXOxxRkgJgkC3bt0wdepUPP/88ygt\nLUWTJk1w8uRJjBs3Djt27MDOnTtx+vRpnDt3DosXL5ZVt99++w2tWrXCqlWr8Morr7Bx5y+//DLS\n09MREhLC+tRpmgagXGcoH2rLR63lOcPvO0A1IVcvam9bTwg5s8386fV6mM1mdlun08FoNMqqhzMi\nIiJAEASqq6tZvztJkjhy5Aj++OMPq3nOhURcbUJclwW9znSAaqgLfxRyOe4DbnqLxcKu/MNEmnTv\n3l1yPcSyZs0alJaWonfv3qx/fMmSJZgxYwYuXrwIiqLQpEkT0fV3BbXfD0L4Sr193jLXrHJ1ovZ2\ndUWQpabl64jkfi4sLERISIik+rjCrl27MHLkSMydOxcLFixA+/btcfjwYafhiUpqhat5eUO31GCh\n+7WbRW297hrqbldXRFnuOXxRIly3C0mSGD58ODIzMyWXJ4fk5GTk5eVZLVbBjUdnEDM3uitogi6v\nfL90s2hCrj7U3K5i6yY3EkOOtc+cs337dnz00UeSy5RD//79WR85n4hz6ydmn1xcjXhR873mDXxa\nzOWi3QTKo+ZQNLF1czU8Ucp+AGjSpAmSk5NBkiSqq6vRsGFDWWVLYcGCBXj//fd5BVyseLsjjNFX\nUHNd65yYq/nL8FXU3KbuFnGxZfCV9+CDD2L//v3466+/QFEUhgwZIrsOYpg0aRLmz5/P1sEVlH54\ne+ptSAnUer/7rJirtUHrGmr9HsSIgxIi7uh8Z8eCgoIQFBSE8PBwdtSmO3nhhRdAkiR69uyJVq1a\nsSNPneHsOpQWdV9AjfX0WTGXgxq/AF9Gje3pCRFn8nDlnKlTp+KVV15Bhw4dXKqHFJo2bYrs7Gx8\n+eWXoGmaXT+Ub6ZGWzzRpmLLcjW9Uqjt/vfZaBZf+cL9FTW2p9SBPO4qRygNN5KFJEnodDpYLBZU\nVFQoUi8plJSU4K677uIdMAQIR21I0QtPRqt4K8rEGwOY/CqaRRNy76K29hRrjXuiHKGyuEIO1P4o\nmalnw8LCMHnyZJfrJ5bw8HCnk3bJtdBt09r+SUHKOZp17qOWubtjhTX4UVtbyhVWJfN3do7QNlfg\nMjMzMWLECNn1FMuVK1fQsmVLmM1mp3OyMChhoYvBWX5iyvNmDLinyvYry1xtglJXUFO7y7WQ+SxF\nR39y6iVlmxGAjh07Si5LDlFRUZg1a5ZV2VyE3ig8FZ7oqN3d/eB2FTX8PnzOMtescs+jlnaU88ot\nRwTkrFbvaFsoDfPXtGlTdOrUCZmZmaIjTOQSExOD69ev21njYibWcveIUDFlqtlC90S5fjOcXxNy\nz6OGdpT7vYux8hhB1el07ARY7qgnX724gk6SJE6fPo34+HjZ5TsjPDwcNE1bLU2nlItFiXZj2gEA\nbx3FluPP7ha/crNoeAal44c9UQduWu4iyHq93mqBBtv0FEVZ/cnp5OPmL8Zlw/c2cPnyZdHlyoE7\ndN+2Q9aRi4X5e+aZZ+wWu+BLKwah9MyDlXvM1TctT+LNsv1SzL0tQr6Ot9tPjojbCnm9evWg0+mg\n1+tx7Ngxu9V2uGLfu3dv5Obmolu3bkhOTnZavq1F/a9//YvdjoyM5BUqW9Fn9nF56KGHYDAYRF+3\nWObPn4+oqCirutj+d/bgIQgCq1atwscffywotLbp5TzcLBYLPvzwQzZ0k7HUpQq6N/FW/XzGzSLH\nX6ohHV+zahz5ooODg5Gfn4/o6GjU1NSApmkQBIF9+/bhn//8J2pqagAA9erVQ3Z2Npo2bcpGeoj5\nXTBWZFlZGQwGAxISEnDs2DF8+eWXSEtLsxuMQxAEu+KP7X7g77cJpReqiIqKYl1I3Jhybv10Oh0b\nKml7jKlbYGAgTp06hTZt2qCqqsrhghZSsH0QM29TZrMZJpOJjbqxLUOJCBh34a6yNTeLhii8ZlHI\ndOk4OsdisSAlJQVRUVFYv349Kioq0KlTJ5AkiQEDBuDee+8FSZJYvHgxjEYjIiIiWHESUx/mOE3T\niIqKQnl5OU6dOoWAgAC8++67iI6OtrLG//3vf6OyshKlpaWsaDdt2pTXWk1KSpLcFkK0a9fOalUj\npj733Xcfu52YmIh7770X165dQ6dOndjrY/46deqEuXPnoqamBjExMZg5cyZ0Oh06d+4s+GASi9Db\ni8ViAUmSDt1eajbcvFE3vxJzNX+5asfTbSfVx8p3vrN9O3fuhNlsxvHjx/Hhhx8iMzMTnTp1AkEQ\n2L9/P6ZNm4ZJkybhySefZMXc1vUgVG/mM0mS2LFjh1Wa/fv3s64CgiDQuHFj1l0QEBCAH374ARRF\n4aOPPkJFRQVGjx6NVatWYcqUKXj66aeRk5Mjq034OHnyJJYtW4YpU6bgwoULoCgKK1euxMGDBzFh\nwgSQJIni4mLs378fJEli3bp1rIAy1xcYGIgnnngC5eXlAIB58+Zh9+7d6Nmzp6DfW6pvmzlHp9Nh\n+fLlqKmpgclkgtlsFjxHSv51AZ9ws6i908PX8VTbKVWOGEvN1hINCAhAo0aNcObMGbvzmCgPvqHt\n3Fd827IyMzMxatQo3uOpqanYu3cvgNqVfbhLw1VUVODSpUto166d84t1My+//DKio6Mxbdo0dt/5\n8+fRqVMnq7eUrl27stcDABs3bsSLL74Io9FoN/hICtzvjKIo6PV6bNy4EcOGDUN1dbWVy0vIBeSo\nXDUsJqF0fj4dmqiJufvwRLspWYbYV25bMScIAhRFIT09HS+99BKbLikpCRUVFexCDQDY1/zDhw+j\na9euggNsSJLEsWPH0KJFC946lZaWokWLFujVqxe2bdsm95I9Ttu2bZGfnw8AOHfuHBo0aMC7rF11\ndTUiIiKswggZHOmK0BtPWFgYwsPDcfr0aTRs2JDtv+DmJydc0Z8E3e/FXBNy6fiaiDvLT0jM77rr\nLuTm5sJgMDh1X7Rt2xaFhYVYv349Bg0aBABo3rw5bt26xboYuGUxnXVPPfUUFi1aJPOq1McHH3yA\n33//HZ988olgZ6zBYECbNm1w4sQJq7caqdi6tZgolmPHjqFt27Z2nZ913Tp3qQN0/PjxH0RHR5fc\nc889fzD7jEZjRN++ffe1bNnyfL9+/faWl5eHMcfmz58/p0WLFhdat259du/evf1crbwm1MrjzjZ1\n1RfuKF8550yYMAERERHIyclBYWEhtmzZgsjISN70p0+fBkmSVmF82dnZ2LVrl11sNbc+/iTkADB+\n/Hi88847DqNqVq5ciZMnTzqcPpdpr/z8fPTs2RMURWHgwIG8cepccnJy0L59e6u3KsafLqcz1Nsa\n4qnynYr5uHHj1u7evfsR7r6MjIzZffv23Xf+/PmWKSkp32ZkZMwGgKysrOTNmzcPy8rKSt69e/cj\nU6dOXUHTtFs7Wb39RfkS7hBZbr7u+i7kvpl17doVN2/exOOPP45bt25hxowZmDRpkqAfHKh1jdx/\n//3s9q5du/Dggw+ywsJEWFAUhaCgIBAEgfT0dHkX5sMwETe2Dzfbe4EkSfTq1QsjRozAvn378N57\n7yE4OBjTpk3jHWg1fvx4hISEsNsjRoxg292RmGuIEPMHHnjgh/Dw8DLuvp07dw5KS0tbDwBpaWnr\nt2/fPgQAduzYMXjEiBEb9Xp9dVJSUk7z5s2zjx492sU9VdeEXAruFHF3ItciB2r9vRkZGfjoo48Q\nGxuLPXv2CM7fLUTPnj3x008/WQlOeno6ysvLUVRUhMOHD9dJMd+2bZudxWz75sJ8zs3Nxbx581Bc\nXIyIiAiUlJQgMzPT6gHJpF+3bh0uX74MgiDw3//+F9u2bcOvv/6KevXqsRFBTP62qFkPPFE3WVZz\nSUlJdHR0dAkAREdHl5SUlEQDQGFhYVxCQkI+ky4hISG/oKBA9mQTav5yfAl3uDx8wedeVlYGs9mM\nmzdvsoOGuLHkYmjYsCHatGmDLl26sOLzn//8hz3epk0bxMTEuFRPX2TTpk0gSRJXrlxBRUUF/ve/\n/zkU9H79+uHRRx8FUOtvDwoKAkmS+Oqrr1BZWYmDBw9apS8vL8fEiRNhNpvRuXNnVFVV4fbt24oM\nTPIWcurANT6cXbvLLhCCICyOOjSldnZKKNcd2foVSoquu10pfOUpge0PgclXyG8uBONe6dfP5W4g\nv+Cvv/5CWVkZAgICAADPPfcc29fAPPQ6dOiAnJwcXLx40SoMs7S0FIWFhWjRogX7fYSGhuKdd95B\nWVkZGjVqhB9//BEDBgwQDBkVwt90wdYN5QhZYh4dHV1SXFwcAwBFRUWxjRo1ugwA8fHxBXl5eYlM\nuvz8/IT4+PgCOWVouIYSN7WnBZxbrty0zjrCdu3ahfLycqvwRDHs2bMHL7/8MjZv3izpvLpESEiI\nldukadOmMBgMiIyMxDPPPGOX/tdff0WPHj0A1EYNjRkzhj32r3/9Cz/88ANeffVVxeqnBqF3Zx1k\nifmgQYN2rl+/Pg0A1q9fnzZkyJDtzP5NmzYNN5lM9f7666+mFy5caNGlS5ejcspQc++0mlFCfL0h\n4Nyy3YXFYmE77mbOnCn5/BkzZihcI/8hLy8P+fn5Vv7v5ORkyfnMnz8foaGhMJvNCA0NxaBBg9jO\nTw3HOBXzESNGbOzWrdvhc+fOtUpMTMxbu3btuNmzZ2fs27evb8uWLc/v37//odmzZ2cAQHJyclZq\nauqW5OTkrP79+3+9YsWKqe5ys2jY48sizpTvSnpn5+t0OrfOF16XSUxMRGlpKTv3zOTJkzFnzhzJ\n+cyaNQuxsbGwWCwwm834/vvvodfrHc67LgU1GIJui/pS66AhOfGkdRm57aKW9nQlasXZNvOQ0uv1\nmDhxIt588035FdVwygMPPIDS0lJkZWVJOq+kpATXr19Hhw4d7Gau5BuYJHegkLcHEblSB23WRD9G\nrjXtbSucizuFnEtNTQ1iY2OxfPlyyR2gGuL54YcfJAs5AEycOBH33nuvnWA7GhcgBzXc924JFfYl\ny1wNX4JaUEIA1YASbxSOhJxvMAsTbcEdoq/hfVasWIE5c+awVjhfJItSw/h91Tr3ublZNCF3jKu+\nZbXgSSFn/nP/HnnkEXTu3LlODvpRIwaDAWfPnmW3mzRpIjjRFoMvizkgvR6amPsJ/iLigHuF3Jnv\nnGudkySJ0tJSWXXRcA+RkZG4ffs2OxujIz+5JuZ/o/nMfQCp/m01+cP5cJeQ214333bHjh3Z8LlR\no0ZpQq4izp07BwAYM2aM4n5yW9Ty+1CyHqqzzDWr/G/8yRIHXKufM/cJADz77LNITk7G9evXMWvW\nLCurJygoCGPHjsXo0aNRWFiIkSNH4urVq7Lro6Esr7/+OhYuXIghQ4bg008/FZxWl0+v6pJ17lNu\nFk3M/U/EAeWEnNm2FXKSJPHMM89g/vz56N+/P3788Ue76VmvXbsmuw4a7qV9+/b4888/rXzk7hZz\nMcc9hdh6+LSbxReESin8zZ3CoLSQM77uuXPngiBqVxBq1KgRtm7dCqB23hBbwefOuKfhfYxGI0pL\nSxEWFoaQkBBcvHhRsYFBdRXtDlcB/iziSgs5ULtW5I0bN9CqVSvo9Xo89thjuHjxIrKzswEAJpMJ\nDRs2xJtvvgmKolghP3bsmOy6aCjLyJEj0axZM6eTaEkd5VuXUZWY16Uvjq/DTuw5fHk4+/MkSoi4\no4gUs9mMkJAQfPDBBzh+/DjWr19vlXbu3LnIz8/H5MmTUV5ejuTkZAQFBaGoqEh2nTSUZffu3eyi\nH7Z40s2oFo1Roh6q8pnXBTGXc03uaBelv3dFbkYHediGF5IkCb1ej0uXLvEuNqyhfgoKChAfH4/I\nyEhUVVXZzd0tJSRR6H4Wc5+rya0jxsfvsz5zf0CuhcxniVMUpYjFrZTlroTl7ywP22PM4hJGo9Fq\n2lQN34KZ9Iy7UhF3RSEp94Qr+IvRqFox94cGdkXohCI46tWrZzUdqFJuFCkuG6XcN2Ly4AtJBGon\nXgoJCWHjxE+dOuVSXTS8B0HULj1XWVmJL7/8EhEREaLeRoXuDWfn+SuqEXN/aXRXhc6RvxgAqqur\ncfjwYYerxasZKe3jKA0zd8epU6ewdOlSpKamKllNDQ9SVFQEo9EIAOjevbvVsnx8fUQa/KjGZ+6r\n/nJ3v+7x3cx6vR4kSYKmaZjNZgC1cdbV1dUAvO8DdJf/3PbBxfWfh4eH49KlSy6Xq+F9Dh48iAED\nBjicYItBzLS4/uQ3d+QzV+XyHWoXcqXrJ/UVsaamxmr1FUbICYIQXKzY0Q2i9vZ2BncFIQ3f56mn\nnmI/C93TjGvGbDajpqZGkUUr1CToclCNm0XtuCvMT46vj3Ex1NTUYNeuXax17iw/d/i93YHYji/u\n5+PHjyM8PFybp9yHee+99xAWFobLly87dCEy2/Xr11ftPewNVOFmUauLxZ31kNLxx93HvcEZ69xs\nNoOmabvJiZRaYkun00Gv1+PWrVuK5e2sTKH9zH+mz4DZx7THd999Z7USvIbvERISwt5frVq1wpkz\nZ+zuN4Kojezatm0bBg0aZGWdS5lZUU46T+DEreQboYneFnJ3W6xK5k1RFCoqKpCRkSFYlhxsHxrT\np08HTdNWQ+KVbiMpkS0EQaBdu3b4+eefsWPHDnZ4//79+zUh9wOY75MkSWzevBn33HMPO5KX+UtL\nS0NMTAy2bt2KuLg4Rcr1tva4iuosc280qKfKFFuOM1cJ8PcNb2uZuzJ4gu8NibF4Dx06hAcffBAm\nk4l3elJX7iOxIs6NP3744Yfx2WefYfDgwfjhhx8AgI2I0PBtIiIi2KkXIiMj0bBhQ9A0jdDQUAC1\n8elnzpyBwWBAVVWV3bznci1zqWndjVBnrqpnTfSWmKu1LDF+b0bMDx06hO7duztdXkton1B5BEEg\nMjISNE2DoigcO3YM2dnZSElJcTiXhpT7SUp4IkEQiI2NRWxsLA4dOiS6DA3/oHXr1rh16xbKyspA\nkiTKysoQHh4Ok8lktcQcUHfFXFXRLGqzkNVYll6vR69evRAYGIjRo0dj5MiRVj3xQr3/QlEuQnUm\niNopY2fOnIlDhw6hWbNmrEXOzYfPl8m3ny+NmHpwPw8YMACvvfaaqHM1/AtmObmuXbti6NCh7H3O\nGDVVVVVerqH3UZVl7s0OR7WU6SySgyRJjBgxAps3bwZJkjh79iw+/PBDvP7661buDyGRZX4EYsSW\noijs3bsXU6ZMwZ9//ik4bwYXJe4nR+6eyspKl/PX8A9eeuklmM1mHDhwAL///rsilrmc9O6E71pU\n3wHqCx2OUst1BxaLBRs3bmRfLdu2bYsOHTqwYscVPtvOXL1ej0mTJomuX8OGDXH//ffj0qVLvNEj\nfLgS9sh3ju1bQGhoKAYPHiwpXw3/pFWrVnjnnXdw4sQJb1dFFXhdzP1NxJmy3Zkn1zLW6/Vo3bo1\nAgMDWREPDAwESZKYNWuWlbhPnjwZ69atc/gmxD127do1mEwmlJWV4cqVKwgKCkKDBg2syrAVb6Ys\nvV7Pe8zRn5h2pGkaBw8eREREhCLtquE7mEwmmEwmREREwGQyYfr06XjllVdUZUl7E6+LuTvwZoiR\nK2VLOZfxgZtMJvTp0wcGgwG9e/dGeHg4tm7dit69e0Ov16Njx44ICAgAQRBYtWoVysrKWOEXElRu\nPSIjIxEWFoaYmBgUFxdjw4YNoCgKgwcP5hXiDh06gKIojBs3zqUHqrPzLBYLFi1aJCtvDd9k6NCh\niIyMRHV1NY4cOYLq6mq89NJLTt2GvoyU349fibk3rXGmfE/mazabUV1djeLiYnTp0gUHDx5EeXk5\nhg0bhqKiIvz73//GJ598AovFgi5dumDWrFkA/p4OgCRJ/Otf/+J1yTCfbX3kffv2xffff4+1a9fi\n2WeftUpPURSmTp3KdpwGBgbKahdHrpbx48fjypUrIEkS//jHPyTlq+HbLF68GF27dgVN03j44Ycd\nhuK6gjc1xBW83gGqhAB7u/GVKt+RH1roM58fm3F1rFmzBk888QQA4Ntvv0VKSgoWLVqE//3vf7BY\nLBg1ahS+++475ObmWgm27XfCCH9ZWZlVva5cucIu/QXUdpgePnwYPXr0gNlstov/BZx3Lgm5W5hr\nKiwsRHBwsMM8NPyD7777DsuXL8fhw4fRtWtXXL58Gb/99htvCK6UhSzEoCZL3/baVN8BKgdvW+JM\nHdyZjxh3A/Of+0cQBHJyctC4cWMAQEpKCgBg2rRpiI2NZQccFRYWsuUwos0n5ARBWA3nB4AGDRrg\ngw8+sPoekpOTYTQa0adPH0EXjiPBFto/dOhQFBUVaUJeh+jevTv27duHa9euYe/evVYRKxr2+KyY\ne1vEvVUHMYOBmEiX1157DZWVlVaTTwUGBuLMmTMoKyvDsmXLMHfuXDRr1owVzYSEBPTo0YMV8Sef\nfBJlZWUwGo2oX7++VTlBQUF47bXXrB4AERERKCkpwWeffYbu3buzKyMB/G8SziJjGCiKQlBQkIwW\n0/BVmBWIWrZsKWo63LqOV8XcXZ1jnsATdZDaIWq7zfyNGzdO8Lz09HRcu3aNtcw3b96Mu+++G5Mm\nTQJFUdi0aZPDcl9//XVMnDgRMTExrDBHR0cDqF209/HHH2fzpigKY8aMsVtYg++6bTtjt2zZgqee\nekobsl/HKCsrw9y5c632qeH370nEXq9XfeaOQuQcnOueSknAHXVw1OknlJbvHNsQQZIkceXKFaul\n5viIiIhgR9QxS7EBwGeffYbHH3/caf0PHDiAsrIyPPbYY1b7s7Ky0K1bNxAEgbKyMty+fRtRUVGi\nIhBsrXimMtNyAAAgAElEQVTGNXT16lWn9dHwL4KDg9lBcbZWujMfuVyNU9MbgM31qnM4v+injgpE\nHPCMkCuVV1hYGM6fP+9UyAHgxIkTiIyMRE1NjdV+MUIOAL179xY8RpIk3nvvPQBAbGwsGyXD/OeD\nr03y8/M1n3kd49VXX8Vbb70FwH6qCjWJrRrwWZ+5N/DUA8UV9xNJkkhMTARJknjxxRcREBAg6tzE\nxETUr18fDRs2lFW2EMnJyUhMTGTX6Dx//jyioqIcvpXZ7tPpdGjcuLEm5HUQo9EIkiQRHx9v9dbJ\nLJ2o8Tc+0RpqsMrVJuRCbhmLxYIFCxYgNTVVsXmeXYU73DoqKgqLFi1ifeh8o0i5EATBLtysUfdY\nunQpZsyYgXPnzlnNac69d7jUZWvdqZjn5eUl9u7d+0Dbtm1P33333aeWLVv2LAAYjcaIvn377mvZ\nsuX5fv367S0vLw9jzpk/f/6cFi1aXGjduvXZvXv39pNbOTWEHjL18ETeYspxZslaLBaMHz8eW7du\nxfjx42EwGJSpqIK0a9cOjz32GCoqKgQF3VbcteH7dZf//ve/AGrf0CiKQmVlJSZOnFinhFuUNjhr\nkOLi4pji4uKYDh06HL9+/Xrwfffdd2z79u1D1q5dOy4yMvLqiy++uHDBggWzysrKwjMyMmZnZWUl\njxw5csMvv/zSuaCgIL5Pnz7fnD9/viVJkuyUftwOUDEdfd7EU0IutiyheG2+kD+SJLFs2TKMGTNG\nwVorS3h4OO+Sd4D1NfXr1w9bt271dPU0VMS1a9cwf/58zJ8/H8HBweygNEezhQrtE4uaHhicCDV5\ng4ZiYmKKO3TocBwAgoODr7dp0+ZMQUFB/M6dOwelpaWtB4C0tLT127dvHwIAO3bsGDxixIiNer2+\nOikpKad58+bZR48e7WKbb10XcjlliRVyLjNnzoTJZFKwpspSXFwMnU7ncFbGxo0ba0KugZCQEMyf\nPx9VVVXsRG5qEltvI8lnnpOTk/T777937Nq165GSkpLo6OjoEgCIjo4uKSkpiQaAwsLCuISEhHzm\nnISEhPyCgoJ4KeXUBSGX616xdT8InduxY0cQBIGHHnpI1R1FAQEBKC0txdy5c3kfUgRBaAsPaKCm\npgYHDhzAxYsXcfr0ad7lC+u6sIsOTbx+/Xrw448//tnbb789o2HDhlYrBBAEYSFsFpywPW67z9Hi\nCd5GTUJum5aJte7Xrx++/vprqzRdunTBr7/+CoIgMG3aNCQmJuL+++93wxUoT/fu3UGSpN0PlCAI\nXLlyxUu10vA2u3fvxvHjx/H000/j+eefR3Z2NuLi4tw2yZbakDKvkSiTrbq6Wv/4449/Nnr06I+G\nDBmyHai1xouLi2MAoKioKLZRo0aXASA+Pr4gLy8vkTk3Pz8/IT4+vsA2T0cRDP6MGCHnaxdm22Kx\nwGw2Y+nSpYiLi2PdEyRJYuTIkfjiiy9AkiQyMzN9RsiBWjHfsWMH6tevb3dv7N6929vV0/AS69ev\nxxtvvIGEhAScPXsWNTU1yMnJqRNCDtj3gTlM66xRLBYLkZaWtt5gMJQuWbLkOWb/iy++uNBgMJTO\nmjVrQUZGxuzy8vIwbgfo0aNHuzAdoNnZ2c0J65kSLUJhaN7GXXXgu1apYYjMf51OB51OB6PRCIPB\ngMLCQkybNg2rVq0CRVHKVtzDMCNRGQiCQOPGjXH8+HEv1krDmzRs2JC1xG2nZBZjufpLBygAph3k\njQD98ccfu3/88cdPtmvX7mTHjh1/B2pDD2fPnp2Rmpq6Zc2aNU8lJSXlbNmyJRUAkpOTs1JTU7ck\nJydn6XS6mhUrVkzlc7PUZSEX68MWqo/ZbAZN0wgJCQFJkvjzzz+xevVql+upBu6//3789NNPViP9\n2rZt6+VaaXiL8PBwAH//FviingD1ia438NrcLLaC5m0xd0f5Qta4TqezsjTE1oWvE5QgCCQlJeHk\nyZOK199bTJ48GZ9++ikr6Ny5YjTqHklJSSgtLcWAAQOwY8cOp/OZ2+KqxqnpQeHIMldFmIM/CLnQ\nYBfb40DtF6LX60FRFOrVqyep/4Dv+H333YfMzEyXr0EtrFq1CqNGjeId4adR94iNjcWHH36IsWPH\nAhAn4HURVVjm3vzByilbyjlC8eA6nQ7Hjx9H+/btrWaDc5QPX4coI3ipqal+JegaGlySk5ORm5uL\nmpoaSf5yZ8fEoKaHhuotc28hNr5bTuSN0MAe5nOjRo3w+OOP8w6WEdNZyt33zTffICoqSlS9NDR8\ngZqaGpSWlrIutsOHD1uFI0oJ2asreN0y95ZV7qhcV+vEd76tmFMUhXfeeQddu3ZlF6kF7G9Mpp24\n63MCtSvvnDp1Cq+//joiIyPx2muvuVRnDQ21ERoayk71wAzblyPmmmXuxwhZua7GvEs5n6ZpzJgx\nA5988ongRFMkSSIoKMhqtjhuvHm7du0AQBNyDb/jrbfesgpDdDb/ioaXLXNvWOVSRl/KyVNsmVzB\n1uv1vL5AgiAQHByMW7duWVkltoKvLaWm4W+YTCZER0dj6dKlePrppx2uAapZ5rXUGcvckQ/b1Xxd\nwWKxoKamBqtXr0b79u3tpoS1WCwIDg5mhdvWxx4WFuakBA0N36NevXpYuXIlpk2bpvnHRVInxJwv\nCkTpfOWmZyyOyZMn49ChQ8jMzARJkpg2bRpIkkTfvn2Rn5/Pivzly5dZUSdJEllZWYpci4aGWggP\nD8fevXtx4sQJmM1mAJqIi8Fra4A66yR0d1meys92KD4fnTt3xsCBAwEABQUFmDdvHjp27Ijo6Gg8\n91ztDApGoxFLlixBQECA1QjS6upqBAYGyrkMDQ3V8eWXX8JiseDRRx+tM5NpKYXXfOa2c4i4S3Bt\n83X1epUScm40D2Nll5SUiF6zU0PDn2nQoIHdPCyAvMUnlNA4tTxUHPnMVSHmcgfhODrODelTYkCB\nXJeK0BuIbWgm40bROjM16iqRkZGgaRrV1dVsQIASE2nVFTH3us9c7iAcMcfFzCDoLCTR0YAdR3+2\noYTc80aPHo2IiAh2/6BBgxAVFYX27ds7ra+Ghr9y6tQp3L592yqyyxlqEVk14FXLXOwITKlpGNGk\nKIpdJ1Dudcp1qwQEBMBkMtlN5wrUvjWMGzcOmzZtQlVVFUiSxKpVq5Camiqrjhoavk5ycjIuXbpk\nN3jOVReL2DSeyEMJVGmZu0vIbfdzXRq2xx1Z1cxK4GLfCGzdKv3797cLM+QeX79+PbKzs/HTTz8h\nJSUF3bt3d3qtGhr+yMiRI3Hp0iVJMyFq2OM1y1yncxxI44qQM+6ViIgIVFRUSBpFxuSp0+nw5ptv\nstEktuc5eogwLpajR4+ic+fOvOeQJImYmBicO3fO6XVqaPgrTZs2xeXLl0V1dmqWuYotcyF/tdDw\ndu65tmkYAaUoClu3boVOp0NcXBwqKyvRokUL9jy+8m3zJEkSCQkJeOGFF+zK4a4kz/3jWuEMBoOB\nrRdj6ZMkiYkTJ6Jhw4Y4duyYO5tYQ0OV0DSN8PBwBAcHs0LuDLWIqZrxageorRgyf3ydhkwaW/cH\n39+0adNw7do1HD16FACwc+dOK6G2/VyvXj27PB966CE88MADVmJsK8rcBwizn1nSTa/XIyoqChs2\nbABFUXjkkUcwatQofPXVVzCZTMjPz0dwcLA3m19Dw+Ns2LAB4eHhqKmpsdqvibXreG3Q0Lhx43g7\nLgGwK8zY/mfSOHKREETtmpFcgoKCMGbMGPY821XgSZK08tMRBIF3330XR44cwYcffgiLxcLOn8Kk\nte3Y5KsnACQmJmLMmDF47rnn0LhxY1y8eBHLly+X3W4aGr7K0aNHMW3aNHZbE3Bl8ZrPXK/Xc7dZ\ngRQKBWTgCibfccYV0qpVK/zyyy8AgLy8PCQnJ9sNDXbk92b87kw0DHe/7T4ArNgz+0iSRE5ODnr0\n6IH8/Hz2uuLi4lBUVISxY8di8eLFUppNQ8MvOH78OHr27Gm3SDMgHL0iN8ZcbBpP5KEEqhw05KwD\n1DYCxbaeQlEm3OgVnU6HxMRE5OXloaamxm4xWL48mf86nQ5BQUGoqKgQTM9XNteHHxUVhStXrlg9\ngCwWi5WLRlvfUqOusmjRIrz88stWQq51gDrGJ8X8TjpZxxmf+HPPPYclS5aw+4VW9ubLk6Iou7kh\nhMTfdh9jwRMEYWfFc2PN8/LyQBAEcnNztRXoNeoswcHBvAtPaGJujyqjWcQgZpiu0BdssViwbNky\nALUNwB08ZPvHdy5feqFybAXfYrHgueee430YcP32ixcvxuzZs9GjRw9s2bJFfMNoaPgR169f1xbv\nVgCvibmSw3WF0nB9cs7O58aiM+Iv9nxuHgyLFi0SfIAAwKhRo7B48WJ89NFHsFgs+O2331BcXOy0\nHA0Nf+TIkSOYNm0a7wA7DXF4faItKV+YFLeL2Im2mDSulCuU3pEbxjb0kgl31HzoGnWVuXPnYunS\npYJvxHI7QeuKm8XrYn5nW04eDo/bLoTMh9RrlyPqzvz6TDqKotC9e3fs2rVLUhkaGv5I/fr1nUa4\nONon5bgYfEHMvRZnzsVZqKCjc4RgwhCVfFXjC4t0ll6oDtz6d+zYEX369MGMGTNE5fv222+zn8We\no6HhKyxdutQq+ktDHKqwzB2ks9vnijWtpLCLzUvI5cK12pmRo0ajEQaDARZL7TJy7733HsrKygAA\nI0aMwJ49e2A0GhEREcGGOJ48eRLx8fGKXZeGhjc5ceIEG4PO/AnFoTO42zJX0wNFldEsUjoVHUWU\niM3D9rOrSO3AFUrPDJhatGgRgNrRqmazGatXrwZN04iNjcXhw4fx9ddfg6ZpNGvWzCpKRhNyDX+i\nffv2uHTpEiorK7FmzRreGU81+KkzLSWmI0VOnlLyEkpLkiTuv/9+hIaG4tq1a6BpGrdv32bTDxgw\ngLVSLl++zIq52WyGwWBQ5Fo0NNRCWFgYgFr347PPPqtFuIikzog5YC/oSlnqcgWdGSVKURQ6d+4M\ns9mM6upqVqy5E/W76w1DQ0ON/PXXX+jSpQuuXr3K7tOE3DFeFXNvCJKjwT+u5isldIqxNnbt2iW4\n3qHFYsHt27ft4tUZJkyYgLy8PJfqraGhRo4cOQKLxYKNGzfaRYVpos5PnbLMGaSM6FQqby4EQWDV\nqlXIz8/H0KFDWSucr4+gqqqK9xhBEPj2228RFxeHDh06yK6vhoYa6dGjB4YMGYJhw4bh9OnT+Omn\nnzQRd4LXolm4HRve/JKkRqW4krdtXHlhYSHi4uKcDo7g8xcyk3kxVktQUBAKCgok11FDwxfIzs7G\n0aNHMX78eNGDicQed4aaXJqqjzP3BYRcJWLO4UvHTNNLEITdHC58+djOl26b/4ABA0Rdh6/w119/\n4dSpUwCAgQMHerk2Gt7kwIED6NKlC9atW8fu465r4GiNg7qEKizzO/s8Xg93le1onnTujIpMByd3\nNkdHdeGbBoAgCPznP//BCy+8oOAVeJeioiLcfffdAGqvk9sJplH36Nq1K86ePYv09HS88cYbVoEB\nDEqO9Fb6fCVR5XB+NYm5O8vnc7WImWpAaF4X5j/XzZKUlIQTJ04oWGvvEhkZafWAMxqNXqyNhjfp\n06cP2xkaFhbGPthtx29oYu6kA/T27duBXbt2PdKhQ4fjycnJWXPmzJkPAEajMaJv3777WrZseb5f\nv357y8vLw5hz5s+fP6dFixYXWrdufXbv3r39hPK2bSBvN5i7yue7TmduFSadozSTJk1CgwYN0Lhx\nY5w4ccJuTUVfJSEhwSp6B6iNN9aomzCd+xaLBUaj0eFbrzvwti5JwaGYBwYG3j5w4EDv48ePdzh5\n8mS7AwcO9D506FCPjIyM2X379t13/vz5likpKd9mZGTMBoCsrKzkzZs3D8vKykrevXv3I1OnTl1B\n07TPRMy4U9CFYtydiTbf8RYtWqB169bYunUrcnNzERYWhqioKHzwwQcAgEOHDuH06dNuuRZ3YxtL\nb7FY0KlTJy/XSsNbPP300w6Pe/uNXk04FdoGDRrcBACTyVTPbDZT4eHhZTt37hyUlpa2HgDS0tLW\nb9++fQgA7NixY/CIESM26vX66qSkpJzmzZtnHz16tIvYyqjhKejOOvAJuu22kMhzty9evAgAeOGF\nF9i5181mM65cuYLw8HAMHDgQY8aMcdt1uIuIiAjcuHHDbtWZffv2eblmGt5iwoQJoCgKM2fOtFpu\nURNxe5yKOU3TZIcOHY5HR0eX9O7d+0Dbtm1Pl5SUREdHR5cAQHR0dElJSUk0ABQWFsYlJCTkM+cm\nJCTkFxQUSJo8pC4JupiybEd+ArV+s+effx5//PGH1YREr7/+Oivsa9asQefOnd1zEW5g4cKFgsv0\ncddh1ahbHDx4EOXl5XjhhRcQGxuL4cOHo2fPnnVS0J1phdPQRJIk6ePHj3eoqKgIffjhh/ccOHCg\nN/c4QRAWgiAESxE6JhRLrRZswwDdmbeYspg0tuuYcqcKpWma3e7VqxdIkoTBYEBRURHq1aun8FUo\nQ1VVFcaOHYv9+/cLrtHapEkTD9dKQ22EhYXhwoULAIChQ4ciICDAav4iwD9DFKXE04v2Z4eGhlYM\nGDBg17Fjx+6Ljo4uKS4ujgGAoqKi2EaNGl0GgPj4+IK8vLxE5pz8/PyE+Ph43pEs3NA6WyFTyxfi\nSQtdyjm21rqjzzt27FCtkAPA6dOn8dVXX+HWrVu8LiaLxYJLly5h0qRJXq6phhq4evUqoqOj/abD\n3xmOdNIWh2J+9erVSCZS5datW/X37dvXt2PHjr8PGjRo5/r169MAYP369WlDhgzZDgCDBg3auWnT\npuEmk6neX3/91fTChQstunTpcpQvbzEdf2rAkz50qeeJCW0cPHiwzNq5l6ysLADAQw89JHgvcK/z\n008/9Wj9NNRHeno6WrZsieXLl7Phve58o1eLBonFoZulqKgoNi0tbT1N0yRN0+To0aM/SklJ+bZj\nx46/p6amblmzZs1TSUlJOVu2bEkFgOTk5KzU1NQtycnJWTqdrmbFihVTHblgnOFOV4ca6yHF3cLd\nZmCe3mFhYViyZAkmT56MzMxMt9VXLtu3b8e4ceMwdOhQ9tVYaIQtc71qvA4Nz7JmzRqYzWZMmDAB\nw4YNw6ZNm2AymbxdLdXgtUFDd/6LEkk1CDrg2YFFYtLbpiNJEgEBAcjLy0NCQgK7SpHa2LZtG9LS\n0py+nQG11xgfH4+zZ896qHYaauLVV1/F8uXLkZ2djfj4ePZ+oSgKNTU17IyjXJQaw6Imy9zGfaqu\nlYakoJZG9VQ9XCnHZDIhJiYGZrOZneTfm1RXV8NgMGDLli0AgN9//91KyMWEZBYUFCA0NNRbl6Dh\nRYxGI27fvo34+Hi72UOFOszrKl4Xc7HC5c+CrlSetoI4ZMgQq7ksHGEwGDBv3jzFOxovXLgAmqbx\n66+/AgDeffddq7oKwWddTZ8+Hdu2bVO0fhrqZunSpXjiiSfsRLy6ulo1mqAWvC7mUhDzWu6pevhC\nGdu2bcPChQudrqO4ePFimM1mLFu2DDdv3mT3z5o1y+mydMxI0379+iEyMhKzZ8+2S2M2m7Fq1Sq8\n8MILeO2113inM3DWAQoAH3/8MTuTokbdoW3btnb3grt/g2rQGal43WfO/S8xD2UrJQMl6+BoYi2h\n/bbzm3O3uaPlSJJEaWmpYNnh4eGs9b5y5UqsWrWKnbiLJEmHE13t2rULTz75JNtRSRAEFi5ciAkT\nJgAAQkNDeQcDifGVcz8//PDDyMzM1NY8rWM8+OCDWLduHSvoQqLuKDLMlTBgNcDz21Gfz9yVBlND\nY3vDOhDbYXz58mXMnj0bBEGguLjY6vjt27dx7733wmQyYfr06TCbzewo0vz8fPz+++/s9tNPP40R\nI0agsLCQt6wJEyZY+TJTUlIwYcIEVFVVsULOPS5mkjHm2rnpNm7cqAl5HeT48eO45557VGG8qR2f\ncrPY4k+CLpSPmPz5LPSYmBjo9XoYjUbo9Xr2+NixYxEXF4eLFy/igw8+wMcff2zlj3z11VetxHf5\n8uX4+uuv0bZtW8yYMcOq3MGDB1vNpUIQBN5//30cOHAAjRo1YoWcuQ7bAU1CnZ6212+xWGAwGFTR\noavhOTZt2mQ3aEYTdWFUIeauWujeFnVvls/c3Nwl5Ji5ztPT0wEACxYsYBd7WLduHTt/y0cffYQ5\nc+Y4FFfu57ffftuq7DVr1lhZ3DRNIywsDL/88guGDRvG+yrsrNPTkaibzWbWZ75gwQJZ7aXhOwwf\nPhxlZWVYunQpKisr8dlnn6F79+6aqAvgVZ/5nc9W/xXIW5F8vFG2s1WGbNMw/nAAmD59Ovr374+Z\nM2fCaDRi165dOHnyJBITEzFgwAA0bNgQN2/eRFlZGZo0aYLS0lLWmhZa6Yh5KDAPCiZu/R//+Ac+\n//xztGrVyi5SJjMzE1u2bMHLL7+MlJQUdlCH1PuML/aeqU/Pnj1x+PBh/Pvf/2YfWBp1g5CQENA0\nDb1ez87NwhfOyqWu+Mz9bg1QRqDqQtkEQeDkyZMYPHgw2rdvz66VySwUHRAQwM55UlFRAYqi8NRT\nT1mt1mIr5LbXQJIkSkpKEBcXB6A2MiUrKwsVFRW8nU8TJ04ESZLQ6/WyhZw5h68tLRYLfvjhB5Ak\niZkzZ0rOV8N3MRgMIAgCOp0OAQEBqK6uZqeAVnKSLbUKuTP8TsyBvxvAG6LuStmOHgZ8IgvUrsRy\n+vRptG3blhXm6OhoAGCFnHs+V2D5LBiuoBMEgfLyckRERMBisSA0NBTp6ekwm83o1KkTbx6Mpf/V\nV185tJZsz5HSHiEhIcjLyxPMT8M/YSKy+vTpA4IgsH37dsTGxoruVPd3vO4zd2fcqDf96e4sl+ty\nGTt2LBYsWGA3Oo7xMXP3V1dXo2HDhk5908z/pk2bAoDVAhgZGRnscb48bKNWxHwHYtMRBIHp06dr\nQl7H+eabb7Bv3z4kJibCYrGgWbNm3q6SKvC6mHsCsWLhjnKVJjAwEEeOHIFOp2Pnp/joo48cRodw\nBXbt2rW8ws9nRV+8eBHz5s1DbGwsbySK7bU6KltsWzjyfxIEgalTp0poLQ1/49NPP8VTTz0FoDaa\n6rHHHhMMm5WDmix8yf1M3u4AvbNt9d9DdVBtWY4GCzGdkSEhIQgNDYXRaLSbC5yLs21HZX322Wc4\nf/48EhMT8cILL+DKlSvsYst8eQmVIeUahdKQJIkrV65g1KhR2pD+Osi1a9dw7NgxPProo4iMjER2\ndjZCQkLY+9HRfSlF49Qu5o46QFUl5rafPVQX1ZXjSGBtww91Oh07cxw3ptsWMS4MWxi/PEVRaNq0\nKfLy8lBVVeXQxSIVKaLORNYEBwfjxIkTaNSoEUpKSnD9+nWMHz8e3333neTyNdSHwWCwG7F87do1\nJCQkAADblxMeHg6TyWT1pgnUXTGvE24WR3jKBaNkGUxeBEFg+PDhGDJkiMMyxJTLdy7zcOjRowfy\n8vJgMpkculhcuRaxaWmaRmVlJaZMmQIA2LBhAzp16oSTJ0/KKl9DfTDjFcLCwnDo0CHs3r0bn376\nKTuWIT09HVu3bgVBEKAoytvVdQtyfk91Xsy5eELYxQqr2DT169fHjh07HHZGSq2frc/6xx9/hF6v\nlzXHipRynR3j+v737duHBx98EKtWrWJfsXv06KFIXTS8C9PhTtM0Dh48iIkTJ+KZZ55hv/uMjAz8\n+OOPaNSoESorK5GUlKRIuWqyyuWgOjcL37a38dSiFM6OcUe+MW6WgIAA9lWTGzOu1PfKLdOZr1yp\n8sTUBbAf9UoQBJo0acJOEqbhW2zZsgVLly7FH3/8YfcAZz5z7/8OHTqguLgYhYWFdq4WLlLe/NSC\no/4oVfvM7+zj/aw2lK6bFEEX8plbLBZ2AAWgrptSDmJni+S2hV6vx//93//hpZde8lg9NZQnKSkJ\nZWVl7NuWkEAzLhaCINh+HEBef5HUdO7G2VuqT4k537YaUbKOQpa47TYj4hRFgSRJVFdXo169enZL\naHnye3XHd+WoPfjEnKIolJeXK14PDc/zxBNP4OuvvxYMU+V2iHNFn5uGi1KuTU8hV8w1n7kLCMVW\nu5KXs30EQWDatGkwm82se+X27duoqalx+KrpTmzbge9PTp5iYB5q9913n+QyNNQJs+AJA5+o0zTN\nGi/eMGDUiCbmCqKUqDvbd+TIETuxVPt6iHKE3ZHfEKh9sGVkZKCiosJqhSQN3+Kxxx5j5xUCal0t\nQveLkLXuL7hyPapxs9zZz/vZl3HlOmzbg/EN265IruR3KDYvT81yKeR+0+l07DztjlZC0lA/MTEx\nuHXrFiiKwrp16/Dcc8+hqKjIqXA723a2X2oaT+CsHj7hM7+z3+G2LyP3WoT85oAyN6ASeSjxPYnt\nCGY+UxSFgwcPolOnTi6XreFdGjVqZDUpHJ+7sC4IOeCamPvlrIlqhPslSRE/204f5iaXK6DuuHHl\nXhtfHnzn214v8zklJQW7du1yGl++ceNG3Lhxg12XVEMdvPHGGwgJCUF1dbVDF5yaxNaduHqdqhZz\nV0RLzcgRPz5RVyOORNmV821jjDdt2oRWrVrh1VdfxT/+8Q/odH/fynFxcRg5ciTeeustjBkzBgcP\nHkRlZSUOHDiATz75RFa9NJTljz/+wJtvvsk7PkKMdaphj6rcLHeOOdz2V5SajEttKNVnwN0ODQ1F\ncHAwxo8fj4yMDFAUhe+//x7t2rUDALRq1QolJSXs4hyMa0oLXVQPkZGRVguJ80U/CXWA2uIslM8R\nankwSImF9wmf+Z1jovb5K5qoOz6XL8YcqPWhR0REICcnB61bt0ZRURFr8REEgdDQUG0edBUyZcoU\nnDhxAqdOnbISdkATc6F0Wpy5jyAnfE8tN6QjXKkjX0cYNyTTYqmdAnXEiBEAgOPHj9tZe7du3UJB\nQaWidaMAABtrSURBVAGbz8aNG2XXR0M5Vq5cicOHD+PAgQMgCAJNmzb1GQNFKZT6/fqEmPuCWCmN\n1LhsXxB1dwk68/fNN98gODgYUVFRVmLODKxq06YNlixZgjZt2miLXKiMM2fOIDU1FStXrsTChQvt\nRvsK4Q9WuVKozs1y57iofXUJf3O/KBGq6ShsUyg9Mx0C87lVq1b4+eefZdVFwz20adMGubm5skIU\nxR4Tc9wTSK2D5mbxA/zV/SIVZz9sMSMEmTQ6nQ75+fnuq6yGJJjBX2fOnMGZM2fcapD442/DZyxz\nR/vrGnLaQa1t5+q1OHuL4+swZf4qKipk1FjDXXTv3p2dl4VZQNx2JlClLHO1iLnfW+ZqaWi1Isfq\nluqD9xRy6mNreTv6gdse69evHzvrpIa6GDVqlNXCFID9TJlcfEGsHaF0HVUp5kL4whfkSeSKs9pE\n3VVBFwtBELhw4QLKy8uxZ88eyedriOPPP//EypUrJZ+Xn5+Pnj172u1X+q1STfe+kqjSzXInjaT9\nGsrN/+ItXO3kFdpm3CrXr19XzbX6MxERESAIwm5RZrGEh4ezQ/wJgsAvv/yCTp06WVnsgG+7WOTW\nwefcLI5QwxehVly8QbzetnJcR1LODwkJwdatWyXXS0McP//8M+Li4tjBP1evXpWcx9ixY1kRJ0kS\nW7duxbBhw1i3mJiHsbfvY28hSszNZjPVsWPH3wcOHPgFABiNxoi+ffvua9my5fl+/frtLS8vD2PS\nzp8/f06LFi0utG7d+uzevXv7ya1YXf1CXMXVdvO2qLu77NjYWLfmX1f5/vvv0b9/f9y4cYMV85Yt\nW0rOh5kCl6IopKeng6ZpXLx4ETU1NYrUUw264q46iBLzt99+e0ZycnIW4x7JyMiY3bdv333nz59v\nmZKS8m1GRsZsAMjKykrevHnzsKysrOTdu3c/MnXq1BU0TStu/avhC1EzSgiyN611pQYX8R179tln\nMXz4cBgMBkn5vvzyy2jUqJHsevk7PXv2RK9evaxiw1evXu3wnK1btyIrK8tu/7x58xAXF4fevXtj\n5MiRVkP8fR13XodToc3Pz0/46quv/jlhwoTVjK9m586dg9LS0tYDQFpa2vrt27cPAYAdO3YMHjFi\nxEa9Xl+dlJSU07x58+yjR492cVvtNRyi1I3jDWGXMvLVEbYDibKzs7F7925kZ2dLqs/PP/+M6upq\nRERESDrPn2nWrJnV9rfffms16jYtLQ0JCQlo3LgxJk+ezKZr3rw5vvvuO0yaNImNLf/tt98QExOD\nu+66C1euXEFWVhYGDx4MmqZlTRkt9Zg/4FTMn3vuuSVvvvnmCyRJsj0PJSUl0dHR0SUAEB0dXVJS\nUhINAIWFhXEJCQnsKIyEhIT8goKCeLmVq8tfjFIo3U6eFHVXy+GLLWf2h4eHS8rr6NGjrPvgypUr\nLtXLH2jWrBlKS0sRGhqKc+fOISQkxG56BZqmUVFRgfLycmzZsoWdtfLkyZMYPHgwzGYzcnNzERoa\nigcffBA3b96E0WiExWJhJ0174okncPfdd6N+/fqgKMqnO7BdiTwT87tzKOZffvnlvxo1anS5Y8eO\nvwv1oBIEYXEyC6LbfvmaoIvDHQLsKVF3JWxx9OjRaNu2LRISEjBp0iRZYrBr1y6Eh4ezr/o0TWPq\n1KlYv349Nm7ciIiICKSnp0uuo6/z1ltvsQ+3++67j400sRUei8WC4OBgLFu2DGFhtV1r27dvR58+\nfUDTNCZNmgSz2cye8+CDD6J+/fqgaRoJCQkoKSnB2bNnUVNTg8DAQJAkyeYrBV/VCj5jRAiHYn74\n8OFuO3fuHNS0adO/RowYsXH//v0PjR49+qPo6OiS4uLiGAAoKiqKbdSo0WUAiI+PL8jLy0tkzs/P\nz0+Ij48vEMpfw7O444b2hAvGWd5Cxz/++GMMHDgQo0aNwuLFi7F582ZW0IXOmT59utV2+/btkZKS\nwpZD0zR2796NZ555Bk8//TQsFguGDx8u46p8myZNmgBw/P0z+1euXInjx4/jvvvuw6lTpzB58mTs\n3r3baspb5v+BAwfQsGFD9tjBgwdhMplQXV2NqqoqhwuXq1mwPVE30XHm3333Xa+33nor/Ysvvhj4\n4osvLjQYDKWzZs1akJGRMbu8vDwsIyNjdlZWVvLIkSM3HD16tEtBQUF8nz59vsnOzm5ua51Ltdal\nLvqr4Rx3t5k78he7TiizTRAELl++jPj4eNx77704ePAgACAnJwdJSUl2eeTk5ODee+9Fbm4ugoOD\nAQAHDx7EsWPHMG/ePN78CYLA7NmzMWfOHNcuToXcd999OHbsGO+xpKQklJWVWVnVfFpCEASaNGmC\nS5cusdtC6ZhwxKZNm+Kdd95B//797To/hcpSu0tW4f4r19cAZUR49uzZGampqVvWrFnzVFJSUs6W\nLVtSASA5OTkrNTV1S3JycpZOp6tZsWLFVHe6WRiYuFQN8bi7zZibV8ky5NQ5JiYGBEHg2LFj2Lx5\nMwYOHGgl5PPnz8dbb70Fi6V2TnQAuHnzJm7cuAGSJDFw4EBBa5AgCERFRaGqqkqwfIPBgF69euHz\nzz+XVG9vYjAY2LYQIicnBwCQm5uL1q1bC4qVxWJh0zLbtjACT5IkSJLEt99+i7vuusvOXSN0vtrx\nVJ1VOwLUJr0iaTTs8VS7KVmOmNHBtr5GZj6WRx99FGvXrmXTff3111bhb9zfg06ng8lkYrdtHyaD\nBg0SXOTi1KlTGD16NHJycjBnzhy8+OKLsq/XnRQVFeHmzZt2kSmhoaHs9aakpGDs2LEYNGgQe/zU\nqVP45ptv8NJLL1kJvxQ9sf2+BgwYgNGjR2PQoEEICwuDyWSyW3mIrxw1W+Vu6qvy3RGgYhrE21+a\nr+LJjkylyhITjsiFJEkYDAZs3LgRw4cPx9y5c9lj/fv3R3JyslUdGX9tVVWV1bZtZMEXX3yBOXPm\nYMeOHXZ1mDVrFi5evAiz2YzDhw9j//797LE//vgDvXr1Yrc9uTbpSy+9hN9++w0AcOPGDSQnJ2PG\njBlWaR5++GH2mmmaxv79+3H79m2rNJcuXcKyZcusZjV0ZJ3zRWXY7tu1axeefPJJtGrVym6QkFjx\nrsv4hJhruB9Px5C7Wp6Y8ymKAkmSaNeuHU6dOoVu3bph6NCheO+99wCAja748MMPceDAAat8xfhm\nLRYL3nnnHSxfvtyubK6/99tvv8WRI0fYY5MmTcLx48fx+eefIyUlBU2bNkWzZs0QEREBg8GAwYMH\nS2wNYbZs2YK77roLERER6N69O5YvX47x48cDAOLj42E2m3H33Xez6a9fv47Dhw9bPbxOnjyJ1NRU\n9OnTh023ePFinDp1ymnnpzOBt91moli4i4g4oi5Z5c7wCTfLnXMUTafBj7faT6lJwriulXr16iEw\nMBBJSUk4c+YMzGYzCIJAYGAgzGYzampq8N///hfNmzfHoEGDcPr0aXTp0kWUf5Yp9+6770bv3r2x\nevVqFBcXo0uXLigoKMDNmzet0jMhdYx/mOuysXUJGQwGXLhwQVZ72LJixQq89NJLrFAy18W9RoIg\nsHfvXjzyyCNshyb3GFN/kiRx7tw5tGjRwioKhYscPbFtB5IkERAQgKqqKtTU1AhOriU3yslTuKN8\nn3ezAMqNCNRwjLfaT661LnSOTqfDF198gerqarRu3ZoVKZqm8eqrrwIAaJrGf/7zHzz55JMwGo3o\n1q0bKyx8ViNfuTdv3kRCQgKqqqoQHh6OGzduoGvXrnYuBCYOmy8e2zZ/pYQcAKZOnYp//vOfgq4N\nZl/fvn1Z4eRzhdA0jdWrVyMiIgKzZs1iXTCO2kgstg/P+++/HyaTyeEDvi4KuTN8xjK/c56i6TSE\n8XYbujIdLmPdMZ+nT5+Od955R/C8V155BSRJ4sqVK8jNzcX27dtF/RgdLZzg6ByhjtpZs2aBIAi3\nhDkuXboU8+bNE3yAOHsbIQgCU6dOxXvvvWdnvfMh5q2Gbx/TUV1TUyNYV2f5iznuTtxZtiPL3C/F\nXGpaDWG83Y5yv3Pbz8x9zueWIUkSOp2OnUPbFVeBmGNC7pUlS5aw/mx3EBYWZtWZyyDGrWR7XMhP\nLhVu2zBCTpIkG+6pCbl9/j7vZgGkNZS3X7P8BW+3oxRx5XMPMJ9t03CP0TRtFwbHl96ZpSjWSrXd\nZh4oer1e1HXKpaCgAIsWLeKti5jr5u7nSysHbv40TbMjPeVa5HUZn7LM75zrlrQajlFLW8pxtXmi\n7kLWt6M6MX+VlZVurx9DWVkZGjduLBhS6EgPPC2scsvzZr+PJ8rwC8tcKtpTXDnU0pZirUAha9wV\nK1JKvaRYla+//rri9eGjoqICd911FwD+YfWO3iw8JeSuWuT+LOTO8Dkxl9poamhkf0FNbSlGlJ25\nPsT+Sa2Xo20+VqxY4XQhByUIDQ3F+++/z4YZct8UhHzgSvnGhfIW09ZqF3K14HNuljvne+QcDX7U\n2JaemvJBbkQVX7QN42Y5ffo0GjRoIHn1I7nk5eVhypQpOHDggGRLWI5euKIxvtBP5sly/c7NUtef\nwN5Gje0v1lL3RDl8ZdluL1y4EJWVlaAoComJiR4TcgBITExEXl6e4INJCSFXwqWlCbk0fFLM5aCm\nRvcH1NqerrhelCzH2Tn79u3D559/jrKyMpfrIpYLFy5g8ODB+O233/Dmm2+y0xDIeTgJpfFG+2pC\nXotPulnu5OHR8zSEUWubesL14ux8R9MNUBSF3NxchIWFYfbs2cjIyHCpLs64cOECOnfuDJqmERIS\ngrKyMt7QQz6UdLs4wtNuHFfwRrl+52YB5Dek2p6m/oBa21SKNenOMoTKXLt2LUwmE7p164bMzEzZ\ndRDL7du32SgWKW8EmpCrp1xH+KyYu4IavwhfR61tKsXH7Q4DwdGxtLQ0NGvWDKdPn4bFYsEHH3wg\nq3yx3HPPPVi5ciUCAgJ4j0uJXFGDkHsLtdbVZ90snLw8ep6GY9Tcru4ecCZ20QzmP3eWwGHDhuH9\n99+XXKYcDhw4gEGDBvFO+MXFXWGJSuXnLTeHN/FLN4urePtL8VfU3K5SrG85nXlyr3369OlWq/i4\nm1u3brE++4CAANx///2izlPyu/WGe8tV1HxvA34g5r52Q9QFlIpocBdS6yb1ISCErVXOfH7jjTcw\ncOBASXWSw5AhQ/Duu++iefPmoCgKeXl5oGkajRs3tksrNu5cDmq+N4TwhTr7vJi7ii98Sb6KmttW\nzgNHqRhz26lzmRWP3EF0dDT27NmDsLAwHDx4EOfOnUPLli1hNBrZ5dk2b97sMA+lvkdvhoXWBfxC\nzF39crWbw32ovW3dFUEhlIYkSaxbtw5NmjRhR4E2adIEAJCfnw+DwQCapnHt2jW7GQ7lEBUVhaFD\nh1rNCLlw4UKEhYXh+vXrHvGLK5mn5l4Rxi/EXAl85QvzRdTetq6EF0rJd8iQISBJEqWlpXj//fcx\ndOhQjBkzhj3erl070DSNiIgING7cGK+99hoKCwsl123nzp0wGAz45Zdf0KxZM7auNE2jTZs2ePHF\nFzFlyhTBVZUcXYMc1P79O8KX6u7z0Sw2+aoiDw1+fKFt3REdxY1aefTRR7Fr1y6YzWZ88803WLVq\nFQiCQNeuXXHhwgVkZmayAvLEE0+w4YrNmzfHa6+9huHDhzusR1ZWFrp37w6LxQKDwYDLly9bPXhI\nksSqVauwbds2HDp0CNevX2cX5QAcC7tU1BT54gvlicFRNIsm5m7MR4MftbevK/VzFJ7I/QOAuLg4\nFBcXs6GJjRs3xsKFC9lzGjZsiOrqasTGxiI3NxcURaG0tNRpHf75z3/i0KFDghE5DRo0wM2bNxEV\nFQWj0QiTyWSXThNy9Qk5oIm51/PSsEfN7euOIf62nZ62a14WFRXh6tWraNu2LQBYWdJM+rFjx2LZ\nsmVOyw8PD7dawFpIpAmCwLJlyzBt2jS7Y+4YQOUKntQptQo5UIfE/E7eqsxLwx41t687XHZ8gk4Q\nBO666y7069ePdbFYLBa7tTGZuPCnn34a8+fPd1jugAEDkJiYiMuXL2PPnj28LhQGKQOGnKEJuftx\nJOY6T1fGl7D9UWkoi5rbl/lRu1I/2+tjtrn/AaBr165Ys2YNu5Qb37nM527dujksMz09Hbt27UJE\nRISdL1ysYMsJ2XQXmpCLx+8s8zv5qzo/DXvU3MZKu12Ehvfznce4YU6cOIH69esjOjoaDzzwAOLi\n4uziw1evXo309HQUFhYiISHBapFqR0LuilWuCblnqVNuljv5+0SeGtaotY2VdrmIWeyZ+7l+/fow\nmUyoX78+Ll26xHaIAkD9+vWh1+vRrFkzlJaWgqZp9nyapmE2m60sfsC5eCsx2lUJPKVNviLkQB0U\n8ztl+ESeGtaotY09Lejcbe785yRJsuJMkiROnz6N+Ph4hIeHg6Zpqw5PPqtcCSH3hGZoQs6PIzH3\n20FDah7FpiGMWttYzCAhqfk528ftnLRYLDCbzaipqWHF/OWXX4bRaAQAFBUVYciQIVYDhNyBJuTq\nResAlYiaO+38BTW3sSt1E3OuUBpb4aFpGq+++ioCAgJwzz33YOjQoWxsuaO8HW07QxNydeO3bpY7\n5fhk3hq1qLWNlewQFTMHOrMtFKN+9OhRdOnSxcrNwhfF4oqLxV+E3NdFvE66WQD/6Wmvqyjt2lAK\nd7tbpKS1WCw4deqU0+kEXMFfRFaN95KS+LVlzinPJ/PW+Bs1trOSw/7FbttOC0CSJGbOnMn6yZct\nW8b61wHwWujc/VzE7lMafynDE9RZy1xJHA2wUOuNotZ6CeHsNV9t1+POOonJlyRJHDp0CGvWrMGK\nFStw6dIlbNiwAQ888AAoirJzzXBDFsWUpxaRdbUe3rhvvGIk1wXL/E6ZLp0vpvNKbdajmjsS+RBb\nXzVdE03ToChK1rlSrHOuKAcGBsJsNuOxxx7DoUOHUFRUBACgKArR0dEAgMuXL8NsNoOiKDYChvGn\nm81mds4XBlc7R+UgJZ7dlU5nb+Cu355mmXsItVmO/oq/trPQddmKenV1NSoqKrBs2TJ2uluLxYKa\nmhoUFBSgqKgILVq0QEhICMrLy5GQkIAff/yRneNFbj3+v52zi2nqigP4abVmE0mNrlxYL0lL05bv\n2wvFbg5mGAIaYUrACCZ1kYQXlzhd0gF7cS/SAjFGEvdCZG7Losl0M+AsX0HSBhwIbYfYUUWusUWo\ngFahRvp19uDu0lVd1Lj2UM8v+T/c09vc37n39n9O/vfcvknC8cJRtN4nL+KtmZn/fdzX/u6rjLSo\nzByjdWYeTKT7FwgEXjpJhvKyb4KGlkqam5sBn88HXC4X1NTUPFM24XA4gMfjAb/fD3JycsDIyAgA\nAACfzwcghMDr9f5rZh7uWfnrLIl8lfOLQhKPxMz8rUrmGAwGs9JBKpljMBgM5s2Ca+YYDAYTBeBk\njsFgMFFA2JN5Z2fntuTk5AmpVHqzsbGxNtzHfx7V1dVtBEE4MzIyrrFt9+/f31BYWNgjk8luFBUV\ndbtcrvXsZ1qttl4qld5MTk6e6O7uLoqEs91uT8zPz7+clpZ2PT09fbylpeUgyt5Pnjx5R6VSDSkU\nCktqaqq1vr5ei7JvMH6/fxVN0+bS0tKOleAsEoluZ2ZmjtE0bd60adMw6s4ul2t9RUXFuZSUlD9T\nU1OtQ0NDKpR9bTabnKZpMxt8Pv9hS0vLwYg7h/4z2/8ZPp9vlUQimWQYRuTxeHgURVmsVmtKOB2e\nFwaDIc9kMtHp6enX2DaNRtPU2Nj4FYQQ6HS62traWh2EEFy/fj2VoiiLx+PhMQwjkkgkk36/nxtu\n55mZmXiz2ayAEILFxcV1MpnMZrVaU1D2drvdayGEwOv1rlapVL8bjcZclH3ZOHbs2Jd79+79qbS0\ntH0l3BsikYhZWFjYENyGsvO+ffu+P3XqVDV7b7hcLj7KvsHh9/u58fHxM3fu3EmMtHNYOz44OPhh\ncXFxJ7ut1WrrtFptXaQuRHAwDCMKTuZyuXxidnaWgPBp4pTL5RMQQtDQ0FCv0+lq2f2Ki4s7r1y5\n8kGk/Xfu3Hmhp6dn60rwdrvda5VK5dXx8fE01H3tdjtZUFDQ29fXl19SUtKxEu4NkUjEzM/Pbwxu\nQ9XZ5XLxxWLxVGg7qr6h0dXVVZSbm2tEwTmsZZbp6WlhYmKind0mSdIxPT0tDKfDy+J0OgmCIJwA\nAEAQhNPpdBIAAHD37t33SZJ0sPuh0Ifbt2+LzGYzrVKphlD2DgQCXIVCYSEIwsmWiFD2BQCAw4cP\nH29ubtZwudx/FnOj7szhcODWrVt7lUrlSGtraw3KzgzDiAUCwdz+/fu/y8rKMtXU1LS63e4YVH1D\nOXv2bGVVVdUZACJ/jsOazFfq+nIOhwP/yz2S/VpaWlpXXl5+/sSJE1/ExsYuhnqh5M3lcgMWi0Xh\ncDhIg8Hw8eXLl/NDfVDyvXjxYklcXNw9mqbN8EVrexFzBgCAgYGBj8xmM63X67efPHnyc6PRmBfq\nhIqzz+dbbTKZsg4cOPCtyWTKiomJcet0urpQH1R8g/F4PGs6OjpKd+/e/fPznMLtHNZkLhQKp+12\neyK7bbfbE4NHLJQgCMI5OzsbDwAAMzMzCXFxcfcAeLYPDoeDFAqF05Fw9Hq9vPLy8vNqtfrHXbt2\nXVgp3nw+/+GOHTt+Gx0dzUbZd3BwcHN7e/unYrGYqaqqOtPX1/eJWq3+EWVnAABISEiYAQAAgUAw\nV1ZW9uvw8PAmVJ1JknSQJOnIycm5CgAAFRUV50wmU1Z8fPwsir7B6PX67dnZ2aMCgWAOAAR+e+Gs\nL3m93tVJSUm3GIYRLS8vr0HlASiEz9bMNRpNE1vn0mq1daEPM5aXl9dMTU2Jk5KSbgUCAU64fQOB\nAEetVv9w6NCh48HtqHrPzc299+DBg/UQQvD48eN38/LyDL29vQWo+oZGf3//FrZmjrKz2+1e++jR\no1gIIVhaWorZvHnzQFdXVxHKznl5eQabzSaDEIIjR458o9FomlD2ZWPPnj1nT58+/Rm7HWnnsJ+A\nS5cubZfJZDaJRDLZ0NBQH4mLEBqVlZVnEhIS7vJ4PA9Jkva2trb9CwsLGwoKCnqlUumNwsLCbjYR\nQQjB0aNHv5ZIJJNyuXyis7OzOBLORqMxl8PhBCiKsigUCrNCoTDr9fptqHqPjY1l0DRtoijKkpGR\nMdbU1KSBEAJUfUOjv79/C7uaBWXnqakpMUVRFoqiLGlpaePsbwxlZ4vFQimVyquZmZl/lJWV/eJy\nufgo+0L4dKDcuHHjPDtwonCO8ev8GAwGEwXgN0AxGAwmCsDJHIPBYKIAnMwxGAwmCsDJHIPBYKIA\nnMwxGAwmCsDJHIPBYKKAvwD4Z0qY+Ivr7AAAAABJRU5ErkJggg==\n",
       "text": [
        "<matplotlib.figure.Figure at 0x1078e8e50>"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 loops, best of 3: 40.2 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit create_fractal.py_func(-2.0, 1.0, -1.0, 1.0, image, 20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 loops, best of 3: 403 ms per loop\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "403/ 40.2 # speedup of compiling outer-loop (inner-loop mandel call is still optimized)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 18,
       "text": [
        "10.024875621890546"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "create_fractal.inspect_types()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "create_fractal (float64, float64, float64, float64, array(uint8, 2d, C), int64)\n",
        "--------------------------------------------------------------------------------\n",
        "# File: <ipython-input-28-9e763decef92>\n",
        "# --- LINE 18 --- \n",
        "\n",
        "@autojit\n",
        "\n",
        "# --- LINE 19 --- \n",
        "\n",
        "def create_fractal(min_x, max_x, min_y, max_y, image, iters):\n",
        "\n",
        "    # --- LINE 20 --- \n",
        "    # label 0\n",
        "    #   min_x.1 = min_x  :: float64\n",
        "    #   max_x.1 = max_x  :: float64\n",
        "    #   min_y.1 = min_y  :: float64\n",
        "    #   max_y.1 = max_y  :: float64\n",
        "    #   image.1 = image  :: array(uint8, 2d, C)\n",
        "    #   iters.1 = iters  :: int64\n",
        "    #   $0.2 = getattr(attr=shape, value=image.1)  :: (int64 x 2)\n",
        "    #   $const0.3 = const(int, 0)  :: int32\n",
        "    #   $0.4 = getitem(index=$const0.3, value=$0.2)  :: int64\n",
        "    #   height = $0.4  :: int64\n",
        "\n",
        "    height = image.shape[0]\n",
        "\n",
        "    # --- LINE 21 --- \n",
        "    #   $0.6 = getattr(attr=shape, value=image.1)  :: (int64 x 2)\n",
        "    #   $const0.7 = const(int, 1)  :: int32\n",
        "    #   $0.8 = getitem(index=$const0.7, value=$0.6)  :: int64\n",
        "    #   width = $0.8  :: int64\n",
        "\n",
        "    width = image.shape[1]\n",
        "\n",
        "# --- LINE 22 --- \n",
        "\n",
        "\n",
        "\n",
        "    # --- LINE 23 --- \n",
        "    #   $0.11 = max_x.1 - min_x.1  :: float64\n",
        "    #   $0.13 = $0.11 /? width  :: float64\n",
        "    #   pixel_size_x = $0.13  :: float64\n",
        "\n",
        "    pixel_size_x = (max_x - min_x) / width\n",
        "\n",
        "    # --- LINE 24 --- \n",
        "    #   $0.16 = max_y.1 - min_y.1  :: float64\n",
        "    #   $0.18 = $0.16 /? height  :: float64\n",
        "    #   pixel_size_y = $0.18  :: float64\n",
        "\n",
        "    pixel_size_y = (max_y - min_y) / height\n",
        "\n",
        "    # --- LINE 25 --- \n",
        "    #   jump 54\n",
        "    # label 67\n",
        "    #   $67.1 = iternext(value=$54.4)  :: pair<int64, bool>\n",
        "    #   $67.2 = pair_first(value=$67.1)  :: int64\n",
        "    #   $67.3 = pair_second(value=$67.1)  :: bool\n",
        "    #   $phi70.1 = $67.2  :: int64\n",
        "    #   branch $67.3, 70, 161\n",
        "    # label 70\n",
        "    #   x = $phi70.1  :: int64\n",
        "    # label 54\n",
        "    #   $54.1 = global(range: <built-in function range>)  :: range\n",
        "    #   $54.3 = call $54.1(width, )  :: (int64,) -> range_state64\n",
        "    #   $54.4 = getiter(value=$54.3)  :: range_iter64\n",
        "    #   jump 67\n",
        "\n",
        "    for x in range(width):\n",
        "\n",
        "        # --- LINE 26 --- \n",
        "        #   $70.5 = x * pixel_size_x  :: float64\n",
        "        #   $70.6 = min_x.1 + $70.5  :: float64\n",
        "        #   real = $70.6  :: float64\n",
        "\n",
        "        real = min_x + x * pixel_size_x\n",
        "\n",
        "        # --- LINE 27 --- \n",
        "        # label 100\n",
        "        #   $100.1 = iternext(value=$87.4)  :: pair<int64, bool>\n",
        "        #   $100.2 = pair_first(value=$100.1)  :: int64\n",
        "        #   $100.3 = pair_second(value=$100.1)  :: bool\n",
        "        #   $phi103.1 = $100.2  :: int64\n",
        "        #   branch $100.3, 103, 157\n",
        "        #   jump 87\n",
        "        # label 103\n",
        "        #   y = $phi103.1  :: int64\n",
        "        # label 87\n",
        "        #   $87.1 = global(range: <built-in function range>)  :: range\n",
        "        #   $87.3 = call $87.1(height, )  :: (int64,) -> range_state64\n",
        "        #   $87.4 = getiter(value=$87.3)  :: range_iter64\n",
        "        #   jump 100\n",
        "\n",
        "        for y in range(height):\n",
        "\n",
        "            # --- LINE 28 --- \n",
        "            #   $103.5 = y * pixel_size_y  :: float64\n",
        "            #   $103.6 = min_y.1 + $103.5  :: float64\n",
        "            #   imag = $103.6  :: float64\n",
        "\n",
        "            imag = min_y + y * pixel_size_y\n",
        "\n",
        "            # --- LINE 29 --- \n",
        "            #   $103.7 = global(mandel: CPUOverloaded(<function mandel at 0x10787b668>))  :: Dispatcher(CPUOverloaded(<function mandel at 0x10787b668>))\n",
        "            #   $103.11 = call $103.7(real, imag, iters.1, )  :: (float64, float64, int64) -> int64\n",
        "            #   color = $103.11  :: int64\n",
        "\n",
        "            color = mandel(real, imag, iters)\n",
        "\n",
        "            # --- LINE 30 --- \n",
        "            # label 161\n",
        "            #   del $54.4\n",
        "            #   $103.16 = build_tuple(items=[Var(y, <ipython-input-28-9e763decef92> (27)), Var(x, <ipython-input-28-9e763decef92> (25))])  :: (int64 x 2)\n",
        "            #   image.1[$103.16] = color  :: (array(uint8, 2d, C), (int64 x 2), uint8) -> none\n",
        "            #   jump 100\n",
        "            # label 157\n",
        "            #   del $87.4\n",
        "            #   jump 158\n",
        "            # label 158\n",
        "            #   jump 67\n",
        "\n",
        "            image[y, x] = color\n",
        "\n",
        "# --- LINE 31 --- \n",
        "\n",
        "\n",
        "\n",
        "    # --- LINE 32 --- \n",
        "    #   jump 162\n",
        "    # label 162\n",
        "    #   return image.1\n",
        "\n",
        "    return image\n",
        "\n",
        "\n",
        "================================================================================\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Numba works very well for numerical calculations and infers types for variables.  You can over-ride this inference by passing in a locals dictionary to the autojit decorator.   Notice how the code below shows both Python object manipulation and native manipulation"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MyClass(object):\n",
      "    def mymethod(self, arg):\n",
      "        return arg * 2\n",
      "    \n",
      "@autojit(locals=dict(mydouble=double)) # specify types for local variables\n",
      "def call_method(obj):\n",
      "    print obj.mymethod(\"hello\")   # object result\n",
      "    mydouble = obj.mymethod(10.2) # native double\n",
      "    print(mydouble * 2)           # native multiplication\n",
      "    \n",
      "call_method(MyClass())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "hellohello\n",
        "\n",
        "40.8\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Complex support is available as well."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@autojit\n",
      "def complex_support(real, imag):\n",
      "    c = complex(real, imag)\n",
      "    return (c ** 2).conjugate()\n",
      "\n",
      "c = 2.0 + 4.0j\n",
      "complex_support(c.real, c.imag), (c**2).conjugate()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 25,
       "text": [
        "((-12-16j), (-12-16j))"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The roadmap for Numba includes better error-handling, support for almost all Python syntax which gets compiled to code that either uses machine instructions or else the Python library run-time, improved support for basic types, and the ability to create objects easily. "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The commercial product NumbaPro includes additional features:\n",
      "\n",
      "* ability to create ufuncs (fast-vectorize)\n",
      "* ability to target the GPU via CUDA\n",
      "* ability to target multiple-cores  \n",
      "* array-expressions (ability to write NumPy-like code that gets compiled)"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}