Ray Tracing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Raytracing\n",
    "\n",
    "The goal of this worksheet is for you to write a simple raytracer. That is, a program that takes a 3D model and generates an image of what it looks like from a particular camera angle (this is called _rendering_). In this case the 3D model will be represented by a _signed distance function_, which makes rendering particularly easy.\n",
    "\n",
    "The purpose of this worksheet is to learn to __vectorise__ your code. As such, not only do you not need to know how raytracing works, but the _answer is provided_. The challenge is that the answer is provided as unvectorised per-pixel code, and you only get marks for a vectorised implementation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Marking and submission\n",
    "\n",
    "These lab exercises are marked, and contribute to your final grade. This lab exercise has 20 marks to earn, equivalent to 12% of your final grade. Most of the time where you have to add code is indicated by\n",
    "\n",
    "`# **************************************************************** 2 marks`\n",
    "\n",
    "with instructions above the code block. Occasionally a markdown block will request that you return to an early block and edit it. There will be no indicator in such cases.\n",
    "\n",
    "Please submit your completed workbook to the auto marker before 2021-11-14 20:00 GMT. The workbook you submit must be an .ipynb file, which is saved into the directory you're running Jupyter; alternatively you can download it from the menu above using `File -> Download As -> Notebook (.ipynb)`. Remember to save your work regularly (`Save and checkpoint` in the `File` menu, the icon of a floppy disk, or `Ctrl-S`). It is wise to verify it runs to completion with _Restart & Run All_ before submission.\n",
    "\n",
    "You must comply with the universities plagiarism guidelines: http://www.bath.ac.uk/library/help/infoguides/plagiarism.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Raytracing with Ray Marching\n",
    "\n",
    "Real light gets emitted from a light source and then bounces from surface to surface around the world. Some of it may hit a camera, where it is absorbed and generates an electrical current, which is interpreted as an image. For instance, a ray of light may be emitted from the sun, hurtle across the vacume for 8 minutes and 19 seconds before descending through the atmosphere to strike a kitten on the head. The light then bounces off the kittens hair and into a camera, just so you can waste your time looking at cute cat images on the internet (Note: It's actually far more complicated than this. For one thing most 'bounces' are actually the light being absorbed then emitted again.).\n",
    "\n",
    "Raytracing simulates this, but backwards for efficiency. We don't care about rays that never strike the camera. For the purpose of this exercise we are only going to simulate a single step. Our output image is a 2D grid of pixels. For each pixel a ray is fired out towards the scene. It will either miss all of the geometry and fly towards infinity, or it will strike the surface of an object. We can then measure the length of the ray and output a _depth map_, an image colour coded with the depth of each pixel.\n",
    "\n",
    "Each ray is represented by three pieces of information:\n",
    " * It's starting location, a coordinate (length 3 vector). In effect, the location of the pixel on the sensor inside the virtual camera.\n",
    " * It's direction of travel, a normal, that is a length 3 vector with unit length.\n",
    " * How far it has travelled, a scalar.\n",
    " \n",
    "This means we can work out where the end of the ray is as\n",
    "\n",
    "`end = start + travel * normal`\n",
    "\n",
    "The main challenge of raytracing is _collision detection_, that is detecting how far a ray can travel before it collides with a surface. Computer games mostly cheat, for speed; rendering for film vfx uses ray/triangle interactions with dense 3D geometry, combined with complex data structures for speed. We're going to do something completely different, that is most commonly used to optimise collision detection in physics simulations rather than rendering. A __signed distance function__ (sdf) tells you for every location how far you are from a surface. Imagine placing a sphere at the end of a ray and making it as large as possible before it touches the surface of an object. Its radius is the distance returned by the _sdf_ at the end of the ray. The distance is positive if you're outside an object, but negated if you're inside an object; the surface of an object in a _sdf_ is hence the _isosurface_ or _level set_ with value zero.\n",
    "\n",
    "To collide a ray with a _sdf_ you repeat a simple process: evaluate the sdf at the current end point of the ray then move that far. If the ray is fired directly at the surface you will immediately collide, and the next time you evaluate the _sdf_ you will get $0$, and stop moving. Normally rays make glancing blows, and over many iterations get a little closer each time, until they stop moving on the surface of the object. This is the _ray marching algorithm_.\n",
    "\n",
    "There are many ways to represent a _sdf_. The _sdf_ for a sphere is entirely analytic for instance - just the distance from the centre minus the radius. In this case we will be using _voxels_, quite simply a 3D array representing space, so indexed with 3D coordinates `[x,y,z]`, where the _sdf_ has been evaluated and stored in every cell. One has been provided on moodle (as a .hdf5 file) for you to download and render.\n",
    "\n",
    "Here is an alternate explanation: http://jamie-wong.com/2016/07/15/ray-marching-signed-distance-functions/ (There are a couple cool videos showing how far this idea can be pushed, plus a more visual explanation; goes far beyond the below however)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports\n",
    "\n",
    "As you have seen before. h5py allows hdf5 files to be loaded, so you have a signed distance function to render."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "It's typical to have a block at the start of a Jupyter workbook to set some parameters. Here we have the resolution of the output image (1024 X 429 is half of DCI 2K Cinemascope, one of the standards for displaying films) and the _field of view_ (fov), which is a standard way of specifying how wide/zoomed in a camera lens is. 24mm is a fairly wide angle lens - this is a good choice for a distance map as we can't see the surface, only depth, which is exaggerated by a wide lens.\n",
    "\n",
    "In addition the hdf5 file is loaded and the sdf function extracted as a numpy array. There are a number of sdf function files provided; feel free to try them all out ('Restart and Run All' in the kernel menu can be useful for this). It's wise to keep the below setup until you have a working system however and submit with the dragon enabled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sdf shape = (57, 90, 128)\n"
     ]
    }
   ],
   "source": [
    "# Parameters...\n",
    "width = 1024\n",
    "height = 429\n",
    "\n",
    "fov = 24.0\n",
    "\n",
    "with h5py.File('dragon.hdf5', 'r') as f:\n",
    "    sdf = numpy.array(f['sdf'])\n",
    "\n",
    "print('sdf shape =', sdf.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start of Rays\n",
    "\n",
    "Coordinates on a computer are represented at (x, y, z), but when images are stored in arrays they are indexed (y, x). This is more than a little confusing, but the convention we will be using for consistency with everyone else.\n",
    "\n",
    "Your first task is to define the _start_ and _normal_ of each pixel in the image. The x values are stored in `start[:,:,0]`, the y values in `start[:,:,1]` and the z values in `start[:,:,2]`.\n",
    "The code you need to vectorise is (`u` is the x coordinate in the image, `v` the y coordinate, to avoid confusion with the 3D coordinates being written):\n",
    "```\n",
    "for v in range(height):\n",
    "  for u in range(width):\n",
    "    start[v,u,0] = -0.5 + u / (width-1)\n",
    "    start[v,u,1] = (-0.5 + v / (height-1)) * height / width\n",
    "    start[v,u,2] = 0\n",
    "```\n",
    "\n",
    "In effect, these are the coordinates of the pixels on the virtual charged coupled device that is the imaging sensor. The slickest solution makes use of [`numpy.linspace()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html) (clickable link to numpy help). Remember that you only get marks for a vectorised solution!\n",
    "\n",
    "__(2 marks)__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[-0.5       , -0.20947266,  0.        ],\n",
       "        [-0.49902248, -0.20947266,  0.        ],\n",
       "        [-0.49804497, -0.20947266,  0.        ],\n",
       "        ...,\n",
       "        [ 0.49804497, -0.20947266,  0.        ],\n",
       "        [ 0.49902248, -0.20947266,  0.        ],\n",
       "        [ 0.5       , -0.20947266,  0.        ]],\n",
       "\n",
       "       [[-0.5       , -0.20849381,  0.        ],\n",
       "        [-0.49902248, -0.20849381,  0.        ],\n",
       "        [-0.49804497, -0.20849381,  0.        ],\n",
       "        ...,\n",
       "        [ 0.49804497, -0.20849381,  0.        ],\n",
       "        [ 0.49902248, -0.20849381,  0.        ],\n",
       "        [ 0.5       , -0.20849381,  0.        ]],\n",
       "\n",
       "       [[-0.5       , -0.20751497,  0.        ],\n",
       "        [-0.49902248, -0.20751497,  0.        ],\n",
       "        [-0.49804497, -0.20751497,  0.        ],\n",
       "        ...,\n",
       "        [ 0.49804497, -0.20751497,  0.        ],\n",
       "        [ 0.49902248, -0.20751497,  0.        ],\n",
       "        [ 0.5       , -0.20751497,  0.        ]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[-0.5       ,  0.20751497,  0.        ],\n",
       "        [-0.49902248,  0.20751497,  0.        ],\n",
       "        [-0.49804497,  0.20751497,  0.        ],\n",
       "        ...,\n",
       "        [ 0.49804497,  0.20751497,  0.        ],\n",
       "        [ 0.49902248,  0.20751497,  0.        ],\n",
       "        [ 0.5       ,  0.20751497,  0.        ]],\n",
       "\n",
       "       [[-0.5       ,  0.20849381,  0.        ],\n",
       "        [-0.49902248,  0.20849381,  0.        ],\n",
       "        [-0.49804497,  0.20849381,  0.        ],\n",
       "        ...,\n",
       "        [ 0.49804497,  0.20849381,  0.        ],\n",
       "        [ 0.49902248,  0.20849381,  0.        ],\n",
       "        [ 0.5       ,  0.20849381,  0.        ]],\n",
       "\n",
       "       [[-0.5       ,  0.20947266,  0.        ],\n",
       "        [-0.49902248,  0.20947266,  0.        ],\n",
       "        [-0.49804497,  0.20947266,  0.        ],\n",
       "        ...,\n",
       "        [ 0.49804497,  0.20947266,  0.        ],\n",
       "        [ 0.49902248,  0.20947266,  0.        ],\n",
       "        [ 0.5       ,  0.20947266,  0.        ]]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Start position\n",
    "start = numpy.zeros((height, width, 3))\n",
    "w_ls=numpy.linspace(-0.5,0.5,width)\n",
    "h_ls=numpy.linspace(-0.5,0.5,height)*height/width\n",
    "\n",
    "start_d0=numpy.array([w_ls]*height).reshape(height*width,1)\n",
    "start_d1=numpy.transpose(numpy.transpose(numpy.array([h_ls]*width).reshape(width,height)).reshape(1,height*width))\n",
    "start_d2=numpy.zeros(height*width).reshape(height*width,1)\n",
    "\n",
    "start=numpy.append(numpy.append(start_d0,start_d1,axis=1),start_d2,axis=1).reshape(height,width,3)\n",
    "start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Direction of Rays\n",
    "\n",
    "The normal of a pixel is the unit length vector from the origin of the camera through the pixel. In this case the origin is:\n",
    "\n",
    "`origin = (0, 0, -fov / 36.0)`\n",
    "\n",
    "(If you're wondering where the 36 came from, the fov is given relative to 35mm film, which is 35mm high _including the notches_, with 24mm allocated for the height of each image. The images themselves are then 36mm across.)\n",
    "\n",
    "The direction for each pixel is `direction = start - origin`. This needs to be normalised, that is the direction vector has to be divided by it's length, which may be calculated as\n",
    "\n",
    "`length = numpy.sqrt(numpy.square(direction).sum())`\n",
    "\n",
    "To be super explicit, the full code without vectorisation looks like:\n",
    "```\n",
    "for v in range(height):\n",
    "  for u in range(width):\n",
    "    len_sqr = 0.0\n",
    "    for d in range(3): # 3 dimensions\n",
    "      norm[v, u, d] = start[v, u, d] - origin[d]\n",
    "      len_sqr += norm[v, u, d]**2\n",
    "      \n",
    "    length = numpy.sqrt(len_sqr)\n",
    "    for d in range(3):\n",
    "      norm[v, u, d] /= length\n",
    "```\n",
    "\n",
    "Don't forget about the `axis` keyword of [`sum()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html#numpy.sum) for vectorising the length calculation.\n",
    "\n",
    "__(2 marks)__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[-0.58189783, -0.24378337,  0.77586377],\n",
       "        [-0.58114466, -0.24394475,  0.77637739],\n",
       "        [-0.58038999, -0.24410614,  0.77689102],\n",
       "        ...,\n",
       "        [ 0.58038999, -0.24410614,  0.77689102],\n",
       "        [ 0.58114466, -0.24394475,  0.77637739],\n",
       "        [ 0.58189783, -0.24378337,  0.77586377]],\n",
       "\n",
       "       [[-0.58205912, -0.24271145,  0.77607882],\n",
       "        [-0.58130595, -0.24287221,  0.77659287],\n",
       "        [-0.58055129, -0.24303298,  0.77710693],\n",
       "        ...,\n",
       "        [ 0.58055129, -0.24303298,  0.77710693],\n",
       "        [ 0.58130595, -0.24287221,  0.77659287],\n",
       "        [ 0.58205912, -0.24271145,  0.77607882]],\n",
       "\n",
       "       [[-0.58221978, -0.24163864,  0.77629304],\n",
       "        [-0.58146662, -0.24179878,  0.77680752],\n",
       "        [-0.58071196, -0.24195893,  0.777322  ],\n",
       "        ...,\n",
       "        [ 0.58071196, -0.24195893,  0.777322  ],\n",
       "        [ 0.58146662, -0.24179878,  0.77680752],\n",
       "        [ 0.58221978, -0.24163864,  0.77629304]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[-0.58221978,  0.24163864,  0.77629304],\n",
       "        [-0.58146662,  0.24179878,  0.77680752],\n",
       "        [-0.58071196,  0.24195893,  0.777322  ],\n",
       "        ...,\n",
       "        [ 0.58071196,  0.24195893,  0.777322  ],\n",
       "        [ 0.58146662,  0.24179878,  0.77680752],\n",
       "        [ 0.58221978,  0.24163864,  0.77629304]],\n",
       "\n",
       "       [[-0.58205912,  0.24271145,  0.77607882],\n",
       "        [-0.58130595,  0.24287221,  0.77659287],\n",
       "        [-0.58055129,  0.24303298,  0.77710693],\n",
       "        ...,\n",
       "        [ 0.58055129,  0.24303298,  0.77710693],\n",
       "        [ 0.58130595,  0.24287221,  0.77659287],\n",
       "        [ 0.58205912,  0.24271145,  0.77607882]],\n",
       "\n",
       "       [[-0.58189783,  0.24378337,  0.77586377],\n",
       "        [-0.58114466,  0.24394475,  0.77637739],\n",
       "        [-0.58038999,  0.24410614,  0.77689102],\n",
       "        ...,\n",
       "        [ 0.58038999,  0.24410614,  0.77689102],\n",
       "        [ 0.58114466,  0.24394475,  0.77637739],\n",
       "        [ 0.58189783,  0.24378337,  0.77586377]]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Direction\n",
    "origin = (0, 0, -fov / 36.0)\n",
    "norm = numpy.empty((height, width, 3))\n",
    "origin=numpy.array(origin*(height*width)).reshape(height,width,3)\n",
    "direction = start - origin\n",
    "length = numpy.sqrt(numpy.square(direction).sum(axis=2)).reshape(height,width,1)\n",
    "norm=numpy.divide(direction,length) # normalisation\n",
    "norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Move and rotate into position\n",
    "\n",
    "The camera has been setup at the origin of the 3D space, at the same location as the object we have loaded. This is not going to make for a very good render, as ray marching inside an object gets weird fast. It's a bit like squishing your mobile phone into someone's face and expecting to get a lovely photo. We need to move the camera (the `start` and `norm` arrays) to get a better view of the object:\n",
    " * Move the camera back the right distance to see the entire object.\n",
    " * Rotate 30 degrees around the x-axis.\n",
    " * Rotate 45 degrees around the y-axis.\n",
    "\n",
    "You can try alternate values later, but the above values should be used until you get your code working, to avoid the risk you point the camera out into space and can't see the object at all. This is also what the auto marker will check for, so make that happy first!\n",
    "\n",
    "\n",
    "\n",
    "### Moving back\n",
    "\n",
    "You should subtract `2 * (max(sdf.shape) * fov) / 36` from the `z` coordinate of each pixels start location (an offset does not affect the normals, as they encode orientation only). Explicitly:\n",
    "```\n",
    "delta = 2 * (max(sdf.shape) * fov) / 36\n",
    "for v in range(height):\n",
    "  for u in range(width):\n",
    "    start[v,u,2] -= delta\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "### Rotation 1\n",
    "\n",
    "A rotation around the x-axis is a multiplication by the matrix (right multiplication, as in matrix * vector)\n",
    "```\n",
    "[1.0, 0.0, 0.0],\n",
    "[0.0,   c,   s],\n",
    "[0.0,  -s,   c]\n",
    "```\n",
    "where, for a 30 degree rotation,\n",
    "```\n",
    "s = numpy.sin(numpy.pi * 30 / 180)\n",
    "c = numpy.cos(numpy.pi * 30 / 180)\n",
    "```\n",
    "Both the `start` and `norm` vector of each pixel need to be multiplied. Explicitely, assuming the above matrix is called `rot`:\n",
    "```\n",
    "for v in range(height):\n",
    "  for u in range(width):\n",
    "    for arr in [start, norm]: # Loop the arrays to transform - reduces duplication!\n",
    "      x = arr[v,u,0]\n",
    "      y = arr[v,u,1]\n",
    "      z = arr[v,u,2]\n",
    "    \n",
    "      for d in range(3):\n",
    "        arr[v,u,d] = rot[d,0] * x + rot[d,1] * y + rot[d,2] * z\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "### Rotation 2\n",
    "\n",
    "A rotation around the y-axis is a (right) multiplication by the matrix\n",
    "```\n",
    "[  c, 0.0,   s],\n",
    "[0.0, 1.0, 0.0],\n",
    "[ -s, 0.0,   c]\n",
    "```\n",
    "where, for a 45 degree rotation,\n",
    "```\n",
    "s = numpy.sin(numpy.pi * 45 / 180)\n",
    "c = numpy.cos(numpy.pi * 45 / 180)\n",
    "```\n",
    "Both the `start` and `norm` vector of each pixel need to be multiplied. The code is identical to the previous rotation, just with this different matrix.\n",
    "\n",
    "__(5 marks)__\n",
    " * Note that 1 mark is reserved for using `numpy.einsum()` to do the rotations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0.14984412,  0.1768093 ,  0.97277192],\n",
       "        [ 0.15074828,  0.17692634,  0.97261093],\n",
       "        [ 0.1516535 ,  0.17704339,  0.97244889],\n",
       "        ...,\n",
       "        [ 0.97244889,  0.17704339,  0.1516535 ],\n",
       "        [ 0.97261093,  0.17692634,  0.15074828],\n",
       "        [ 0.97277192,  0.1768093 ,  0.14984412]],\n",
       "\n",
       "       [[ 0.14948279,  0.17784513,  0.97263868],\n",
       "        [ 0.15038698,  0.17796293,  0.97247774],\n",
       "        [ 0.15129224,  0.17808073,  0.97231575],\n",
       "        ...,\n",
       "        [ 0.97231575,  0.17808073,  0.15129224],\n",
       "        [ 0.97247774,  0.17796293,  0.15038698],\n",
       "        [ 0.97263868,  0.17784513,  0.14948279]],\n",
       "\n",
       "       [[ 0.14912107,  0.17888132,  0.97250418],\n",
       "        [ 0.1500253 ,  0.17899987,  0.97234328],\n",
       "        [ 0.1509306 ,  0.17911842,  0.97218133],\n",
       "        ...,\n",
       "        [ 0.97218133,  0.17911842,  0.1509306 ],\n",
       "        [ 0.97234328,  0.17899987,  0.1500253 ],\n",
       "        [ 0.97250418,  0.17888132,  0.14912107]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[-0.02174325,  0.59741172,  0.80163986],\n",
       "        [-0.02095226,  0.59780764,  0.80136572],\n",
       "        [-0.0201602 ,  0.59820358,  0.80109054],\n",
       "        ...,\n",
       "        [ 0.80109054,  0.59820358, -0.0201602 ],\n",
       "        [ 0.80136572,  0.59780764, -0.02095226],\n",
       "        [ 0.80163986,  0.59741172, -0.02174325]],\n",
       "\n",
       "       [[-0.02214013,  0.59823369,  0.80101577],\n",
       "        [-0.02134961,  0.59862994,  0.80074115],\n",
       "        [-0.02055803,  0.5990262 ,  0.80046548],\n",
       "        ...,\n",
       "        [ 0.80046548,  0.5990262 , -0.02055803],\n",
       "        [ 0.80074115,  0.59862994, -0.02134961],\n",
       "        [ 0.80101577,  0.59823369, -0.02214013]],\n",
       "\n",
       "       [[-0.02253675,  0.59905447,  0.80039105],\n",
       "        [-0.02174671,  0.59945104,  0.80011595],\n",
       "        [-0.02095561,  0.59984763,  0.79983979],\n",
       "        ...,\n",
       "        [ 0.79983979,  0.59984763, -0.02095561],\n",
       "        [ 0.80011595,  0.59945104, -0.02174671],\n",
       "        [ 0.80039105,  0.59905447, -0.02253675]]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# translation\n",
    "delta = 2 * (max(sdf.shape) * fov) / 36\n",
    "back=(0,0,-delta)\n",
    "start=start+numpy.array(back*(height*width)).reshape(height,width,3)\n",
    "\n",
    "# rotate about x-axis\n",
    "s_x = numpy.sin(numpy.pi * 30 / 180)\n",
    "c_x = numpy.cos(numpy.pi * 30 / 180)\n",
    "R1=numpy.array([[1.0,0.0,0.0], [0.0,c_x,s_x], [0.0,-s_x,c_x]])\n",
    "\n",
    "start=numpy.einsum('ijk,lk->ijl',start,R1)\n",
    "norm=numpy.einsum('ijk,lk->ijl',norm,R1)\n",
    "\n",
    "# rotate about y-axis\n",
    "s_y = numpy.sin(numpy.pi * 45 / 180)\n",
    "c_y = numpy.cos(numpy.pi * 45 / 180)\n",
    "R2=numpy.array([[c_y,0.0,s_y],[0.0,1.0,0.0],[-s_y,0.0,c_y]])\n",
    "\n",
    "start=numpy.einsum('ijk,lk->ijl',start,R2)\n",
    "norm=numpy.einsum('ijk,lk->ijl',norm,R2)\n",
    "\n",
    "norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Firing Rays\n",
    "\n",
    "Your task is to fill in the below function, finishing the renderer - given the current state of start, norm and travel for every pixel you need to evaluate the _signed distance function_ at the end of each ray. This means you need to vectorise the following:\n",
    "```\n",
    "ret = numpy.zeros(start.shape[:2])\n",
    "for v in range(height):\n",
    "  for u in range(width):\n",
    "    # Get end of ray and round to sdf array coordinate...\n",
    "    pos = start[v,u,:] + travel[v,u] * norm[v,u,:]\n",
    "    pos += 0.5 * numpy.array(sdf.shape) # Center of sdf to 3D origin\n",
    "    sdf_coordinate = (pos+0.5).astype(int)\n",
    "    \n",
    "    # Loop the 3 dimensions and check each is not out of bounds...\n",
    "    for d in range(3): \n",
    "      if sdf_coordinate[d]<0:\n",
    "        sdf_coordinate[d] = 0\n",
    "      if sdf_coordinate[d]>=sdf.shape[d]:\n",
    "        sdf_coordinate[d] = sdf.shape[d] - 1\n",
    "    \n",
    "    # Evaluate function...\n",
    "    ret[v,u] = sdf[sdf_coordinate[0], sdf_coordinate[1], sdf_coordinate[2]]\n",
    "```\n",
    "\n",
    "Note that the [`astype()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.astype.html) method above is a real numpy method you can call. The `+0.5` is because conversion to an integer always rounds down - by adding `0.5` you get more traditional rounding behaviour.\n",
    "\n",
    "Below the function the ray marching algorithm has been provided - it's pretty simple!\n",
    "\n",
    "__(5 marks)__\n",
    " * You are allowed one loop over the dimensions (a loop over just 3 items isn't worth optimising - the point is to vectorise loops that go around 100s of times). Any more than that and you will lose marks!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5218.29418945, 5218.86447906, 5218.8816185 , ..., 4524.73806763,\n",
       "        4518.28198624, 4516.15455723],\n",
       "       [5217.99403572, 5218.43806458, 5218.691082  , ..., 4517.85720062,\n",
       "        4516.00814056, 4509.66106033],\n",
       "       [5219.55341339, 5218.97557259, 5219.60873985, ..., 4515.59083176,\n",
       "        4512.10440636, 4507.94093418],\n",
       "       ...,\n",
       "       [4993.90895748, 4992.70815945, 4993.15915585, ..., 4645.15558434,\n",
       "        4645.50047874, 4645.50047874],\n",
       "       [4993.15915585, 4993.15915585, 4993.15915585, ..., 4645.15558434,\n",
       "        4645.15558434, 4645.15558434],\n",
       "       [4993.15915585, 4992.95070076, 4992.95070076, ..., 4645.40531349,\n",
       "        4645.40531349, 4645.15558434]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sign_dist_nn(start, norm, travel):\n",
    "    # pos is a vector; may need transpose.reshape(height,width,3).reshape(height,width,3)\n",
    "    ret = numpy.zeros(start.shape[:2])\n",
    "    travel=travel.reshape((height,width,1))\n",
    "    pos=start+numpy.multiply(travel,norm)+0.5*numpy.array(sdf.shape)\n",
    "    sdf_coordinate=(pos+0.5).astype(int)\n",
    "    \n",
    "    sdf_coordinate[sdf_coordinate<0]=0\n",
    "    SDF=numpy.repeat(numpy.array(sdf.shape)[numpy.newaxis,...],height*width,axis=0).reshape((height,width,3))\n",
    "    sdf_coordinate[sdf_coordinate-SDF>=0]=SDF[sdf_coordinate-SDF>=0]-1\n",
    "    \n",
    "    '''\n",
    "    i = 0\n",
    "    for v in range(height):\n",
    "        for u in range(width):\n",
    "            ret[v,u]=sdf[sdf_coordinate[v,u,0],sdf_coordinate[v,u,1],sdf_coordinate[v,u,2]]\n",
    "            '''\n",
    "    ret[:,:]=sdf[sdf_coordinate[:,:,0],sdf_coordinate[:,:,1],sdf_coordinate[:,:,2]] \n",
    "    \n",
    "    return ret\n",
    "    \n",
    "\n",
    "travel = numpy.zeros((height, width))\n",
    "for _ in range(max(sdf.shape)): \n",
    "    travel += sign_dist_nn(start, norm, travel)\n",
    "    travel[travel>1e6] = 1e6\n",
    "travel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualisation\n",
    "\n",
    "The below code will visualise the travel distance using `matplotlib`. valid is detecting which rays have fired off to infinity and which have converged to the surface of the object, so the background can be masked out. The range is adjusted to look good.\n",
    "\n",
    "__Warning__: The rendering will be glitched, as the above approach has simplified a little too far. The next part will fix this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x286e9c10640>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x1152 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "valid = sign_dist_nn(start, norm, travel) < 0.1\n",
    "image = travel.copy()\n",
    "image += image[valid].max() - 2.0 * image[valid].min()\n",
    "image *= valid\n",
    "\n",
    "plt.figure(figsize=(16,16))\n",
    "plt.imshow(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Interpolation\n",
    "\n",
    "The above render glitched because it jumps between the values in the sdf function; the problem is fixed by _interpolating_ between the values. This will make the function smooth enough for it behave sensibly. We can solve this with [linear interpolation](https://en.wikipedia.org/wiki/Linear_interpolation). In 1D on a grid with a step size of $1$, linear interpolation is\n",
    "```\n",
    "base = int(x)\n",
    "t = x - base\n",
    "value = (1-t) * sdf[base] + t * sdf[int(x)+1]\n",
    "```\n",
    "\n",
    "In three dimensions it is called trilinear interpolation, and can be coded as\n",
    "```\n",
    "base_x = int(x)\n",
    "base_y = int(y)\n",
    "base_z = int(z)\n",
    "tx = x - base_x\n",
    "ty = y - base_y\n",
    "tz = z - base_z\n",
    "\n",
    "value = 0\n",
    "for oz in range(2):\n",
    "  for oy in range(2):\n",
    "    for ox in range(2):\n",
    "      weight = 1.0\n",
    "      if oz==0: weight *= 1 - tz\n",
    "      else: weight *= tz\n",
    "      if oy==0: weight *= 1 - ty\n",
    "      else: weight *= ty\n",
    "      if ox==0: weight *= 1 - tx\n",
    "      else: weight *= tx\n",
    "      value += weight * sdf[base_x+ox, base_y+oy, base_z+oz]\n",
    "```\n",
    "\n",
    "Your task is to take the above and write a new version of your sdf evaluation function that includes this. To give complete code, without vectorisation:\n",
    "```\n",
    "for v in range(height):\n",
    "  for u in range(width):\n",
    "    # Get end of ray...\n",
    "    pos = start[v,u,:] + travel[v,u] * norm[v,u,:]\n",
    "    pos += 0.5 * numpy.array(sdf.shape)\n",
    "    \n",
    "    # Get base part of coordinate (no 0.5 this time!) and bounds check...\n",
    "    base = pos.astype(int)\n",
    "    \n",
    "    for d in range(3):\n",
    "      if base[d]<0:\n",
    "        base[d] = 0\n",
    "      if base[d]>=sdf.shape[d]-1:\n",
    "        base[d] = sdf.shape[d] - 2\n",
    "    \n",
    "    # Calculate t part of coordinate...\n",
    "    t = pos - base\n",
    "    for d in range(3):\n",
    "      if t[d]<0:\n",
    "        t[d] = 0\n",
    "      if t[d]>1:\n",
    "        t[d] = 1\n",
    "    \n",
    "    # Trilinear interpolation...\n",
    "    ret[v,u] = 0\n",
    "    for ox in range(2):\n",
    "      for oy in range(2):\n",
    "        for oz in range(2):\n",
    "          weight = 1.0\n",
    "          if ox==0: weight *= 1 - t[0]\n",
    "          else: weight *= t[0]\n",
    "          if oy==0: weight *= 1 - t[1]\n",
    "          else: weight *= t[1]\n",
    "          if oz==0: weight *= 1 - t[2]\n",
    "          else: weight *= t[2]\n",
    "          \n",
    "          ret[v,u] += weight * sdf[base[0]+ox, base[1]+oy, base[2]+oz]\n",
    "```\n",
    "\n",
    "\n",
    "Hints:\n",
    " * When doing the bounds check you will need to go one tighter on the maximum to account for the +1s in the trilinear interpolation loop.\n",
    " * Do not let the `t` values go outside of `0..1` as the system may explode; a straightforward solution is to use [`numpy.clip(t, 0, 1)`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.clip.html) to limit the `t` values.\n",
    "\n",
    "__(6 marks)__\n",
    " * You will lose marks for looping over pixels, but not for looping over the terms in trilinear interpolation (`ox` etc. above) or dimensions. Same principle as before - it's only worth vectorising loops that go around 100s of times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sign_dist_linear(start, norm, travel):\n",
    "    travel=travel.reshape((height,width,1))\n",
    "    pos=start+numpy.multiply(travel,norm)+0.5*numpy.array(sdf.shape)\n",
    "    base=pos.astype(int)\n",
    "    \n",
    "    base[base<0]=0\n",
    "    SDF=numpy.repeat(numpy.array(sdf.shape)[numpy.newaxis,...],height*width,axis=0).reshape((height,width,3))\n",
    "    base[base-SDF>=-1]=SDF[base-SDF>=-1]-2\n",
    "    \n",
    "    t = pos - base\n",
    "    t[t<0]=0\n",
    "    t[t>1]=1\n",
    "    \n",
    "    ret = numpy.zeros((height,width))\n",
    "    for ox in range(2):\n",
    "        for oy in range(2):\n",
    "            for oz in range(2):\n",
    "                weight = numpy.zeros((height,width))+1\n",
    "                if ox==0: \n",
    "                    weight = numpy.multiply(weight[:,:],1 - t[:,:,0])\n",
    "                else: \n",
    "                    weight = numpy.multiply(weight[:,:],t[:,:,0])\n",
    "                if oy==0: \n",
    "                    weight = numpy.multiply(weight[:,:],1 - t[:,:,1])\n",
    "                else: \n",
    "                    weight = numpy.multiply(weight[:,:],t[:,:,1])\n",
    "                if oz==0: \n",
    "                    weight = numpy.multiply(weight[:,:],1 - t[:,:,2])\n",
    "                else: \n",
    "                    weight = numpy.multiply(weight[:,:],t[:,:,2])\n",
    "                \n",
    "                ret[:,:] = ret[:,:]+numpy.multiply(weight[:,:],sdf[base[:,:,0]+ox, base[:,:,1]+oy, base[:,:,2]+oz])\n",
    "    return ret\n",
    "\n",
    "better_travel = numpy.zeros((height, width))\n",
    "for _ in range(max(sdf.shape)):\n",
    "    better_travel += sign_dist_linear(start, norm, better_travel)\n",
    "    better_travel[better_travel>1e6] = 1e6 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualisation\n",
    "\n",
    "Same as before, but if you got your function right the glitches should be fixed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x286ebad89d0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAGYCAYAAAC6WkQcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACGl0lEQVR4nO3dd5wcd30//td7Zveq7tSbVSzJkiy5G8tFMgSDKcZATAslxgECmGKKKQFMaCkkhGIgv9BMCQYM/jqm2BAMGAMB495wky3Jkqzeu053tzvz/v0xZT8zOzM7W057kl7PRya3O/Wzp3twft37U0RVQURERERERNQOVrsbQERERERERMcuhlIiIiIiIiJqG4ZSIiIiIiIiahuGUiIiIiIiImobhlIiIiIiIiJqG4ZSIiIiIiIiapsRC6UicpGIPCkiq0TkIyP1HCIiIiIiIjpyyUisUyoiNoAVAJ4PYAOAewG8TlUfb/nDiIiIiIiI6Ig1UpXScwCsUtXVqjoM4HoAl4zQs4iIiIiIiOgIVRih+84AsN54vwHAueYJInI5gMsBwIZ9Vg/6R6gpRERERERE1E77sXuHqk5OOjZSoVQS9kX6CavqNQCuAYB+maDnyoUj1BQiIiIiIiJqp9/qjU+nHRup7rsbAMwy3s8EsGmEnkVERERERERHqJEKpfcCWCAic0WkA8BrAdw8Qs8iIiIiIiKiI9SIdN9V1bKIvAvArwHYAL6jqo+NxLOIiIiIiIjoyDVSY0qhqr8E8MuRuj8REREREREd+Uaq+y4RERERERFRTQylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DYMpURERERERNQ2DKVERERERETUNgylRERERERE1DaFZi4WkbUA9gNwAJRVdYmITADw/wDMAbAWwKtVdXdzzSQiIiIiIqKjUSsqpc9R1TNUdYn//iMAblPVBQBu898TERERERERVRmJ7ruXALjWf30tgJeNwDOIiIiIiIjoKNBsKFUAvxGR+0Xkcn/fVFXdDAD+1ylJF4rI5SJyn4jcV8JQk80gIiIiIiKiI1FTY0oBnK+qm0RkCoBbReSJvBeq6jUArgGAfpmgTbaDiIiIiIiIjkBNVUpVdZP/dRuAnwI4B8BWEZkOAP7Xbc02koiIiIiIiI5ODYdSEekVkb7gNYAXAHgUwM0A3uCf9gYANzXbSCIiIiIiIjo6NdN9dyqAn4pIcJ8fquqvROReADeIyJsBrAPwN803k4iIiIiIiI5GDYdSVV0N4PSE/TsBXNhMo4iIiIiIiOjYMBJLwhARERERERHlwlBKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkRERERERG3DUEpERERERERtw1BKREREREREbcNQSkREdBQqTJ+Gtf+6FIcuOafdTSEiIspUaHcDiIiIqLVWXHM27N4yzpu7HA/tPwkzbmp3i4iIiNIxlBIRER1lzly0Fj2FUrubQURElAu77xIRER1lBl/uhK/VBqy+PsCy29giIiKidAylRERERxkd9qqkrgpOf/FyjP9VAQdfvoTBlIiIRqWaoVREviMi20TkUWPfBBG5VURW+l/HG8euEpFVIvKkiLxwpBpOREREKUol/Pnx+QAAFwIXgtnvX4HC1MltbhgREVG1PJXS7wK4KLbvIwBuU9UFAG7z30NETgLwWgAn+9d8VUT4Z1kiIqLDyB0cxOIv7I3ug2DDa+YBIm1qFRERUbKaoVRV/whgV2z3JQCu9V9fC+Blxv7rVXVIVdcAWAWAc9ETEREdbpu34aFfLo7sOvFVT2L9x5a2qUFERETJGh1TOlVVNwOA/3WKv38GgPXGeRv8fVVE5HIRuU9E7ithqMFmEBERURJnz15MeaAyttRVr0K68HlPYe2/MpgSEdHo0eqJjpL6BGnSiap6jaouUdUlRXS2uBlERESUpMMu48RnrcG6Ty5rd1OIiIgANB5Kt4rIdADwv27z928AMMs4byaATY03j4iIiBrV+av7sOIHJwKoVEtdFXRYZSy+cCU2f2AZpMAly4mIqL0aDaU3A3iD//oNAG4y9r9WRDpFZC6ABQDuaa6JRERE1BBViIuw664ZTC1RLHzZChx86VltbiQRER3r8iwJ8yMAdwI4UUQ2iMibAXwGwPNFZCWA5/vvoaqPAbgBwOMAfgXgClV1ku9MREREI23MRgdP7ZoUBtNAEE73LLBhjxvbptYREREBopo45POw6pcJeq5c2O5mEBERHZXW/utSnPxXqwAArkb/Hm2Jiyd/tQCzr34A7uBgQ/e3+/ux4+UnY9yqQ5A/P9Rsc4mI6Cj0W73xflVdknSs1RMdERER0WgjgCXJf4R21cKJF63EU588s7FbFwpY/YFTgFfvwJbzepppJRERHaMYSomIiI5y87+9GX9ZPzOskrqQyFZWGwuXrgUkaRL9bCs/twR9Z+2AquDQWQMovSDxj+BERESpGEqJiIiOcuXVa1E+5M2y66J60qNgvOmq759R9727j98fvh7XP4DNbx2CLDml+UYTEdExg6GUiIjoGLDwrQ9i3d5xAFA16VFg8cwtWPGdJbB66uuG62pl6+kawrZPlFCYOaPZJhMR0TGCoZSIiOhY4DrYvWlsJJDGq6WuCk6etxEr/vU02JMmNvwoEcXwnMmtaDURER0DGEqJiIiOEQvffg/Krj+uNCOcnnjmOjx15UIUpk3NfW9VCTcA2PORAUhnZ2s/ABERHZUYSomIiI4h8Vl409YvnbtsHVZdMa+hiqmqwG3/inNERHSEYCglIiI6huz61uzwdRBIzSqnuc09fx1WfGQBrK6uup+jKtjwvrNa1m4iIjp6MZQSEREdQyb88snIezW78caWilEVnHDmBjzx/52aer+Zn05/lrtkX9PtJSKiox9DKRER0THE2bMHQx+fVt1tF9ExpsE+F4L587ZgxX+nVD0fXRUJtqbOYhmrvnReaxpORERHLYZSIiKiY4kqrD89iIEvV5Zsia9dar4OtnmztmPF18+p2ZXXDKgiCrfXGYEPQURERxOGUiIiomNQx94yNu/rD9/XWioGAObN34JVnzozdfIjNcaoBqToojBr5kh8BCIiOkowlBIRER2D7D88APvX46r2m+HUnPQoCKczz9qENe88EfbUKQCAoQuSx5sGwXTchANY+Y5ZLW8/EREdPRhKiYiIjlEq1cvBAIisNxqeawTUac/aiDVvnw97/Hhsu/xQ+v39ewiXhyEiogyFdjeAiIiI2mP6H3Zg+RnTMf+ELYnH45MhhVQw9fxNWNmzCD32Hm9X2rlEREQ1MJQSEREdo5zHV6C4YymsEzQy+y6AyIRHSVwVTDx1O0qONaKBdN/rzsOW53qTJS16/xNw9+8fsWcREVF7sPsuERHRMWz+Zx7DyvVTE49Fxpcam6PibW6+QNpx0l7sfOvSutpln3wiNv9sMfSyHZg/bwvmzd2Kjd+fiZXfTVmahoiIjlgMpURERMcwZ98+LHjTA1i/fTyslMGfwd5gsiP1A6mbY6yoqqBoO3A666umasHC1L4D6O0YDsPx5DEH0dM/CKuvr657ERHR6MZQSkREdKxTxdy/fRhrNkyuPuR/dWMz8ZoV0jzV0qFxgD1xQr72WDYOzulL7Do8tX8/nvjyiSjMnJFwIRERHYkYSomICFIoYOebl2LoxWe3uynULqpY9J6VePrx6VWH4muYesG0nlsLJj1rM9a+c1HqGqeB0guW4MArl6D47srkS/E1U+fM2o7lH54Je/7c/I0gIqJRi6GUiIhg9fTgtn+6Gi/77K04+KpzAQBb370sf2XrCCBLTsH6jy+DddqiyP7C3OOx/h+XwX32mW1q2ejh7NuHhd9NnkgoqRpazwRHB4Y6MOe5a/HUlQszu9/ueOdB9Lx9U/g+baKl4xdtwfZnTcv9fCIiGr04+y4REcEdGMB513wAd7z18xj6ZBE/uPRsfO7Ub+OfLn4JduyejXl/+1DqtfbiBVh3yWTM+Mwdh6/BdbIXL8C+fx3Ap+b9HJ8/7wXYvnUJ4AgWf3Qt1n5+DD508o249oKlWHvZEgDAonc9CndwsM2tbp51yiI8/TLjDwsKzPq3OwFNL3Naazdhx22LMeG5m6uOpS4RU4ezn7scd/SfhAVX3ge4TuI5tWb+JSKio4toxi+mw6VfJui5cmG7m0FEdEyzenqw7r1n4PZ3fh4OKr8bBlXx2W3Pwc/vORML33lP5Bp70kSceutOLB2zCj/feQZW/MfJ6Pnp3Ye76VXW/NtSzF/6dBhqxnUewism3w9XvQ5CDiw4KvjhpnPx2uPu9fapBcfvQPTD9eeg7FrY/MQUzL/yrvC+q75/Jha85XHo0NBh/kSNcZ7zDGx/76HwvSWK/SvH4YQP3pVxFXDoZefAeuc2lF0LCrPLbmUsqauVSqnGQmTShEkiiiljDmBC5wAAYNez90PL5arzNv9sMSaPORjeK6kaK/79N+/ux/FXC3DXw5mfh4iI2u+3euP9qrok6RgrpUREBMCrlo57yg0Dqevv7xDBx6b+Ae968R+wetUEfOw//h4Tv+WFGunsxJsn/BkAcNL0X2Pt5+7GFza/ru0hoTxzCG+f+QcAgAvLD5xeuAmCpy2Kvz3u7vC46bUzvaA6MLMTa++biLLaAIAXdv8fVt8+GXdvXYgJL12ZWXEcLYIWCrzQaM0cqHlNzy1/waYTzkL/87fUPDeJq5IYTLcf7EWH7aCnMIzNNy7AtJc/kfk9TOserCoQUUwfvw/bP9qF6VfOQXn12obaSkRE7ccxpUREFBpzw1244Cv/gO1OdRgYZwHP6NyFn3/8c/j203/Cd5/+Ez7/5xsj58wp7sGXrv86rFMWVV1/uKz7xDJ8aen1ALxAmsaJBR4n4dxOq4QTe7Zgcc9mLOzZAktczO/Zikvn3oM1PzwN9uTJkW20kZKL4eHY359Vai6pokNDKO5XlN3k7189kxxF7mtMVnTipG1Y88PTGrsRKoF1bPcg1OZ/zhARHcn4v+JERBQx4zN34CV/uiJ876hGNlsEHSL+V7fqelsUn//Ff0OXnn7Y2iyFAnTZ6dClp2NoSnScYrwK6u3zu5sm/BqMj2N0E64HgHee9n94wR9W4nm/fwrP+/1TeM7vVwPnnNroR0glxQ4U5s1p6Frr9ocw9udjIPAqpgqgu3sYT3x+Uc0lVSZdcycO3ToFg6XGOlWljQctOXYYTIsdZRTmHh85nrTkjDnzbtyG7eMhw6WG2khERKMDQykREVXpfagb9w4lL91hBtQ0XeLgvd//f9j55qUoP/eskWomAGD/a87DtreejY9+//v44Pd/iP/vomsBZFdJ80iqnAJeSDU3BxJ2DT7t64+2fFkde9oUPPkv42GdcVL9106dggMzBea/lALom3oAT7x/FuyFJ2ReP+2Ld2DXtv7Mc/LOwBuct/1gL4bdglctnbwNyz81EfbJJyZekxREzfeqgp57euDu2pOrDURENDoxlBIRUZXpX7gD39+6DABgS3XocAAEtSkb1eHUgWBRcQf+5xOfw+L/eBTDF3lBbdM/LIPV1dWydm575zJc/k8/wec+eA2G1a4Kok44sZH4AbJyPDjXrKSmVfeC0Bmvmpr7XbUwqXgAsz/2JDZctQylFyTO5dCQhcdtxRPv6cG2K5ZVVRazDC+eCeucPVC/8mhuvfP2YuVbptQMptNvLWC4bDfU7rTvpxc2ve/ZaXM2Yvl7+7HtXctQmHFc2L5a9w3uPf7iTZBpo6/rNBER5cdQSkREiTZ+fgEeGY5WyRx/C9T6JeICeM+U32HhPz+Kp284FZ9523ew9vsLWtbGSa9cj1nFnYlddNM4KlWB1IEVCVBpVdLIfWJB1VFvwqRFvVtx6etuQ/kDO+Fc8Izc7UoihQKevHKmV1WcsxlTX/k0Hv+HqbCnTsl9j6RAGmxdC/ZixdsmozBrZur1fdffheFya+ZFNGfpdeFtZbVw6onrMetvVmP5VbPQ1z0YnhOeG9sCXDKGiOjowFBKRESJen56Nz576aU46GpitbSWoFtrSS1cMeX3uOGcb2JOYTduPPsa7LsluzrXCDdWBU2qktYbSNPGk8ZFqq1+WH3B9OUofGIrtt98IrbdtAho4HsIsTD/zPUAKuFy4Ymb8OTnZ2DFN5rrJhwExO55+/D4Px6XOfmRJMykG5dVFY3bMdAbCZjB65NOWYeuQrnmOqUMpkRERxeGUiIiSnfXw7jiojdh2B8/Wm8nzkG1w4oiUKkufmPxddj1i4WNBTXLBiwbK79yLj5w/G8ihxxIJCBmBVIHViSQBu+BSndcc7yoG7tvFtdvx7kT1+Klxz+Kl815GMO/mV3359XSMKx3jwk/U1BdnHfcDsyfvwUrvrXEu2fKfQu3P4zun/dDFZEtvL//2cdMPQDpKKa2Y+Zbd1S3rY4wGB8HWnasxApoybGTrwGqOolHwqjF/5whIjqS8X/FiYgoVWH6NMj+AVz6zveH1dKkYJo0rrSUUGUMzivCxXWn/jdWfKu+SZDkzJPxiVX34h9X3Y/vvugb6JLorKuOWpF1SeOB1FELw1oIw6irYoTT5MmLgn3hM2BW6fL9GnUhuGDKSuz6+QLY/dkTB8U5jz0J+cTEsAJrhrh5c7Zh+DezseGqpZDOzqprtVzGhP++E9bdY6P7jXAaVGDXfuM42BMnJLd/9+662px4D6MyqirYemAMHNcKt5Jro6xWOPsuUB1G4++D8/Z92UXh+FlNt5GIiNqDoZSIiBLJWSfj43/+X/zs7ptxy9f/CxaqJz2ypfKLJCmYBvtsaOLxvokHM8czJvHuVVmKJgiiwURHw2qjpDZKWghfV4JqdRgFjHGhNcJoUiDNGs9qGZ/ZheDiWY/hif+aX3M5lqrPfGAI63eOq+q2Gryf8pyN2PrWs2CdtgjWadVrxHbtUAwPVVdCzXBqWYonv3w87JNPTGxfsEyLm1BpTapqJm1mu13XwrYDY7B7sBvDro2yH07LrpVYGY20O9YuSxQ7v1YdyomI6MjAUEpERIlmfOVpnNUJuH4ALIoVBlMb0V8geYJp5dzK+5+e+U2svWx2Q+0LKpqVIOqF0FrV0axuuma1FKgE0XgYTQukbka33uDcy06/G49/bAYKc/J/bvcvyzHhJ71GG6LdYR3XQs9LtmDfZ4ex/7PDVcvSTPjOndCN3an3D4Jpd88w1v1LAU++dzbs+XPD44PPPzPSXdecITe1qpkwsZKrEp7nqMBRwVCpgL2HunBwuANDju39u2Vs4f1zfu+IiGj0YyglIqJE9/3oNKwqDYXvbQjsWOjyQmr0uiCEWgmxIdhnGxPnTL5gU2J1L27tp5fiybd5wcwLloKSFjCoRZS0EL43K6VJ1VEgPYx695bEimk8jGYF0vgxJxZi/27pn7F3yfSan9k0dvlerF41LbIvHgxdP+jtf/tebH/7Ugy+9Jyq880teqwSTrtO2IdVb5kGe/5c7H/tedj9tgNwFXAVkYBphsyk+ycGU9eC61qR+5QcG4OlAoZK3vIzjnE83tZIN2Bj3/DPuSwMEdGRSjRj8XMAEJHvAHgJgG2qeoq/71MA3gpgu3/aR1X1l/6xqwC8Gd6qAe9R1V/XakS/TNBz5cJGPwMREY2Qva8/D7f8+9XolAJcuHCgcFVRgsJRhQNv2RfH/1USdKr1JhzygxKkKqAGoTQIsB9Y+0qU/q4D5afXp7blqqceRp81iJLaGIaNAbcTg1pMrY5WAmhlIiMzeHrH8o0VTeuim1YZNScmSrvHj1eegcHt3RAVLLji7tTPbdr0oWWY8oINYVdar60ShtF40Ny5ZwzsVd04/pcH8dQre9Exd3/ifeOz6wa9tAdX96Ew+yB6u4dSq6NAJRxHq6m1P098fiYRhYjCFoVlubAt/w8cRvvMtgb7nR9Mwdgf3gu4DoiIaHT6rd54v6omLuKdJ5T+FYADAL4XC6UHVPXzsXNPAvAjAOcAOA7AbwEsVNXM3xIMpUREo5eefwZ2L+zG//3Ll+HCRUn9cArkDqYms0paqaoC3969FPcv64M7MFB1zb5bTsCXF10PACipjYNuJwa0M1cgNaujWWG0VhDN6pqbdH78msiyMUa7AODHj5+JEy59MPP+gDfx1OOfnI05J2zNDKXxZVJ27h6Djs4yLMtNnTU3LZhaVvSTx7voRr9G75l3hl6JhM7KPksUth9Og3OCIGq+H/tuwFm5OteziIioPbJCac3uu6r6RwC7cj7rEgDXq+qQqq4BsApeQCUioiOU/PkhTLj2Hpz/mSsBAJZ43Xjj40uDbrxpv1hsvwJmCgMhgDePvxOveWCVt+RLzMtmPhwG2EEtYlCL3gRHKYE0qbtuPHwmdt31u+XGl2BJCqTmufUE0qrvC1ycNmtDruViypu3YNEHHsP6bdFZchWIdKkN9/tBddzYg+jqKKFgu0gT7yYbBEzXrXw/FWlddKtn800ag5qve693P9f1xsqWHBtDZRulsh0uJRPcE/AC+PrPdtU9qzEREY0ezYwpfZeIPCwi3xGR8f6+GQDMvlcb/H1VRORyEblPRO4rYSjpFCIiGi1cB127XGx1yl4gTQimQDSY2tAwiMbDqMkMps/uXo3nPbwH9qSJieeW1A7HkJbUrgqk0ftmB9LI+xpBNB5AI1VP4/y0a7M4sLCobys2/vgk2OPGZp4LAO7Bgzjh9Q9h067+qopoICkUAl5VsVhwqqqiaddW1jatjAfNE0bTxoPG10sNNi+IVo87dV3xN29W3rJrYbBUwKHhIobLdnh+f/cgtl43LenjEBHREaDRUPo1ACcAOAPAZgBf8Pcn/XZM/M2nqteo6hJVXVIEp3EnIhrtxt+2Gs//v/fAgpUYTItInvgoDzOYvqrvLxh3kwvnOc/wtguegbH2AEpqY4/bE05qlHwfq6pCGsgKpOE5KUHUlBY+k65LrKAmBEkHFl4272E88Z8n5FsuRhUnvHFFZKxlElcBx61+nmXVHvCZHE6jW/V52QHUPD+pQhpsZlg1w6njWGHltuTYGBgu4tBwESXHhtXAzx0REY0OhUYuUtWtwWsR+SaAX/hvNwAwV6+eCWBTw60jIqJRY/vFJ2DlhV9BGQKoBcD1/hSp8P6fSCV5mPt9DgQ2NDVQBlwA/zLz58B3K+NSS7CwqTw2nFE3axxpeJ9YCDVfxwNpPFymBdW4WlXQvFwVlGDjDaffhe9+/Hyc9G9W5qRPAKCOi40PTMf0M7dA4I/BhDkTb31tCAJlvIqqKomV1aRKrPc6+Zyk4+mio1i9NgTtCN4HR4HBUgG2KMrPPQuF392f5wFERDSKNBRKRWS6qm72374cwKP+65sB/FBEroY30dECAPc03UoiImqrwvGzUHj1NgCABQsQNzWYOkbq8M8AUJnUKE8wNbkQDLhFP6BamdcGVdKkqmieQFprcqOsEJpUATUrmWldbc39JbXx5qV/wm/O+Ct0P70e2961DG4RsdmFKi879nrPcFW8rwCQGASjEyAFs9wGx5ICphlE0yYsyjPBUWIIrTEBkiL67ODvHSJIDadlFax/axnT+s9B98/4nx5EREeSmqFURH4E4AIAk0RkA4BPArhARM6A96txLYC3AYCqPiYiNwB4HEAZwBW1Zt4lIqLRr3TcBNx5+rXhDLuA12U3KZiG0xSJNyOvGUzDa/3QkTec7nO7UFLvV1bW5EZmtTTp3nkDaZ4wmhYy85wTr+oGSmqj5NjYdukhDL3sLJw6bzUsqNdVOBYsg2Vhhl07EkxVNHHW4zjLUj88VsKpqdbMuVkV0aogWiPUxsX3VkKqJIbT4IrOrhI2vtLCdPtc9P443zI7RETUfjWXhDkcuCQMEdHoZvX0wDlzIVa+xcaqF3wTLtRbt9T/HZJnDVOgOpzW4kCwy+nCTrcXJS1kLgGTVSUN3qeF0noCaZ4wWvtzRZeHAaqrqpYoVu6fjLLakVl1zdlny+p/bn+cpaISVr190UqoOYNuoDJhUfU6p0nMsaHm++oT0yu29QqrtuFyMEG1t1L1jSwl88dxmPbFOxp6FhERjYysJWEa6r5LRETHFndgAPLnh7DowR68tO8iLP7lDnxi6p8BAF1SiFRMraCUZYwvDYJpEMXyhtP9bhH73K7USYPychIqovUG0rQJipoVn6woCKDeZkWe65oBE9WTC6UR0cTzzH3p51RfE9lXs6KacM/s5kaIeQ9/fKuq91gRwAr/CSrV1OFl+zHw9Lno+QmrpURERwKGUiIiys0dGAAGBvDoWcCrZRkK06bi/bffCkctzCrsxayC5YelyvhSC4gEUyC5S2/SfgdeNdSNLO+SXCVF7Lrg/LDtdYbawxFI0+5d65ygO6+53+zC6/jhzYLARXLYDMQrn/H9lfexymjKREdZUsNo0vXBmNeUc72fMoXrSlV3Xtt24RY4HS8R0ZGCoZSIiBqjivLmLfjsCacCAFZdfR7+8uovwRKJjC8NJhawE4JpkiCYOhB/LVK/ollj/GlaSMw7bjV1fGlV4K0dRuPX1Fq6JevaWvuTiGhi0LOM8aZps+d67xF7nxxImwqjta5NCapqHlfxwqvlPcWcpffQREF/Xx/c/ftztZGIiNqnNX/mJSKiY96ERwU3HZwRrmEKeJMh2aj8ssm7hqkFYMAt4KDb2XC33Xoro8n3qB1Io91tJTE8Jp2Tdq5pTHGouQ9gCMZlRhZbyZGV8wRSrbFV3zS5m3DWeqjhdf4W3l8FGq5vKuH6poeeewDbXncKhl50NmDZVc8jIqLRg6GUiIhaYsJ37sTVK7xJ62yIF07ReDAFEHbbbdV6oJX7RseTZi0LE+6vWge1dqisu12x+03qPIBxHYeauF/y/jzLvSQeiwXS1NBZdSOJbuH9E4JnYjsSzjXDqQrUtcJAquqF1IPPO4AtbxrEzjedk6eVRETUJgylRETUUpb/q8USL5hGj3lqBdMSBPu0MxxT2g5ZgTOri2291dAsNlyMK2aHUhHN7B6sCZVNQTSYZl3nvU7en3yhJIbQzAooULvcamyRe5hVU9fy3rvRGYX3Pf8gtr5nWXa7iYiobRhKiYio5SxYYTdes1pqygqmjgoG3WJzbZB6F6BJV2scaa3w2UxILVgOpnbvjwRPC14QTQujWccAY55ayRNOgxexcadVJ6ZXQTVP2Ex8tlRt4cONgBoGXxgzFBvhVAQ4eN4AtryXwZSIaDTiREdERNQyUy/dgld1vhgAoDMm49qff7PqnLSZd03xpVnysOHmnhHXgjb0DCBhJtwGKqH1XjO2eAiOCrYd6ktduiV+f6+CGp1cqlUit0ybJKnO5+aeNCm2jA28/4ME/57BZEjmLL0KiOVi4NwBrPzeMzDrfwro+vk99TWQiIhGDCulRETUMs6+fXC2b4ezfTvchx7HZbPOx8X/9EGsLydXPc1qqS3e5gLY6XY31W3XNhKRnSMdWfUmqDaY0DGAcZ2VrrxBtTSLiEYqoc2OgU0bY1o5jkjlM6nSmbYlPzBjM9uT0B04zMbhOV5QL3SUsfWyQ3Ce8wyvhEpERG3HUEpERCNq4rfuxN/84t2Z58S78tY7c249S65En1u7i29W9TUt5DmwqraRkvbZgzBm5eiimyZxTVIk7DO76MaeX/shGVut65Kek9DW6iVvBBveUUJh6pR8bSQiohHFUEpERCPKOm0RZp+4NfV40tjSvGuLJj7PCJpprxuVp9KYvl5qa0Oqi3xjVMOlYGLjTIMqap5xpUAs2MUmL0qqjnpvcmytkmMWX5M83gcdHGxhA4iIqFEMpURENKI2P3sCblh8XfjejIatGO9op4xQTevCm6c6mkdSGKwnbDYSUPsKQyhY+dsfhNBmqqU1ZYXRzOuql4hpteDO4Wf3vxb+Mgbzvv4UnD17R+zZRESUH0MpEREdFk7a/iaykh2phGpiQE2rkNY7jrRWRbKZ6mdaQI2/77aHMb17H0S0ofGhQbW0riuTuu4ioyqZtD9lmZikZ+TWYJYtPDoGc65di/KW9Oo9EREdXgylREQ0YvT8M/CRd/0ITh39Krc73U0/NzWIJuxvpHIaD4StHDNaq3rabQ+HFdBg+ZNmJzAK5KqmZj2rau3ROiqhLa6YJlZJ1/RiztefRHnjppY+i4iImsNQSkREI2Z4bBHP7dkQvs8T/4arVjSNsuHCFoVl3M1OfT2yXXhria9PWs86pWnBdNtQHwqW2/DkToDfuzZr1tssWc81bzeC3XIbUdrVhRP+9WE4u/YAlu1tREQ0KnCdUiIiGhGFObPx/W98CY5qatddO8c6mpax/qglbtXMvLa4cDQ47nVrteECUpnF17wu6R7ecxpbuzQpPNYKnubxvOHSVcGu4V4M+svr2OLCFYFTR/hLqqp6kxVJeDyLoFIMFfG78Po7w/VTg5OCz9WmcKoqcAYKgCPBQqZ44vMnR85Z/MWdwK49gOPC2b27Le0kIiKGUiIiGiE7zz8u13lJs+9Wn+MCalXNymvBDdcztf3wahnjLS3jOivhHo0G0Sz1dqWttDU9nLoq2F/uwkC5GM66a/njQ13R1ODnGtXQvFXRXD2t/WfWDKbBuUB6OG204hs8F95nE1FvBl4A7lABGLaMNWGSngssf99EABNR3GNj/vd3Ajv3wNm6rbH2EBFRw9h9l4iIWm7bO5fh5s98IVIlzdthNm023fg5tlR3x83TjRfwwqrZhTepO288JCaFxniVtJmxnVnXltXG3uGuqgqvBQ3DaS1p40WTQmuuACsKhEvKIAyIlTGcyedXbeHx2JZHwkdyh2xgyKq97IxxrDTOwfL3jMPuC+flfDAREbUSQykREbXc5z/wjYauM7vyWinh1IqEycrY0vhMvIAXTONrlVYF1Nj7eEDNE5JbJW3MaVoX3XA23YTAGV+XNNiX9LoSTGHsQ/XxxEYE66AiIYgmNjt6vJ4QmsQPl27J9gLpsBUJnKKSuMWvhwJ751mwF57QRGOIiKgRDKVERNRSK755NuYU9tZdJTUDaXVwdKv2m2HRDKY2XD+MRoNpfNKjeLV0JCWNYc0+P5rSOq0yxhSHEs8NQnVatTQIn8FapbblRmamtSzveBBCI1XSPBXTRqvD9V6WtKyMv2nJ8sJoyaoKo6mPTwinh2aWsfrSqSjMmln/5yEiooYxlBIRUcus+MbZ+OXzv4w+q/6gkjS21IZWuubGKp6V6/zQFauYBsE0WL80CKZVlVNxYfnPqXft0lpctcJAGrzOG1DNqqklik7LQcFyMrvsBmuQmsfMSmoQTIPzxD9mWdFwnjSutGpXbLkX85pcS8tkSVpaxnyr/uYKtCxAubo6mlc8mA5NLUPHNL8sERER5cdQSkRELbHmM0vxfy/6IibamjnjbpZckx4lVEuTgmm8ahoPpvFqbLQdza9dmhU+6wmoQTjttodxXPde9BSGa1ZHA5UwqlVdd63Ie8CyNLFKmji+NCEkjphY8FVFJRA71YG0EWEw9e/xxLsmwJ48ufEbEhFRXRhKiYioaVZfH0rjy+gSgRNLKHnjXfALKQiL8WBowU2sliYF06RwmhZMrarnRKuMWVox3rSe6qkliild+zFnzM7MtsWrpeF+USQVsSsV0xzJLiuQtiKchjPmihGMY2FU4QXSYLmXnF12w/sntDO81gXUViz/9Bx/oCwREY00LglDRERNsceNxYqPLca9F38hjGj1VEmtlNfeexcO7MhapIlt8JeDCYKpoxKdKEmMJWOgKAGAWoC/TIzrf0XKc4JrR5K5jmr6OZWQ1FMYxr7hrqolbcwlcYDKMi3x/fHjIkE4rZ6RNylrZlVHc83eayzpEtkHRMKo+T48xxHArQ6kNZ+X9d4nEMDxDlsnnwhRhew7iPL6Ddn3JyKihjGUEhFRw6yeHqz4+GLc9WovkMarpDWvT9svLhy1AXiV0/j6pME+S9wwzJnB0VwuxgyoXnXUgg0XJdiAFgBxYfn3d/1neveoDqhpwa6VXLUyg2lgSud+uCrYPdTjtQve99NsX632msuJAsHER16oTPynzPrsiednf4bka1ICaRBAgzBajwaquVIWPPn2sQCA7k0TMe3uqQCAzntXwtm3r84GEBFRFoZSIiJq2BNfWYwHnnc1SqgE0rxV0lp1Ry94Gu/FDatrjlqpwdRrg2VcF0sh6lYmONJKaCsBsMzqKSqTDNUbROudbTfp+jzBdHzHAPYOdVdVS4HqwJlGAGO9UC+MiqiXBVUq90iZ1MjbkeNBtdQKo4BRHY0G06olXqrunbA/uCa+VmrC9YeOc7Dm5QVAgPHzT0bHfkX/D+/K8aGIiCgPhlIiImrIpp+ehHuX/GckODYTSG3/ektc2CpwYVWCKKyqamnkfn6Ai4fTRBKc48CCC1csWKoYcouABZTcQuLnMCuxo6liGrQH8MfvZnTRTRMEU28yJCvszouE67LGkGpWOEx6vmh2GA2+BiFUgaquvJFnxF4ndf+NU6kE00o2r76vH1h3n+r9mwxMWQYAGPdUGV0/vyf9/kREVBNDKRERNeQzp/4EADK77SZFqnggtRPOyWLBjVRLAYSBNR5Ok5iB1RbAgXqTKFkuHFfgilcldbX2WNaRViuYFsXF1J592DrQH6nsetfWF5qDs4PlYVQtP6+JMcbUuCAtkCYEwfSuwEkz+8a/JgTSPN2CXe/ctPmg6v6bQmwM7P75DiDAgdkWCucsxbwf74X70ON13pSIiADOvktERHWSYgcm/nk8zu3cGQmktaqkFmoHUhvANHvIO79GldCciTe+vIslbu6tKGV0iINeawgT7APotEreWqApyScIffHZbaNrgzY/K28elrgYVzyEiV0Hw7VL42uExtcszXVfy4Vtu+HkR17F1DjBeK1BaA3He4q3fqg/Y666wYy58Q3Jm3n/tAppkuA8RyCOwG92PnkTasL9tFMxPNHBk3/fh5X/eS7s/v6cDyUiogBDKRER5WZPmohdPzseX5n9v3Vdl9ZdN/U5wbIw0Gj49F+bS76Y12SuPeofT9qK4qAoDnqtYcwq7kKXVYq2PyPdtGJZmCx5xqcWLCe2XI7X3qSoFQ+tJvOIbXvBNEh24eooQU9Xo4JqhsZIN9z4uNB4+DQfHNniwTWhy2581l0/FOcOovUQY0s6rAItKLSgeOLfF8OeNHEEGkFEdPRiKCUiotxWfWAhbj39e3CgNaukQUSqN5AmsTKCX3w907TgmSVcz9SvnM7v3II+exBWLBQ3y4VEtlYZVzyEMcWhzKqoGUaTgmnSd6hQcLxqafzcqrBZYwmX+IPSAqoZRl2EldfIdcY9w0Dqnytp1dekIGwKvh9m8MwKohkBVUWx4iMLUJg3J+OBRERkYiglIqJc7JMWYsLp2+Gq5qoNJnXXzctbusWNdIMNq6exaqm5rxYzfJpbcD8LlX3zOrclBN7WVkVbGUyz1Oq2W5Ub/SqoqvjdeBP6wsYCaO5AWvVwP3i6RhiNjx8N93mbqKQH0hzCJgafywyg8cCZdSyF0+ti7WuOy9cYIiJiKCUiotoKc2bjwBdLuOVUr0oK1L8ETKBqHKlE/yvfQnSMaNCF14JbM5gmhdN4+Iw+y60Ko8Ezi1LGpML+sFqaZ2xmI+NK8wTTRpeYsUSj+SocD+uvSRr7HJEuucE9LIVd8Fop8abmDaSpFdGksaWxaqkRQsMwGo4fRTh+tGYgNR6ZGUZjm4pCs7o8x4/71w2PV7jPOrNGo4iICODsu0REVIPd348p1+/GD2b8Ouy22/C94u/9lGOLhCHXBtBnlVBybAAu3NjfT4P1SdNmxs1TNY13B06aNMmGYkLhAHaU++CqbRx3I+ug1sOCJobQcObcvKW+BBM7D2LQKcLVIlx44T6YgTdtbGnaMjHx/bbtfX9KJbvqbpmBtKpSmjB7brwqGu+ai9i5wVdz/Ghm19xY84IwahwzP1JaAM0KpvFnAYA9CHSs34ly7auIiI55rJQSEVG2jiK+NPM3kV1pS8BkqVUhtUXCrUs0rDSaFceksaVZ402TZI5PNdKNBRf91iCmF/eEYTFrxt1267TKKPgV3WAWXsuohma11fyXSFqXVNWbkbdQcCBWMCMvjPU9UyY0Co6Z3XODzZXKmNGEqmilAQlbfPxojQ+WJ5BGKp45Kqi1uvXahwTltesyGkdERIGaoVREZonI70VkuYg8JiLv9fdPEJFbRWSl/3W8cc1VIrJKRJ4UkReO5AcgIqKRY/X04F/uvQWuamKVNG/X3VqBNMuW8lisL03Edqey1EbVEjB+F9xaks7JqqxacNFllRK7/5ohr56xplnV0KyuvHm68M7s2YMT+7fhxLHbULC8tVfNYBoPnEldeCU8F1Xri9q2C7vgRAJYfFbeSBitGieK5MmL4tXRqmCL5ECaQ1V3XSAxkIbvsyY2qjW+1Ng3MLuM3W9cmq+RRETHuDyV0jKAD6jqYgDnAbhCRE4C8BEAt6nqAgC3+e/hH3stgJMBXATgqyJS70SLRETUZoU5s/Heh+/H/KITjiMF6q+S1hNIHVX87MAC3DU4Ax1wsdMZgwG3EwBQ8rvQZk1wlBVM6w2kgWmFPZhS3Be9boSXgWlUuP4qFIvHbsGcMbtQtL0/HbixQBqMKzWlLRcTn/jILjgQywx5QcU06eLgqxFGg/1JExelTY7kd/PNXZw2x4/6782vamm4QeD9F1Ge4JnwnKTzetYXMP67d+ZsLBHRsa3mmFJV3Qxgs/96v4gsBzADwCUALvBPuxbAHwB82N9/vaoOAVgjIqsAnAOA/8tMRHQEmfijPVjatQeuH0IbrZKasgLphzdehHUHxqPwvHVwnvMMnPfFe3Fmz9Pes9QKq5XBONK0saX1dufNo986hB3ShwHtgCUaCXjB+2Csafx4OwRdnnsLQ5jcdQCbDo6teY0gmgdFgmpp9WcpFFxABY5aUAEEUsmb5hjRQNV74zlZ36tGAqnZZTdWHVVLAVu9gx0uxFKvGhx2IRbAqfFvl6cRjqBn8+jp2k1ENNrVNdGRiMwBcCaAuwFM9QMrVHWziEzxT5sB4C7jsg3+vvi9LgdwOQB0oafuhhMR0cg5dMk5OHdsdbfdZqqkWYH0FY9dhrFvGUJxyyZsfecyAMB1D56D+Uu3+tdWV0TNCZDSJj3KbFvC+qZpJhf2YXu5H0NaiAbgURBA07hqRcfjisJpsq1BQBVRFIpOuM8pWRAL0KC7LpDevTZ2XEWTq6SxQFrFTNGRiYoQrY4KMPF+C6KAWwD2nQA4swahjldKFQEU6p1o+de5ac9M6OYb/5wC2AcsTPhv/i2eiCiv3KFURMYA+DGAK1V1n6T/x0XSgapfTap6DYBrAKBfJvDPiUREo8imV5fw+v4VcFP+1zlPlTRvIH3RQ2/C1A+6KG/YCKu3F+97zw0AUDXrrndPBRKqpd4z6g+maZKqrVOLe7DX6U58Rlo4tcStezkXF5I67jQeNGveSy2U1arMwitaFbZENDJTb7CvesIjqXodBFOxLLiuBXfYhkKqf0ASnltVmo08LNfHS57IyDg2+V4L3dvL6Pz1fYDrNWrK4gXYd9IEbD5foBOHk4Op+o0z2xxZQib6nEgjFJj9a865S0RUj1y/KUWkCC+QXqeqP/F3bxWR6f7x6QC2+fs3AJhlXD4TwKbWNJeIiEbarr9fin87+ydNV0kDSeuQmtuhuyfBeXIVAOCpb58AIDmQxoNi8D6ypmnKeqTVbaq/i+9E+wCKUklbwbjSpFltG1mvNDy/iWVhct3fn5m3FYJxpoWCi2LRQbG7BKvoeMHO0mhFMT62M0n8WFgJ9SdfilVEq9YdNe4z+V4LE376KDpvuTcMpADgLF+J3h/fjRO/uRN6sFDdHVdgtF0RmSQpciy2Wd55C747jOJv7sv8vhERUVTNSql4JdFvA1iuqlcbh24G8AYAn/G/3mTs/6GIXA3gOAALANzTykYTEdHIOTBL8PzuzZHJjUz1VklN8ah5wb2XY87Xnwzv+fZTbs+8ryUuoFakWuo9r1IxBbKrpo0E0sDp3etw58H5AKzEymgza5i2WrxK26pOxvG/TXhjTwUiCttWWF0KdJUxdLADWjaeHBmw6r8PC5IaHVuaVEX1q62R7rnG7U3jH7Ew4ca/wB0YSP0czvKVkPK54b0F4lVLvUGy1ff1w+iCb5VQXLc99b7lTZtTjxERUbI83XfPB3AZgEdE5CF/30fhhdEbROTNANYB+BsAUNXHROQGAI/Dm7n3ClVtZD4MIiI6zA78zbm49c2fRRAfG6mSpnXbTYpqA/s74ezYCQAo/mE6JhU2JN7Tggs7VtGyxQW0UlVNCqZe263I++Q25/t8XVKCBc0VzM0uvfV0483qvlvreQBikzC5mNa1D4NOEbsO9bRkXGlc5UfDC6ZBFbZrzBBUBYP7O43Jg4wusbFgWiVpzKY5cVESP0zuWjqMrj2nYcwNd2WcDEhZwp66VfcJxpcGbXQF837oQu56GOUGew0QEVGyPLPv3o70XwEXplzzaQCfbqJdRER0mEmxAweOs9Fn2ShpJcCZgbSevzDWCqTbHYHs6gAAFGbOwNSuvbXvCdcPMVYYQM1Jj+LB1GtHc7PxBjP/mvdzgzVEtLoyOpqqpYGewjD2250Ydupfoc0cX5qVxbxjxthV/2t3/yDKZQulgQ7vrxzhmqUSnaDIT4YCY7KkpIplBu10MX6qt3zP0NgJ6O/qgjs4mHr+/PffhRX/fRbE9tamqaqWBoG0ZGHWLUDhd/fnbwwREeU2un5rEhFR28jJ8/Hnf7g6dQmYPPJGnl0ucPGvrsT893mVrNVfnIBnj3si8dzK2NF8a5DmrXpmSRrTCgAOBGPtQ8ltqDG2NLK/iTbWO3FSoMNqXaclc93SYPP2Jx+3bUVX3xC6xg5BuhygqECHCxT8fzdjbKaKsXZo0pbWpi4H46bsD9vivnQXnLMW1fws3U91Gm1QiOVtXWs70POUt03/vYXumzgSiYhopNS1JAwRER2dpNiBlZf1p44jBRpblzTNHYfmYuHbvf/ILz/3LJw4JdptN2n223H2gB84K9XS+NjSQFLFtFVO6tqA2w+cGPl+5FkaJt6F14L6FddqjXbhTVN2LRwqF3MvX5O0Nmn+a4IqadI5QEdXKXzvuuJVUEtG4jTGmRq3q4w5TbpvTxl94wcq3aWB3JM5zf6P+7D978/C4ATBocVeVbX30U7M/Opf4B48mOseRETUHIZSIiKC1d2Fh17zJZSamHE37+RGcesu6sDHp9buFrmguBM73U44Gn1SMKlR1dqlfpoZqXBqiws31pYgnObtwpsVTFtlf7kLu4d6Gl5PNSugZk16FBzz9iVfb1mKYncJTtGCO2QDZf97ljALrzkZUhhYu1zYXWV0dw9HLnFVcncF09IwJn3jTuj5Z2CD3YNJj5Qx5vYn4DCQEhEdNgylREQE3DQms0par6x1SU0DrzgXFzz74Vzn9giwBwo3Vi11IKnBFKhdNU3q7huv1MbHlZ7YtRnLB4/zuucmjCutR6uCaVro7LDKKFoOhlDwQjO8PxS4QPXaoYakIJkVMKPXVMaWJp1vBl2xFIUOB66tKB8sGpMiVW4lPWVYRRfO3g7YAxaO+6Niy+sGUSw6sO3k7169Ibzw+NOYu64X5fUbWtorgIiIauOYUiIiwlfm3QAAkWBazwRHeaukNgQ2JAx9B6daeNbYJ2u2zxaFLYLJ9jAscTPHjSZ1/bWhqVteZjfhvoRxpWnjR/Oot6tuPeNKu+0SxnUeQsGqrKsqopH25u/Wm++Z8bGllf2SWnm1bLcy423AXyPUKigKBQfF8YOQ6YNY/9cuOjq8QAr48ybFNgB46u2CwozjcrXZ2b0b5fXJsz8TEdHIYiglIjrGWb293qSoTUxwZEqrktp+PWtluYgfPWMhyheehbe/56bEc5P86dB0FAF0GBMfmQHVrGQmBdNWK0pyVI+HU/O9lTETcBBMLWjLxpMGz7ag6CkOY0xxGD3FEnqKpTCkBuclPbEygVGO0KpS2RANsElhVLV6K/YOez+AfhiNt8WyFHbBQWffEFy3eqKlyPkAxvQNQnu6arediIjaiqGUiOgY95r7V2KSnT5vbqNV0iS/HJiFT535POjwMA4c14Fea6jmNcH6pCW1cevAHEywS1Xh7nAH014ZxuKuTeHzkmYGzpotOE0rJzcyTenajy67FJn8p2g76CqWw/dNdSCOh0I/nAZhs+r0+D4j0C766r7I/aTbgV1w/OsqAdR1BY5T+c+YpBmBFcDGz3XC6mIwJSIazRhKiYgIrj/BUaCeCY5MaWuTBlXS77/+Yjh792HX68/Gez52g39N8rO8LruVY08PT8L1l1yAz269EF3i+N1v3TCgpgXTka6aNtNtt9Usv1uuFeuem6bDdtBZLKNguyPzOYyqqbklnRN46h87gaILFBQoaDgu1bw2CJ2uK2HFNPHxfjAtn724xR+MiIhaiaGUiOgYtvuNSzGvY1v4Ph7fWjnhyyWPXwp7+15IRwfef9X1qefFw2jAEhfOk6tw35fORK+UI9XSrGAKtKZqat4zmDgpXtlMXZc0ZxfevJLukTdUxtvcaTvoLpZQLDT/r520dqnZpbf6gurxpqqCQncZhe4yij0l2AW3qltwZRO4rhW+Tl47VbD+3eXExxMR0ejAUEpEdAw77k2rcXpH9aQ9eeWZ4Ciokg79YBrKa9dh1afPrJqtNgiiaVXTpPt3wA2rpUB1UEsKpiNRNY0/x2uLH45H4HmNhtpoMK6upHYVvOBWa/yoamzMaOYMvinhNBZUMyudZsiMbaqA43jdeJOqsMF1lqXY+ZalmZ+LiIjah6GUiOgY5kJGpOtumhVfPwcfe8lPGrr//37ouQCAiX9Yhwv/8B50ihNOdGSGP3NG3cTAWCOc5g2ufdYhTO/Y410jWjOAtrub78TOg5HJjUx52lbrxyJ7PVPjWNWER0Y4zdiCc5OCbjC+tFI1jbbXshQ7z2a1lIhotOI6pUREx6hVXzwPv53zeaT9fbKVXXctEbzmw7/GWHsgddbaJGbQ67rtYW984MZN6Fg7B/YFClsVEBeO2v5zXLhqRdYmDdYwrWpTk1XMDnHQJcOwoHV/r4J2Hk7ddqnmOblm2c3BzK/BHYN7m5MtxQNp3nt6O4zJkAC4jkAshRrfVxHAslyIAF0TBrHiG2dj6p9sjP3BXbk/CxERjTxWSomIjlE6voQJxqy79Ua0PLPuBl13nywVMLNjZ67ZdivXprdozr/cg5fc+Q5jwqPqSmWtiulICZdhqdGFt5FuuK0Yj5plbPcggOrlXOKv6ymmm5XO4B5V65dGLqjuplu1GfdV855ufDxpcMwLw8X+Yey4eBADLz/XS6wmEW+WXque+aSJiKgVGEqJiI5RDfbSTZQ2664DxdNlG2tLk3JVBm244Wa6bc9JgGtU2MplqGvB8gNp0qRH3v1GNph2iBO5b71jSFsVMnNPcpRwnsT2WSldfBOlrA8aOR4LkblvnbCOaWQca2RsqTfLrqsC14lWSgHAdS2Uhgve+FJRbH3NIQy/4KwwgEqhgMGXnI2V31mEoRc+o45WEhFRKzCUEhEdg+wT5+P4GTur9jc6njTNJsfGU6XJ0WenrOmZFui+/vSzsellfdDScGR/4YkerC5P8MdzauakR+FzxG1ZOHUgmFbYi0mF/bDFrZpIKEnSfkvcEa+ABnoKw5EQGm+PJYq+riHYdovbkxJOq4Jqju7DaWFV3UpAdR0LrmOFkyA5TmX5GNe1oK6FjW8axvALngGIwJ49ExtfNwx3Zyc6dw629rMTEVFNDKVERMegdS+fgl+cdH04ydFIRKIN5QJWDk+BA6mqkpoV0azq4r8vvwg9V3agvHlL1bHZ/3wHfrTtvLAamjTpkfes6iB4uLrz1jML7+EIpzO69njPQvo6prYoejuH6wqmiWNRa+yrWq7UEWMdUvNAzg2VgOq6AqdswSnZKA/bcEqVLrmq/ukq2PiGYex/9bnY9uzpAICJD1rAPY/k/dhERNQinOiIiIiqNDvJ0epyB9aXJiYGUnM5mKywZokL69bxcB6/I/NZfZaDkt9l07ybOZlQEEwdVEJREEyTJkGqRzzc2XCrlryJn+82MKFQKwKrAwuWKJyE55vtskXR01HCQQ2WW6lMUtTIZEhmyBTj3wDmpEdBpVMUYgcp07xH+nNFtDrlVjUCxqxLAtd/u+2SwVwVWiIiGjkMpURExyinrhF++VgAVpW6sMUZWxVIs4Ja1X3ExVX3vAKLfrEetRbyKAJh0LLEBdQC/GAYn+XWnJU33JcyO289kmbgbSZ8mm0+XF174wqWizFdQ3BcCwcOdeYKo0k/UdVrh3pfRVC9PIwrAATqKqyCa1wTe3b8nshuW3zcrHeRJIx/9V5uf/tSHJrm3bNrBzDlv7L/MEJERM1hKCUiOsYMvehsfOdtXx6ReweBdFjtMFhlhVEHVlW11BIXn1vxQpx45TqUd1SPe01ShAvXDybB3ew6gynQWNXUhjdO1Xu+lRpEzQpqrcBaTxBN7YbrfyfM77/rT/STtxJui8K2HYztPYQ9B3oSJ8fK3XW36rqsgwK3bCVWTJPPr3XYWy6mlh3nl7DzzHOhY0oQPxQ7XZ01ryMiouZwTCkR0THG6bZwSjH9P9DzBJa0RTMGtRgGUgdWGIgclaqt8rzor6Jbdp2GiS9fCydHIN0z3A0A6LMqEw0FY0tN8ZCXNM4USJ8IKWsM6pyO7Rhjp0+OU8+kR61iBn3ztSWKOb27qs5PrCQaLFGM7T1UtYpKLZXZcjO2SEPM/roCuBI9J89yMUmbK1DHXNom5XN2OcC4EsR2w/ZZw8nnEhFR6zCUEhEdg9ywilb5r/NmZt51VLG61IVtTl8lkCYE0Og1lWNmMHVUqmbaTVO6YDP+NDgDNmDMwGssAxMJZPmrj3ln6XUglYmWUp4bue+ITClVH0vcXCE0zrZc9PUMwrZdWAlVx4Z/etSf5MhNWF5GUbU+qXksPvtu5la24A7ZcIdt/3mIbup1KTa/N3qogOM/cWejn4yIiHJiKCUiOka5zYTQ2Ov1TifWlSdEAmnuexnnNjN+sijJ1dK0YJpWLTXlDafhs2JLw1SeOzJV0cTw2ETwrdXOou1g/JgBdHeW6q6aAl5X36rNNQJnzp8bTayeIrq5/uaIt7n+17JAB224AwW4B4uVbaAAt+x1G1bH22AprNMW1f9BiYioLgylRETHuGZqdw6ADeVurC9NbCiQJrEbDHBdiQEte0mWPME0r6TwWis0jmQX3rRnBs+1mvjsPZ3D6OkaDrvb1rvWaHiRXwlN/ftIwrGqQBq5l7+5lW67kXDqSuVYPMg6Aj1YAAZtYMjyNkvx5JvHQZednu8zERFRQxhKiYioYS6AjeXxcCB1za47koIuvEFVNB5M844vbUQzQa/uZ7WgSmpJ+nqltfR0Did24w1kT2QUfDUCbDxgGvvNbrqZ55vdfF2EoTcxvPrHxZXKphJ5j2EL2ulizSU9DKZERCNodPwXBBERHRaFObPxvE/+qSX3cgCsLEWXfolXSW3RcBtpwS80c2bdtO7ArQ6mkW7BYRgOQrBGvlZfe/iqpTa87sVTu/e35J59PUMQy/heJs7E63/JU0HV2Ouk8Gq+Tzsnc5+3iXohNHKf2CauQMoCZ4yLtS/pYVdeIqIRwlBKRHQM0Z4u/MPEh1p2vz1Ob9ht15QURNPCaSsCqy3i9dI0Qkh0wqPs8aXx8+u1oGMLilIZaVsraCZ1p61HM1VSGy667VLNyY5MaXGyYDsY13eoqj31VEkTz02oaFZNeJQ0e2+w3xynmkCSwmrSs4PnO0C5z8WqS8ejcPysjA9HRESN4DqlRETUkEeHJyas95ln8qCRrQzG1yGNr1NqyrOGaa1nAUCHOIlVWXNt0lqCYJe1fuloZFsuJo47gKFSAfsPdEcrojWqpBoLqNUnGAE08Wsd41fz7M96r4DT7UJ7uvI9k4iIcmOllIiIGhKEt1aMJQ2qfDbqm4DHXrwAvdYQHFXscoo1npE96VH8vFaq1YU36dxGj5vnpY0ZtaDosJ2WjoHtLJYxafx+dHSWvB1pVUwgX5iMh9vIll0JTXxm5NZ1fm6jSvvE2yfCXnhCfdcTEVEmhlIiIqopHuMGVOColVqBNAVjGWsJKo1TO/fBueAZudo16TtbcXbnTgDekjDFqsmNksNHrfVLcy0XEzvHhkZm4K23C6+p3vGntboDx8Npp1XC5M4DkXPq6c4LpFd0CwUHYml6n9+4tGoojPd5wmjKuND0x+ZoY8rxTRdNrXEhERHVg6GUiIgyubGvALC+3I+S1h4BYoal9GVZKkHSFheTigew8+TaXSQPvPo8PHPcqvD9BMtBjzgtmzgomMU37Vhc2qRKWeGznmDa6gmRLFFIRjXVVM+TezuHYduVz1Wz627iwRoTGTXTwMiEv34wFeNY/DECb+mbYPmboouerc0spERERHEMpURElFvwn+KOWnWNvQzEQ2rSMi3LD07HlK/ckXmf/a89D6/8xG/wsjErw33BNENZgTEtZKYFyqRragVVK1YxrTwjfxde85paobGeSZPMNvQWhtDfMZi7LfXo6RpG75hBQIwKbFa4TKqS5v02NZLVjfCpot5m+Zut0IJCi8bW4W+dLtDhYvMLyg08lIiI0jCUEhEdoyzx/qu83l8EeWtEZuCMLJkS684bD4Tnj12Jp75wXup9h150Nt74yZvxd2MfyWxbK8eGBlXTrHvO69yae4ymGRzrXVu0WcGzi+Kgyy6lHs9SazKmro4SejuHMbZ/AL19g+ldg3Mv45LRZbcZEtus4KtfGbX8zfa3ghuG2U0fWtbkw4mIKMBQSkR0jLHFXDYlO1wkxaVN5W4MaGf2MxKujIfTYJ93fiVdTLAP4Oq//h7evGINLl+xGsMXnV05/4yT8Kn/+jZeYVZI/X6g3sod9cycm9yWRvXKMGxxM8eVmu9bEUwPd6DNQ1XCraPgoKejhN6+wfTxm5HqqFTvS31Qkw01JXXbTXuW//rgTCfxVCIiqh9DKRER1SUr+OWZ1CgIp/FAaoY5W1xMtA/g1M7N+P41X8Q3190O+6SF+ObN1+D0Dm+CHvMpDoCSAo5KQ92Kzba1QrwL72gMj4FWzsCbNn60p6OEKZP2odhV9s/Lc7Pga0Z33/i+OiY6CiU1OS0cG23RMQ7WfYrVUiKiVqgZSkVkloj8XkSWi8hjIvJef/+nRGSjiDzkbxcb11wlIqtE5EkReeFIfgAiIqrDcAk3HZzU9G2cyNqebmoYjXbb1cQtzoUFRy0MahFrS+MwoIIeEXzv1/+NLhE4xjWOaiWQQuBC2rLOpxmyWxnysiR/v+sbr1oUF7ZVuU9SN9vcQztzfN+toFts1kOSKqc1H97gsUbv7Qdep0NhT57c5AOIiChPpbQM4AOquhjAeQCuEJGT/GNfVNUz/O2XAOAfey2AkwFcBOCrImKPQNuJiKhOzqo1+P8+8lpYsGp23W2lRsZ3OmqhBBurSxOw3RHsdRUuEG5mIPXeRz9PnopprSCdhxXprutXfw9jF97stqVPlOSqYFLnAYwpDtUVZpsJ/d2dwxA7mPiowfskLRlT7zV5jsXbF6/cKlCaWsLaty1AYdbMHI0gIqI0NUOpqm5W1Qf81/sBLAcwI+OSSwBcr6pDqroGwCoA57SisURENDokzS47UvdzIHi6PB5PlcZji2NjjwsMq6IEI5D6AbTZGYEDeYNp/DwzfDfShXcku/kmhVMzYDaz5EyeKikAlBw7XwhMPafG+yzNVEzjswMbwfTQ3GGsff1sBlMioibUNaZUROYAOBPA3f6ud4nIwyLyHREZ7++bAWC9cdkGJIRYEblcRO4TkftKGKq/5URE1DTLnPTIf92qri1mYEsLi/GJgeKCbsJe11wLm8pjsb7cj01OJ7Y4ndjudmK70409bgfcFld+zbGvke65sfem4zt2pNwr/5qjecblHg6tXhcV8NYw7e0bhFixZWICI93zuZX3N4LpwIJhlGY33y2eiOhYlTuUisgYAD8GcKWq7gPwNQAnADgDwGYAXwhOTbi86teAql6jqktUdUkR2bM4EhHRyGm0G68NTQ1nua7PuM41fj2ZwdSBoKQF7HLGYI/Tgz1ODw5qB/a7XdjjVn6XxCunrrZmXr9an3WifSDzc9UzDjRrrG4z40nrCchA9qS0jejpiC1Do2i8K2+rNFtxVWDNJd0ozDiuVS0iIjqmFPKcJCJFeIH0OlX9CQCo6lbj+DcB/MJ/uwHALOPymQA2taS1REQ0IizkW3/UUWCaPYD9bjcOGsvCtGrWWpMLC5bfqiCY2uIaVVc/aAZLdGgnBrUYdqG15PBWHG24YZi24I13taCAuHDUgiXa8HhMGy4c/95pn8lVaai6Oat7Nw6UOnGoXAz31dPWvF13Azv2jIE6CX8kiHeRTTue9j4vRXXSTvoIdX4vy5NKQEex9olERFQlz+y7AuDbAJar6tXG/unGaS8H8Kj/+mYArxWRThGZC2ABgHta12QiImpGz0/vwdlfvRJAY1VSCwjD4khzY7+mzFl/g8qpCyvcHLUwrDaG1UZJbQxqESUthJsDKwx3wWunvpEsiYKgGJltOCWoV86tL/TU2623nsrpSHTVTaNuzrVIGwzwogLJulZir4P3LiBDVvo26G1wU+49bOVc64aIiOLyVErPB3AZgEdE5CF/30cBvE5EzoD3a2UtgLcBgKo+JiI3AHgc3sy9V6gqV5gmIhotVAGFX4d0YYnA0WCt0MrrLOFYULWaWhe0EWbVFKh00bWhRqXSrQRYMxz6+1xYLavuxoOiJW4kPAdtje+LXtN4FXW0i0+mZNsu3GDkctUEQsHXxgNp9gmVl8U9NiyjJ3H/amD8d++s+YwtVy7DvpNKQDAu1g+2C74/jPLadfU3moiIaodSVb0dyR1bfplxzacBfLqJdhER0Qgau8bFDQdm4lVjvP+I9iqmGsYrG/C7nyZ36+2VYRxEJxxYsKEjGkzNbrwmR61INbJWOI12/UUYUIHGuh+nVS2L4qCU8us1Hj7N980G03rXKI0/K9gnorm75Gadl/RZXBWM6x/AHvSgNOB3dc3zrDq77mrS98J/THG3je6tgpk3bWgoRE770h2wrlgGp8t8HlDYvQ/8CzwRUWNyjSklIqKjS9/1d+GfL3opXvW8rzR0/VT7EPa4PSip92skK5g2skZpXvFgCnjhNHhmYuUU0YBqQ8OJkJLCaTCeM++SLpML+7HBLXqh168mx2cGNseItkIj3W8j66WG43BbU7GtdY9x/QPYI90oHeio7MxbJU35qLW67FqHLEy9B+h/6gD03kdQzn5KpilfuaNqHwMpEVHjGEqJiI5hVlALFaR24U2rllpwI91SRzJ8Zol35wWiVVMgGk7j18TDaVowrSV41rTCHmwYnpC7/a2slo4Geds/ru8Q9gowvM+YgT/p2jp/rOJV0tm3AMX9ZdiDZeCuh9v0U0pERFla92daIiI6oiz67H58dOuy8L0NifxSSFqv1DYyw6zC3jCY1it+TWWqouQtj6Qxm/HqbXDHpGsaXT7GhlYF8sRgOwIzFLfK7N5die0b6QmQ+nsH0dFf51rlGZnXDKRT/2xh8Zd2ovuWB2D/4QHgrocbayQREY04VkqJiI5RzuMrsPbAVGBqY9d3iYsOcTCYEuLyhLBWz+JbqztvrWuCc9MqpkD+inBlIqj6tKNa2m2XMo97I45bT0TR3zuIPY6F8v7mllMJAmnP+gKO//pyuAMDcIbqDLxERNQWrJQSER3DDj1nB35yYKZXJZVKELIlXyiaV9yVWC1NC6TxCmgwi6+5jYSkimnkeELFNEkjXZRtccMxm0Cl+mh2CW62Ipk2qVAzDtcyMSIKy3b9WWxzPjP+0Sx/63RxaIYDZ/duKAMpEdERg5VSIqJjmRut49U7C68NRa81hINuZ2q3yrRqaOo6nhId91mPekJt2qy+4fGMaqkpOMfs9msb38PDxVVpOEg2c20rjB1zCHtcQelQESghOrbU/LkymyjwlmWxFVOP24PuYgkFy8WqNVNRmHEcyhs3HZ7GExFR01gpJSI6xv3TvS9FSd2GqqUWgOPs/ZmV0bh4RTQYkxmvQtZbOW22yppULc2a4MgSNxJa61lWJqla2gqjYZKkRsPtuP4BTJ22B1ZvGdLjbVZvKbJJbzmyjZlyELNm7URXwZtL11XBwrlbsOaNc1r4iYiIaKSxUkpEdIybf9mDOOvL78fDr/wSgNrVUlsAx8gdtijGWQPY6Yyp+ayqbr7xIOq/N7vQtnOCIHMpGDvSBTdphl6FLQ56MYypxb3YVBoXBl0XUlflt5VLs9QKiUnPqWet0lZyVTB5wv7E9gSCz5PWOheSuxcwERGNDqyUEhERFn38cViw/EBakadaWoRisn0I4+yB1HPqrnqmVE8b1ch9IsEYGlZG44E03s4uKWOyvc87Jm7uMNrO7rNZ6m1Xs2E66XozIAfH461SFbj+NnzKAJwLntFUO4iI6PBhKCUiIjgHDuLZn3gvLFiwRKqWhwkE++xYbrCh6JJSddfcnGE0aymYZsNpM9eW1EZJkzsVJXY5RrDWqxs51sj42EbFQ109IdESHRXhuNlgO2/qDuyf3Vn7RCIiGhUYSomICHAdTHpgLwBEqqUWvGpp0pqlJgvARGsIfdag3421NTPpmmNSG5r5NuOa+HjXrPbGZ+RNCqNpz6r1fah3XKkDK9zS5A2m9YS/4MzDFVrjbUuqliad56rAhcB63Tbo+WeMaBuJiKg1GEqJiAgA4D70OJ7/vndjq1MOq6WmIJimVUsBYIZ9wKuY5giQWSHODLVJVdO0KmXWcVO966MGATB+3/j7oNIY2dfCFT7jQbTeYBrsM183Q+oIqKpStY0UVwX9HUMYHlsEci5vRERE7cNQSkREoTH/czde9bkP4dHhzkg33vjY0qRgGuzrkpK3BmlKQMxbVYxXXM1wGr9XPVXUtBmBzXsWxTG2MjoQXzonOYwGx7Lu32r1BNN69gH5qqL1BNO4VoXTcJxp7F5dH9yEwpzZTd+fiIhGFkMpERFFTPmvO/D2r78LDw71Vi0Rk9SNN14xnWwfQr81mBog8wjHZgahs0Y4zStPII22ww0nOTLbFN4vFkZtKKzYpEhuyjyx9XaDzQqfWd15a1VFW10xbdeY1KrKsP993/HM4wCrVgd0IiJqJ4ZSIiKqctxn78B7vvJ2PF2unvQo3o3XFOybbB+CLfnCY9o55ky3kQmEYuG0VkjNOicrkJrtiFdk4xMChfv9r/0yhAn2AQCHd5Ijc7xpPKQG4TS+pcmqgDYSPBupqDYSmNX4XKqCiX//NKyOYt33ISKiw4ehlIiIEk2/+g685ZPvgwOt6sabNb60EkwPhsE0NXgiOlOvd+9oeAnCqRkKkyZSyprBN65qluC07sQ5wmhYHYXCFm/rs0qYUqist5kWTEe6qlhrQiTzPFO8XaNhRt4kQavMsbKI7SMiotGPoZSIiFKNv/ZOvPId70NRrLqDaa+Uw2Dq7csXGE1e91lvK0o5Vzitec+EdUZNleqsi6I4kUBqXhOvjtqiRkhFOK42V5v878VIhb94BTWroprVhrSY18y40HonS6qHi9ZM6ERERCOLoZSIiDJ1/e+9eMnb3g0ADQXTidZA7WVR4lXPlOBow82snObZku4bPDMpkCaNG/U+X7Q6WgmjwOuX/x3e+4O3Zn7meiRVO9O64+btnhu/T/CZRlIzkyLFhV10Y++BaBdeAIDNMaVERKMZQykREWVTRef/3osXXfV+PFLqwV5X6wqmfVYJ46xDicGwnkpnEAg74CSG03pm4K2ePdfsyusF0g64ucJocDz4/Fdt+GuMedEadOwG9jtdme3Iu55o/Jx6qn95QqubMe61VvV2pKukWeuV5qEq2P/jqXVdQ0REhxdDKRER5TL2B3fh0/POwAt+8kFsday6gmlRol1h08Jo4nIqYffZShD1QmM0nAbn5tnCtsWqo8Fsu0EgjY8ZTQqjQSC1Bfjw+kuw+/xdgCqmffkOXPvHZ6XOvpuXWSVNC6OuWlVb3vNctZpuY6OaXQ4mXi0195mvR+uYWCIi8jCUEhFRXea/7y789c/el6tiGoTTPiljnDUYWVolLm2/A4lVMr0g2CXlSDgNxpzGu/4miZ8XjOkM1ii1JBpGvc+THEa90A28+tE3Yt8Fe2s+u9XqCaDhMUhkc1LCYZ6lXpKqnfWEwFasU1oLx5USEY1uDKVERFS3+VfehRdf+w8456b3owhBUSSyjmkQ1oBKOO2TMiZah6q63GZ1vQ2qhGnBqwNuGE69+7iR6mnaFgjO9157gbRLHBTh5gqjtniB9II/vRsTLtsFLZeb+bZmqu7qm14RBaqDZzyEmtvBcmdTbWt2rGitYNpMqHQhKNoOdr9hacP3ICKikVVodwOIiOjIdPwn7oTV1YXz9n4AD77hyxjQEiACqBdQHFSCqYsgmDqwMIDtbo+3PyFU5al0mjPiuiree3Fh+fe04cCpo0uqGUjNMGo+C4gGbQvAax7/OwzdOBUn3vI0yjt3Re458IpzseiU9ZnPDdof10gIy+qCm1QJDb73rgoGysXMZ5rtFHjdZdPafjgFFdlareiwHGy6+CDGXzvybSIiovoxlBIRUcPcwUHM+8yjuOQ3b8PqtwL3PfsrsMQLoUE4jZwPoNdyYctBbHe6wzThqpUYRoMqpgMBjHMceEE0CEVBBdOBAOL6wbTy/LSAap7jjXutXivVjM1Bd2QLwIfWvxTj3umivPpOJNVH98618bwJa0dkvGY8zMefkRVCK+8lvLaszc9OK6KRimdaaI2fF1CV1IprK8aEJvw4EhHRKMFQSkRETXH374f1fw9i4QN9eP2YV+DMWzbiPRPvQlGkshKpkQhcAF2imGwfwnanGw6SA2nis9QC/O6/QdCMd/0NqqZmCAvOyaqeDrhFFC0XHX7FNbzWCKIlBba7nfinZS+FDg/D2bk29X4q2dXLRmUF0ngYTQuiwXWOCgbKHSi7jY3mabRamhRM83YBrqersKsSDbRGJZ+IiEYP0VHwP879MkHPlQvb3QwiImoFEUhHB97/2AMAgIn2QRxfKMEF4BhdewFgv2thl9uVuA6njeQ1Ra2EamZcED7joSxPl14bXmAuGmF0Q7kbO91efOWlL4XzxKqawWbg5efiuZ+63XtmxrhPr43it80ylmgxgiasyL74hEXheZFZZ9Nn7A2ucVRQdm0MlDsw7NpwVbz1PRFdLkaNNkXWAk34DOb5ac+vV7xKmjT5ksTeW6LheZYoCuJCRLHikVlY8N67mmoPERE15rd64/2quiTpGCulRETUWqrQoSF8Yf7JAIC9l56H895/H1wVvGPS/2GirWGo6/CXd6ljidFQrYCZNQlQ9D7x4ApscXpwnD2ATU4Prtu5DPd8/UxM/PadAFbWvJ/V04P9s2xY0JZVSlsRSM0w6k2SJChnLAeTVAUdDeNIkyi8YGpWRs3uwK7f3ZuIiEYnhlIiIhpRY6+7C8uv815f/LUrMWbagbCadv7M1fjA1N9il9MFIF8lM238afycuPi9M2f2FeDeoRn42I//FnOvuhMTcWfNdoUWHI9XveV3NSukATPo5Q19SYE0TxgNznP9imjZtRoOmcGER7Xa3UyQbXQsaVW3XSIiGtUYSomI6LBZ+I57Iu+fuuAZ+Mg/j8FHZv0ynJwoLZg6RrUrTxU0/T5meEtf4/PeA/Mw96o6wigAq6sLqy4dh/MyKpD1SOrWHDleRyA1Z9utBNLWrwyXNpHRSKg3fHZMP4jyhWehcNv9I9gqIiKqF9cpJSKithkeV8AJY3Z4a38aY0XT1y3NDjsOJNyqj1mR6qgZyJKuO6t3LZ7+5/rWtpTubrzhot/XPM/OmGk4TRgqM74HeQNpMD40T3COTyzUSAVytFQt503eia1nN7cmKxERtR5DKRERtYX7rDPx0n+9DZeOr0w8Y3bLzQqmaZt33ErcwucmhNH4/QFgWmEvPv6aG7Duk8tyf6YdP5hUtc8Wt2oL9jcjXiWtJ5CaVdL4BEZpRkuwrFWFrflZRsfHICIiA7vvEhHRYWcvPAHv+M7/YE5hZ2Wf33XXMpZzyerOG6jVHTfr+qRxn2ZYnFXcicFp5dxLibxgxhPh6zwTHdniwlErc9xlveMx81RIk+7dSJdbc1xpZH9CF96RniQpmOwo9bgKMEqCNRERRbFSSkREh409dQoKc4/Hv/36h5FAGh6PLfuSJKkCWqs7rqNWuJW0EG4urMiW5L9f8C1subJ2N1576pSa5zQradIi76tUHU/tshvMvtviNVRbXUlNu1+tdUpHS0WXiIjyY6WUiIgOC+u0RVj2g4fw1/0PAYhW6cyKaFLFFKgxWy4SZteNnReEzrTKqQ31utfGgrElLg4ep7DHj4eze3fq5+u50UWPNdzysJdXPYG0WY1WPUeyWmreNSuYDo9T2JMnw9m+fUTaQURE9WOllIiIDost/4IwkALVwSFtDKm531UrrIAOq41htavGhQYV0fAavwqaVjkNzrVQHUgD33nl13Dw/AWpn23oRWdjfMehSpuDQAtN3RqVVCVNWoM0q0Ia358m+DfKqk6mhcFaFc2RUOv5rgoWLl2LXS844XA2i4iIaqgZSkWkS0TuEZG/iMhjIvJP/v4JInKriKz0v443rrlKRFaJyJMi8sKR/ABERDT6HXzVuXjR7MergmdaMK3VjTcIki4q3XHTwiiAqjAaZ0PRIQ4scWuugZpk+1sGML9nW13XBME0z4RH8epmzUAKQVktlN1gsyuBNEcYTW1zC4Jmnnvk7bobhuY6788evkREo0ue7rtDAJ6rqgdEpAjgdhG5BcArANymqp8RkY8A+AiAD4vISQBeC+BkAMcB+K2ILFRVZ4Q+AxERjXKbzxdcOv5uAJXAGQRFM0S4KpHgmjQzrqPR8Z+VWXftxGprrYmSAOCjj78MHf9vfNX+3YsE37n0K3j9b9+Gkx7cgMe/fg7svhJOuPTB8Jztb1+K82Y8UhV2s8JmpTqbPBlSUjdXF5LYNTceRuOh0xw/WtkX/drsuqJpEx6lyerG22gg5VhSIqIjV81QqqoK4ID/tuhvCuASABf4+68F8AcAH/b3X6+qQwDWiMgqAOcAqG8FciIiOirs+9vz8PEX/SSy708D8/HTv78w9Zot543Bte/9IgCkrt4Z77Lr7fMkBcKkCmlg96axWHjdXVX7J/T3459//gactG4dylu2YtHXx0ELlc63e/5uKc7++4cwr3tHzaBpCtpntskSBdQFxMoMpLXCKBAs81JZ1zQeQuOvzecEbalVSU07x9yfNAtv5PPmlKdCSkRERy7RHFPci4gN4H4A8wF8RVU/LCJ7VHWccc5uVR0vIv8F4C5V/YG//9sAblHVG2P3vBzA5QDQhZ6znikXt+ozERHRKCKdnbD6+6M7XQfOzl3p1xQ7YI3tw/L/mItrn/Mt2HDhwEJJbW8GXdgAot144yxU1gPNCqQAsN/txq7yGPzPP74Q3T+7J9fnGnrR2Vj2b3djbOFQpC1xYdAzx8bGArUbVIBV4MD7WlLbW1NU7dyBNB5GgeqqaPy1GRrNdqVVU7OCrSbsb6YKmzQuNDJuNGF/fBysJeptUIgoCpaLndccj/4fVv8RgoiIRs5v9cb7VXVJ0rFcs+/6XW/PEJFxAH4qIqdknJ7026fqt4qqXgPgGgDolwnsc0NEdJTSoaG6ZzrV0jCcHTux8M078WmcgbG3T8S7jrvNn5nXYwbSxEAY/DbK8RtmnH0Q4+yD+PDnv4er91+Kwm33Z19g2RicYNcMpAASJzUK9iVVVNMCaVmtlldHGwmMZiU0T0U1q1pa67qkZzfKhaROpkVERO1V1+y7qroHXjfdiwBsFZHpAOB/DWZ42ABglnHZTACbmm0oEREdu/Y+cyc+veYl4Xs7DHXRX2PxGXaTzgnvIW64md7/jesw/MLEP+R6LBv7/+ZsvPKqWyPPaYTlL0NTaX9l5twgkJZdu+5AmqRWIG3lUjbx8FjvTLwjMXNvMzMeExHRyMoz++5kv0IKEekG8DwATwC4GcAb/NPeAOAm//XNAF4rIp0iMhfAAgD5+kIRERGlsF66C1c89LqqEFkZT2p0iY0FU1NSEI1705d/lt6O3h686uO/8ZanMSuTxtYIVwVl1+uiXFYbJdf2Zs2tc/xosC/pa6CRQGoGRSvlddYsuCKaK2zmDaSNfJc5GRIR0eiU58+70wH8XkQeBnAvgFtV9RcAPgPg+SKyEsDz/fdQ1ccA3ADgcQC/AnAFZ94lIqJmuQMDmHPFDrzlj29s+B5mGLWhid05bSg+c92rU++x9gOnRtuV1AU3ZzgNxpKWXBtDbgFDbjEMpGnjRyPX5xxDaqq3K22rg1zmmqcZx7LaUW8bty5VFOYeX9c1REQ0cnJNdDTS+mWCnivpszASEREFCrNm4vFPTcOX/+qHkfGk8aVfbGMdUHPSIxsavo937X3vj/4eEx9V9P/4Pmi5nPj8ZX8ZRo89hJJb8O9RY5balG6jQSD1wqgXSIMQWna9iZxKaoWBNLgmackXsx1ZVdKkQJqnu2/SPVKPZ9zHFG9LrQppVeU15Zg50ZE5+ZEtbjjpUYdVxoGrZkD+/FDmM4mIqHWanuiIiIhotCiv34CT/rGED37xb/DZJT8O93uTIEW78AbB9HtbluHAlVOr7jU4rQcf/fJ3w3A65UEXPT+5O3X04ZofnY4X2n9CSb3QmLcaGhfMuDvoFsMuu1XrkMarosbkRanPqlElzdO2vNImPIqvWZo2GVIQQlWlqUCadF68q7H5hwF24SUiGn0YSomI6IhT3rIVpX2zq/bHgyngBcAdh8ag8/7Hqs7vFMGX7noWNl62CJ945w/w6n/5FW554lw4j69IfO5pMzdG3udZkzTOUS+EltSOjCFNW/YlLmt90ZGSd+3RQN5gGtyv2bbVs5+IiEYfhlIiIjoi2Qds7HO60GsNR/cbwdSB4OGB2eh8wdrkm6jC2bkL0750B6750jx/Z3IgtSdPRsFqfIqEoJtxPJAmBU9T3qpnq+VZ7qWe5WHy3K8ZaVXSNCqNTZZERESt1/g89kRERG10wgfuwreeflbNmXRbEYTsBfOw69qxOH/cU7BqPC9JUiB1UOmmmzWZUSPyVgnrWSYlMstunll0a9yjkefG72uOGTXbVes5rKISEY0uDKVERHTE2nH7dLzv968DUD2zbiuteNsUXDbn7vC9GUxrBTszkAYTFFXWI03+NezUO0Mu8oWxeuW5X9ryMFnn5w7NdQTS1HtAI2HVguL+lXNQ3LY/VxuIiGjkMZQSEdERa9a/3IGFl9+LT3779fjgza9PXPJlRudubLlyWdPPMgOkDY2sd2pBqzagOpAGYbQZ9QbPWhXOeqql9cr6pGnhNNhfbyCNf7as79PU2wpwVjyV0ToiIjqcOKaUiIiOeDP+4w7Y48fjc3ddCgAovXEXPrzg1wCAaYW9mPSSDcCXmniAVsaoBixx4aoFW9wwfCZxw/Gt+QOpLVqzWhqM0QzaEUy6VNmfMjtuwkRFQTBN6jqc5z71jC1Nun+W+J0a7ZpbCbL1d78mIqKRxUopEREdFZzduzHmf+7GmP+5G5OvGMKPtp4THhupCXaCgGNWTYGE5VyaeH5S99hmu+mmjQk1q7yt0sx3vt5AWktw/YS3rIN72ywUZs5o6n5ERNQaDKVERHTUKa9dh4MXD2H54HEAgLfMvh0rvnpOjauS7XzrUrz1ot9W7bdRu/LmTWKU/1dt9Zqa2WNX49W/+NjSrPGeWZMVxZ+Vdp+0mW6Tut7WE06Tzo/fM9f41fjn8N+fPHYzXjztEZzy842Yemc/pNgBWHYdLSQiolZiKCUioqOSu38/HtgzCwDQJSXYY0uwx42t+z5OUdBjDVetfwpUB1OzWpo3jFpQ2KJV4dauEfjydmOtFUyzqqbNSGpfrXBab3gNr8vxvYh/P1y1ML1jD57Rvw4XPbQNa647BYXjZ8Hq7W2gBURE1AyGUiIiOmodfPYOfP6p5+Pq1c/DeXPXYO0VJzd9z1rriuZlJQTRcH+NamlySI1WS+P3THodyBNM662Wpj0LqITP+JamFZM7BfsKlouiOHAQLMPj/Xu+87T/w/N/+QjWfuB0uM8+E+6zz6zrmURE1DhOdEREREcvVfS/yJtldcsFz8CEiU5Tt4sH0qTqaR423HCd0rzCCYz8CY0i+2pMemSeG38dCMJb0iRI8efFX6dNepT2rHo/d9a+1C7EsaVgAmOLhzDGHvL+LcWFDY38u7711b+C9Rov4P/g6hdBXKBv/TCKv72/4c9ARETZGEqJiOiYYP/hAbSqY2Y8jAahxlErcQbbVkkKhXmCqdfG9JBqSpudNymY5mln8D5oQ72fN8++rOPRCq8bdot21PL+vcT19htV4eDf82/f92tY4uKWLadg7bOXYu5N+6H3PVrXZyAiotrYfZeIiKgOZiA1u3+aY0iDcOqoFa5PGr2Htz+pK3BWcAsDZcpERFldedPGmKZ1561a97NGt+A864SmrUGadl7W88xnxu8bVEnTnuNCws3x/w3Tqt6uWnjh1Mfxjlfcgj3/PAj7xPmZbSciovoxlBIREeVgBkgzjAKVQBqGnIRZd70QKlXrlXrnBuMbJbLPfG78mlpqBdO84TRyz4QxrdltyJjh1wiS8S2PeNdcM5AmPgeVryYXgpLaKLkFOJCqLTxPLbx69gPo+uZe2BMn5GojERHlw1BKRESUU1I1LR5ITWYIjQdSNwyvlUDqBSTL2Fe5NnhGrUAa764KZE9YVCucps3Qm1R5TTuvFeuLBvcw25MWSNOqpAUrOrFU0IU3+ENCya0e1RQPp8+c8BQW/2YPICPXTZuI6FjDMaVEREQNMgNpIN5t1wyk4TmxQFr2g2h4zAihSRqZOChrXGh8zGfWGFDzPub1SZMexc+pt+1Z3XXj55iBNOl6S1y/WuoF0/gfEErqrVNacryvXVYpcXZkAJjSsR/AmNyfg4iIsjGUEhERtUCeSY6CcaRBIC27dmr33eD8WmpPOuSGXYDjwTR+fVY4jcywW2N237Rgat6zHulBM2Upm3j1F4qC5aK3MIwpHfurK9qxPyoAwKBbRFEc2P5ESA4kMhkSERG1DrvvEhERZRi/ahg3bzkt9Xg8iKZVSeOBND7JUdB9txzvsuu/Ttuq2pNYpYyudRrvzpt7fdEakw/Fu/KmrX+aV/weac9KqpJG2+iiIC56C0OZgRRApDvvkBYw6BYj3XotP6Tuef15jX8wIiKKYCglIiLKUPzNfVh7/8yqZUPi4aYRkSopkoNorvvkOD/eFTUtnCZNhpQ0bjRrnKopCJb1BNTE2X9rBNI4c4KjguWiYDkYWzgUmXk3q7Jtds0uqR35I0JRHJxyxSO5Pw8REWVj910iIqIakrKeLW5LgikQm1k39rBGxo+mCYKpGbCCUGcGtKz1UCP3SxmnmjZ+1AyaZvferMDa6Gy8QfsKlgMAKBr/XnbKWNH4v6ejVnhuSW0UxcnVFiIiqg8rpURERHWKd4dthXils55Kab2CLqiRfQmV0/hrcwZc8zrzvDxLzQT3qFVBrbVWaVq33UrV1/uMBXExqfNA+P00Z93NK/7vvGjMZqz41pLc1xMRUTqGUiIiohrmf+wBXLP8mQCQe7IbG24YjiqvvRlg7ZQ1NQMjFUajz0j+T4C0YBrfFw+mWdfVuwZp2jjXrG67VeudovK62y7BRlAljoZ9M5zGK6jm+/ixLilj8vS9kAI7nRERNYuhlIiIqAYdGoLrSlh5s/2lReJBxQucbq7wZfnn2bFzkycvsiJbLfHzk7Z6JVVOqyYiqjGBkrk/61jWs83nBM9PDqSVPwpM6jwAAHBghUvzJIVTwAufdsK/rdeO6L7L5tyDJ685A/a4sVXnEhFRfgylREREObirxmB3uTf1eFKIqVUtDV6nPjMlQLY6cEbunbAGaa3XacE0OC9PQM2zvIt5f3MMaWRyJiOQAkCHVQaAyDqxZjhthFktf/+5t2L9W09u+F5ERMSJjoiIiHKZ+9E7ccPQs/HGV90aTngTVs6MNUotKCAu4C8DY8MFxA9A6sIWwAkmD4IF21YccopVz2s2XDai1jqrQHQSo7S1Sc0JkJKuDa7P85zwfUIYjX8NAmmgIC6mdu6HDbdmCE2b/Ch4rqMWvvboX6G8qQcQ4Mrn31J51sj3tiYiOqoxlBIREeU0+5/uwA/3Ph9veusvAbXg+GnEFhdQC/BneDWDKQBAvWAahrhYOB0N8gRSkzkrL+CFzHgwzbp3ri7OqK7Gpk3AlNR1eFzHofCcPME0/kyTC8HEn/ag7/q7ABF8+90vDmdlnn7vwZr3JSKidAylREREdZj2n3fjZyufjx2nFPH3l/0KEBdusHSIH0wBRF/DggXHq5wK4PiVU0uTK4qmtOOtmvU36xl5qpnxpWOC8Ggu+RJva63PnBRGg2eYX4PXwflmt92xxUH0FQbDCY7yyP09VcXU/7wj932JiCgbQykREVE9XAed/3svZv2hF7+9+Swsf/84vHPp7yrHg263QUgFYIkDF14gBbwwGnQXXXdoQvUj/OuywpsLaWkwjT6/dmUzHkbjr9PWJAXyhb+kMJr92ui2a7notMphN+ugTfUE1LhWrUlLRETVGEqJiIga4B48CCxfiRPf1YnfFaYBloVT/u8AOq1yZT1MY6bXwI/vPAcnfujR8P3wTeMxuftA9f2NQGpeHxmXOYLBtJa0MGp25w1kBVRT0nqjae/DqmlCt92CuOi0SoltjTO7IAPVY0vNMHr+h+7GX54+HXLnX1I/AxER1Y+hlIiIqAk6NAQdGgIAPPwMALCTzgpfLcDdkXqdq5P8MajB++QwGt8Xhr8RCKbxEJc1M25aGE2b1Mjs3hsPoWnPS3sf77YbBNJh18Zje6djYf82jC8OeON8E8Jy3IbB8dg4MBYnj92MsYVDAKIhdWzhEC74xl24/cLZcLZvT70PERHVh31RiIiI2kSWnIJOu9zQtZHwCgm3VklaqsWCRjbzPPO6tHuZkgJp0nlV40drBNKdg7146nsLoc/diFt/fjaue+xsfyyvm/qMwJ9/cTqc52zCTb85D9977Fxc9+TZ6d8gIiJqGVZKiYiI2mT1By2c03WwqipZVgn3xSt78Qpk1VhPI5jmraCmLeESPyfruqSqabz9SdXK3OuTJoTRYL8lig7LwZ7hbuy8fhYmffNOAN5syQDw40+fD9cGylNK+Luz7kysnDpqYXDBIOyTFmLuR7zrrd5efPvqZ+GtS/8Yfs5v3vlXWDT4RNa3ioiI6iSq7RmLYuqXCXquXNjuZhARER1Wa64/DefMXgdX/UqnH0aH3UL4Ok2t6mTk3JzhtNZMv+ZkQuY6qvHrssZvZrYzpXqa1AazkhuE46f/ayH6f3RX6v0Lc4/H5ouOw8BzDuBVCx9KPOdHjyzBok/uRnn1Wu+aaVOx6RUnYO95g8DuDiz+9zUob9ma+TmIiKjab/XG+1V1SdKxmt13RaRLRO4Rkb+IyGMi8k/+/k+JyEYRecjfLjauuUpEVonIkyLywtZ9FCIioqPDlvcuw8JplXGJFjS1wpgkPvY06/y83Xrj3XOj3XSjEwB53WbdyHWVY9Vdf9P21zw3aIf/PEsUBcv1NnHD79uWT5+QGUgBoLzmaUz+2p2Y+88l/HrD4sRzXnfqfShNH1e5ZstWTPnqHVj0r3ux+LPrGEiJiEZAnu67QwCeq6oHRKQI4HYRucU/9kVV/bx5soicBOC1AE4GcByA34rIQlV1WtlwIiKiI9mBuS4mdx2AowLAinR9DYJWUtjMqopmdvUNutkmdcP1w6WbsuyJuf5n/Hnmtea9zW69SW3Mqoqa7YxXRsPX/vGC5WDjxxag83f3JbY9ifvoE5jyjpl4oHshFv9oDbrtUs1rnBVP5b4/ERHVp2alVD3BXPVFf8vqB3QJgOtVdUhV1wBYBeCcpltKRER0lJBCAWo1NnymrgppjWorEK2AVqqR0a1yPLnKaV4bHotVWuPXJG2R64zKaFogLauFpz+9CIXfPQDUORypvH4DnBVP4YkXT8a+chcOOJ0AqpeEISKikZdr9l0RsUXkIQDbANyqqnf7h94lIg+LyHdEZLy/bwaA9cblG/x98XteLiL3ich9JQw1/gmIiIiOIFZfH57+x3PwnHMeAwDYoohXIuNdZePiYbOeYNrIDL2JwbBGOE0LqFlbQZyqMBrcP3yOX0XeV+rC099YiK5f3FN3IDWVt2zFk0tKePiqM3D3zjm4Y8c8WEONzYhMRESNyRVKVdVR1TMAzARwjoicAuBrAE4AcAaAzQC+4J+e9Nuu6reFql6jqktUdUkRnQ00nYiI6Mhi9/dj/TtPxTMv/kvmeWlddFUFmjIrb7MV07R2ZAXSWuNDkwJq9P7xqmzys8zxpQXLwa6hHmy8YS7Gff/Ohj5XkuJv7oN14XpYF66H3vdoy+5LRES11bVOqaruAfAHABep6lY/rLoAvolKF90NAGYZl80EsKn5phIRER25rK4uPH3FKTj/lQ9W9vl/s7VrjK8EEIbR4LWqVHXfrdWdNzwvo1qaGgwz1ifNCq9JATVvt2Dz2R1WGZ12GQPlDmz5f8djylfvqPk5iYjoyFBzoiMRmQygpKp7RKQbwPMA/IeITFfVzf5pLwcQ/FnxZgA/FJGr4U10tADAPa1vOhER0ZFD+vrwzJc/WPtE+BMIGZ2MNCVoqgqkxnIwkXvWWjomYZkZSxSFyFIw0bbF8238OXmem/bsgh9ebT+YPnjtqejYp5h8XesqpERE1H55Zt+dDuBaEbHhVVZvUNVfiMj3ReQMeF1z1wJ4GwCo6mMicgOAxwGUAVzBmXeJiIg88RlugzU2K8crr4MZeIHk6qYF9SqmQENBME00FGp0ht34c2Iz7jbajshER/4zgzB67/+chskPDmHKH++Fljnek4joaFMzlKrqwwDOTNh/WcY1nwbw6eaaRkREdGyzJAid0XGkQYBzIanBtJFnmV8L4qJgOZGuxbY4/hI24VXhq1oBNfW5iD7XDKO/v/9kLP78FszY9he4Bw9mTv1PRERHrjyVUiIiIhphtcaCxseOxoNpq9sy6BbQBWDYD8R9BW+mfAuVyq0ZUi2JVYFrNMkMoQAw6BRRdi24amHo4gOA42Ch8yDKpeEWfjIiIhqNGEqJiIgOB9fB8t3TsHj8lrAbbN5JiZLOa7aLbhJLFAPlDqz59VzM/Pc7cNDfL4UC1t48J2zHtDH7MbVrf9iGoJKbGVLDZ1S6Aj+2fRpEFCKKvq+PRef/3tvSz0NEREcGhlIiIqLDwNm5C2PeNQ63f2Yenjlrdc1gaokLV+3D0jYz3D6+bjoW/Ht0ZlstlzH24lXh+y1vXIpHnlnyD3rtL/YN4dlzn0JBjKquMUHSIzunY/uGceF7KVlY8K67QURExFBKRER0mDgrV2PWv52M339wIZ5zwgp/rwUoEgOqhXzV1Lj8kwtFl2U5UOrE+Ntrrx0+/rt3Yvx3o/vsE+fj9tedntxtV4Ap95ex8OecjJ+IiKqJavunDeiXCXquXNjuZhARER0WcvapWPsPwLPneNVHVy0MuTaG3UK41qi3WThY7siopnoTAonEJwvKXve0MrmQW7mPKDYeGIsxF61u3QclIiLy/VZvvF9VlyQdqx7sQURERCNK730Ec/+5hAe3z/RmmhUXRaNqaQqWSKnaH9uXFUizBIHUEk1YdIaIiGjksfsuERFRG7iPPoHJb5uBp4tT4Uzqx/FfWQXLia5ZaomLzkIZh8rFSPfeRoJn+DpWJQ2UXQtj31YCVwElIqLDjZVSIiKiNilv2Ijymqeh9z6Cp5/lYvVXT4xULgEvRHbaXlQ09wfHgv3m1/B4yvnx48F40vK6Da3/kERERDUwlBIREY0COjSEzn0utg70RfZb4qIgLjrtciWEQsPX8fGkleti741AGq+SWlBYrx4ERsE8E0REdOxhKCUiIholun5+D3bcOqO6WuoH06LtwDYCpaR0480TSM1n3LVqLjBcavXHISIiyoWhlIiIaBSZ+EgJy7dPDd+bAbMgLgqWC9tyIxXSSBfdOgOpBcXCLw3B2bdvRD4PERFRLQylREREo0jnLfdi/4Z+FMSNjBUNAmUQTOPV1OC88LXRxdc75iaec//vFsHasG1EPxMREVEWhlIiIqJR5sSv78X2Dx+PA6XOxGBqQauCqTkxUjyMxgNpcP59f1yEE/7rKTjbtx/Oj0dERBTBJWGIiIhGGffRJ2ABkDfPgfX9QW+fih8q/TGlannLxPhLyFTPrOsar6PVVEsU9zy4AIv+43E4e/aO6GchIiKqhZVSIiKiUaq8ei32X9aPfcNdGHSKVZMfWeJGKqPhvoxACgD3PDUHC6+8n4GUiIhGBYZSIiKiUay8ei30uRux98uzsf3QmKouu/Egmtil13i//dAYLPi7B6Dlcjs/FhERUYjdd4mIiI4APT+9G3v6luK+c11AgTNOWx2OK3VVqs5PWrfUgmLdI9MxH08frmYTERHVxFBKRER0hBj3vTsx7nve65X/sAxqA4emuDj73BUAEAmn8VB6/59PRMduwfzP3HnY2ktERJQHQykREdER6LjP3QEAKMycgbXPXoggg3a+cQuO642OFb3/D4uw4D+fgrOVS78QEdHow1BKRER0BCtv2Iix120M38vKU7G9c1zknPmrVqPMQEpERKMUQykREdFRRO99pGoWQ05pREREoxln3yUiIiIiIqK2YSglIiIiIiKitmEoJSIiIiIiorZhKCUiIiIiIqK2YSglIiIiIiKitmEoJSIiIiIiorZhKCUiIiIiIqK2YSglIiIiIiKitmEoJSIiIiIiorZhKCUiIiIiIqK2YSglIiIiIiKitmEoJSIiIiIiorZhKCUiIiIiIqK2YSglIiIiIiKitskdSkXEFpEHReQX/vsJInKriKz0v443zr1KRFaJyJMi8sKRaDgREREREREd+eqplL4XwHLj/UcA3KaqCwDc5r+HiJwE4LUATgZwEYCviojdmuYSERERERHR0SRXKBWRmQBeDOBbxu5LAFzrv74WwMuM/der6pCqrgGwCsA5LWktERERERERHVXyVkq/BOBDAFxj31RV3QwA/tcp/v4ZANYb523w90WIyOUicp+I3FfCUL3tJiIiIiIioqNAzVAqIi8BsE1V7895T0nYp1U7VK9R1SWquqSIzpy3JiIiIiIioqNJIcc55wP4axG5GEAXgH4R+QGArSIyXVU3i8h0ANv88zcAmGVcPxPAplY2moiIiIiIiI4ONSulqnqVqs5U1TnwJjD6naq+HsDNAN7gn/YGADf5r28G8FoR6RSRuQAWALin5S0nIiIiIiKiI16eSmmazwC4QUTeDGAdgL8BAFV9TERuAPA4gDKAK1TVabqlREREREREdNQR1arhnoddv0zQc+XCdjeDiIiIiIiIRsBv9cb7VXVJ0rF61iklIiIiIiIiaimGUiIiIiIiImobhlIiIiIiIiJqG4ZSIiIiIiIiahuGUiIiIiIiImobhlIiIiIiIiJqG4ZSIiIiIiIiahuGUiIiIiIiImobhlIiIiIiIiJqG4ZSIiIiIiIiahuGUiIiIiIiImobhlIiIiIiIiJqG4ZSIiIiIiIiahuGUiIiIiIiImobhlIiIiIiIiJqG4ZSIiIiIiIiahuGUiIiIiIiImobhlIiIiIiIiJqG4ZSIiIiIiIiahtR1Xa3ASKyHcBBADva3RaiOk0Cf27pyMSfXToS8eeWjkT8uaUjVat/do9X1clJB0ZFKAUAEblPVZe0ux1E9eDPLR2p+LNLRyL+3NKRiD+3dKQ6nD+77L5LREREREREbcNQSkRERERERG0zmkLpNe1uAFED+HNLRyr+7NKRiD+3dCTizy0dqQ7bz+6oGVNKREREREREx57RVCklIiIiIiKiYwxDKREREREREbVN20OpiFwkIk+KyCoR+Ui720MUEJFZIvJ7EVkuIo+JyHv9/RNE5FYRWel/HW9cc5X/s/ykiLywfa2nY52I2CLyoIj8wn/Pn1sa9URknIjcKCJP+P/bu5Q/uzTaicj7/P9OeFREfiQiXfy5pdFIRL4jIttE5FFjX90/qyJylog84h/7TxGRZtvW1lAqIjaArwB4EYCTALxORE5qZ5uIDGUAH1DVxQDOA3CF//P5EQC3qeoCALf57+Efey2AkwFcBOCr/s84UTu8F8By4z1/bulI8GUAv1LVRQBOh/czzJ9dGrVEZAaA9wBYoqqnALDh/Vzy55ZGo+/C+7kzNfKz+jUAlwNY4G/xe9at3ZXScwCsUtXVqjoM4HoAl7S5TUQAAFXdrKoP+K/3w/uPoxnwfkav9U+7FsDL/NeXALheVYdUdQ2AVfB+xokOKxGZCeDFAL5l7ObPLY1qItIP4K8AfBsAVHVYVfeAP7s0+hUAdItIAUAPgE3gzy2NQqr6RwC7Yrvr+lkVkekA+lX1TvVmzP2ecU3D2h1KZwBYb7zf4O8jGlVEZA6AMwHcDWCqqm4GvOAKYIp/Gn+eabT4EoAPAXCNffy5pdFuHoDtAP7b73r+LRHpBX92aRRT1Y0APg9gHYDNAPaq6m/An1s6ctT7szrDfx3f35R2h9Kk/sdco4ZGFREZA+DHAK5U1X1Zpybs488zHVYi8hIA21T1/ryXJOzjzy21QwHAMwB8TVXPBHAQfjeyFPzZpbbzx99dAmAugOMA9IrI67MuSdjHn1sajdJ+VkfkZ7jdoXQDgFnG+5nwujwQjQoiUoQXSK9T1Z/4u7f6XRfgf93m7+fPM40G5wP4axFZC29IxHNF5Afgzy2NfhsAbFDVu/33N8ILqfzZpdHseQDWqOp2VS0B+AmAZeDPLR056v1Z3eC/ju9vSrtD6b0AFojIXBHpgDeY9uY2t4kIAODPJPZtAMtV9Wrj0M0A3uC/fgOAm4z9rxWRThGZC2/g9z2Hq71EAKCqV6nqTFWdA+9/U3+nqq8Hf25plFPVLQDWi8iJ/q4LATwO/uzS6LYOwHki0uP/d8OF8Oag4M8tHSnq+ln1u/juF5Hz/J/5vzOuaVih2Rs0Q1XLIvIuAL+GN1vZd1T1sXa2ichwPoDLADwiIg/5+z4K4DMAbhCRN8P7ZfQ3AKCqj4nIDfD+I6oM4ApVdQ57q4mS8eeWjgTvBnCd/4fq1QDeBO8P6PzZpVFJVe8WkRsBPADv5/BBANcAGAP+3NIoIyI/AnABgEkisgHAJ9HYfx+8A95Mvt0AbvG35trmTZpEREREREREdPi1u/suERERERERHcMYSomIiIiIiKhtGEqJiIiIiIiobRhKiYiIiIiIqG0YSomIiIiIiKhtGEqJiIiIiIiobRhKiYiIiIiIqG3+fw2xMG3yFdcLAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x1152 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "valid = sign_dist_linear(start, norm, better_travel) < 0.1\n",
    "image = better_travel.copy()\n",
    "image += image[valid].max() - 2.0 * image[valid].min()\n",
    "image *= valid\n",
    "\n",
    "plt.figure(figsize=(16,16))\n",
    "plt.imshow(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambertian Shading\n",
    "\n",
    "(This is optional, and confers no marks. An extra challenge for those who want it.)\n",
    "\n",
    "Rendering depth is pretty dull; it looks much better if we shade the surface. The simplest shading is the _Lambertian reflectance model_; whilst simple it actually looks pretty good. The equation is:\n",
    "```\n",
    "brightness = max(normal.dot(light), 0)\n",
    "```\n",
    "where normal is the surface normal of the model and light is a unit vector pointing at the light source. You can select any light vector you want. The normal is the gradient of the sdf, which will need to be scaled to have unit length.\n",
    "\n",
    "Your challenge, if you choose to accept it, is to rewrite the visualisation code to shade the surface."
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}