{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Error bars" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.core.display import HTML\n", "css_file = 'https://raw.githubusercontent.com/ngcm/training-public/master/ipython_notebook_styles/ngcmstyle.css'\n", "HTML(url=css_file)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$$\n", "\\newcommand{\\dt}{\\Delta t}\n", "\\newcommand{\\udt}[1]{u^{({#1})}(T)}\n", "\\newcommand{\\Edt}[1]{E^{({#1})}}\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We're starting from Euler's method, which is first order. That means that the difference between the exact solution $u(T)$ and the numerical approximation $\\udt{\\dt}$ should be proportional to $\\dt$: that is, \n", "\n", "$$\n", "\\begin{equation}\n", " u(T) - \\udt{\\dt} = c_1 \\dt + {\\cal O}(\\dt^2) \\simeq c_1 \\dt^{s_e}\n", "\\end{equation}\n", "$$\n", "\n", "with $s_e=1$. The problem is that the measured slope $s_m$ will be \"contaminated\" by the higher order terms, proportional to $\\dt^2$ and higher powers of $\\dt$. For sufficiently small $\\dt$ the measured value $s_m$ will be indistinguishable from the expected value $s_e=1$. However, we rarely get to use a sufficiently small $\\dt$. So how close does $s_m$ need to be to $s_e$ to be close enough?\n", "\n", "One argument that can be justified: $0.585 \\lesssim s_m \\lesssim 1.585$ is close enough when $s_e = 1$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Error bars and Richardson extrapolation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The argument starts by noting that what we care about is not the algorithm, but the solution $u(T)$. From the solution of *any* numerical algorithm we cannot compute $u(T)$ exactly, but only estimate it with some error. Given a set of numerical calculations - $\\udt{\\dt}, \\udt{2\\dt}$ for example - and a model of how the algorithm behaves, then both the exact solution *and* the error bars can be estimated. \n", "\n", "**Claim**: if two models estimate exact solutions that lie within each other's error bars, they are indistinguishable. Hence, if the model corresponding to the *measured* slope is consistent with that of the *expected* slope, the algorithm implemented is close enough." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To make this concrete, we need a model of the algorithm. The simplest models are\n", "\n", "$$\n", "\\begin{align}\n", " u(T) - \\udt{\\dt} & = c_e \\dt^{s_e}, \\\\\n", " u(T) - \\udt{\\dt} & = c_m \\dt^{s_m}.\n", "\\end{align}\n", "$$\n", "\n", "Using [Richardson extrapolation](http://en.wikipedia.org/wiki/Richardson_extrapolation) we can estimate both the solution $u(T)$ and also the error $\\Edt{\\dt} = u(T) - \\udt{\\dt}$. For Richardson extrapolation we perform two numerical calculations $\\udt{\\dt}$ and $\\udt{2\\dt}$ and combine them as\n", "\n", "$$\n", "\\begin{align}\n", " \\udt{e} & = \\frac{2^{s_e} \\udt{\\dt} - \\udt{2\\dt}}{2^{s_e} - 1}, & \\Edt{e, \\dt} & = \\frac{\\udt{\\dt} - \\udt{2\\dt}}{2^{s_e} - 1}, \\\\\n", " \\udt{m} & = \\frac{2^{s_m} \\udt{\\dt} - \\udt{2\\dt}}{2^{s_m} - 1}, & \\Edt{m, \\dt} & = \\frac{\\udt{\\dt} - \\udt{2\\dt}}{2^{s_m} - 1}.\n", "\\end{align}\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The models are consistent if\n", "\n", "$$\n", "\\begin{equation}\n", " \\udt{e} \\in \\udt{m} \\pm \\Edt{m, \\dt} \\quad \\text{and} \\quad \\udt{m} \\in \\udt{e} \\pm \\Edt{e, \\dt}.\n", "\\end{equation}\n", "$$\n", "\n", "That is, if both models predict the same exact solution, within their own error bounds, then we can't tell the difference between them, and they're close enough." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Checking the MOOC solution" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can use this criteria to check the result from [the full phugoid model notebook](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb).\n", "\n", "Let's take the code from there directly." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": true }, "outputs": [], "source": [ "from math import sin, cos, log, ceil\n", "import numpy\n", "from matplotlib import pyplot\n", "%matplotlib inline\n", "from matplotlib import rcParams\n", "rcParams['font.family'] = 'serif'\n", "rcParams['font.size'] = 16" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# model parameters:\n", "g = 9.8 # gravity in m s^{-2}\n", "v_t = 30.0 # trim velocity in m s^{-1} \n", "C_D = 1/40. # drag coefficient --- or D/L if C_L=1\n", "C_L = 1.0 # for convenience, use C_L = 1\n", "\n", "### set initial conditions ###\n", "v0 = v_t # start at the trim velocity (or add a delta)\n", "theta0 = 0.0 # initial angle of trajectory\n", "x0 = 0.0 # horizotal position is arbitrary\n", "y0 = 1000.0 # initial altitude" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": true }, "outputs": [], "source": [ "def f(u):\n", " \"\"\"Returns the right-hand side of the phugoid system of equations.\n", " \n", " Parameters\n", " ----------\n", " u : array of float\n", " array containing the solution at time n.\n", " \n", " Returns\n", " -------\n", " dudt : array of float\n", " array containing the RHS given u.\n", " \"\"\"\n", " \n", " v = u[0]\n", " theta = u[1]\n", " x = u[2]\n", " y = u[3]\n", " return numpy.array([-g*sin(theta) - C_D/C_L*g/v_t**2*v**2,\n", " -g*cos(theta)/v + g/v_t**2*v,\n", " v*cos(theta),\n", " v*sin(theta)])" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": true }, "outputs": [], "source": [ "def euler_step(u, f, dt):\n", " \"\"\"Returns the solution at the next time-step using Euler's method.\n", " \n", " Parameters\n", " ----------\n", " u : array of float\n", " solution at the previous time-step.\n", " f : function\n", " function to compute the right hand-side of the system of equation.\n", " dt : float\n", " time-increment.\n", " \n", " Returns\n", " -------\n", " u_n_plus_1 : array of float\n", " approximate solution at the next time step.\n", " \"\"\"\n", " \n", " return u + dt * f(u)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we're going to compute the result at a specific time and do the convergence test. We'll use an end time of `T=100` as in the original notebook, and convergence test on `v` as an example." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [], "source": [ "T = 100.0\n", "dt_values = numpy.array([0.001*2**i for i in range(3)])\n", "v_values = numpy.zeros_like(dt_values)\n", "for i, dt in enumerate(dt_values):\n", " N = int(T/dt)+1\n", " t = numpy.linspace(0.0, T, N)\n", " u = numpy.empty((N, 4))\n", " u[0] = numpy.array([v0, theta0, x0, y0])\n", " for n in range(N-1):\n", " u[n+1] = euler_step(u[n], f, dt)\n", " v_values[i] = u[-1,0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We now have three calculated values of `v` using parameter values `dt=0.001, 0.002, 0.004`. As in the original notebook, we can measure the order of convergence using\n", "\n", "$$\n", "\\begin{equation}\n", " s_m = \\log_2 \\left| \\frac{\\udt{4\\dt} - \\udt{2\\dt}}{\\udt{2\\dt} - \\udt{\\dt}} \\right|.\n", "\\end{equation}\n", "$$" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Measured convergence rate is 1.023.\n" ] } ], "source": [ "s_m = log(abs((v_values[2]-v_values[1])/(v_values[1]-v_values[0]))) / log(2.0)\n", "print(\"Measured convergence rate is {:.4g}.\".format(s_m))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As in the original notebook, this is close to one, but not exactly one. So we now use the two most accurate data points with our two models, with *expected* convergence rate $s_e = 1$ and *measured* convergence rate $s_m \\simeq 1.023$. We compute our exact solutions and error intervals." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": true }, "outputs": [], "source": [ "v_exact_e = (2.0*v_values[0] - v_values[1])\n", "v_exact_m = (2.0**s_m*v_values[0] - v_values[1]) / (2.0**s_m - 1.0)\n", "error_e = abs(v_exact_e - v_values[0])\n", "error_m = abs(v_exact_m - v_values[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then we check if they are consistent:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Does the expected solution 29.8693 lie within the interval [29.86798, 29.87053]\n", "from the measured model? True\n", "Does the measured solution 29.86925 lie within the interval [29.86798, 29.87061]\n", "from the exact model? True\n" ] } ], "source": [ "print(\"Does the expected solution {:.7g} lie within the interval \"\n", " \"[{:.7g}, {:.7g}]\\nfrom the measured model? {}\".format(\n", " v_exact_e, v_exact_m-error_m, v_exact_m+error_m, \n", " v_exact_m-error_m <= v_exact_e <= v_exact_m+error_m))\n", "print(\"Does the measured solution {:.7g} lie within the interval \"\n", " \"[{:.7g}, {:.7g}]\\nfrom the exact model? {}\".format(\n", " v_exact_m, v_exact_e-error_e, v_exact_e+error_e, \n", " v_exact_e-error_e <= v_exact_m <= v_exact_e+error_e))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So the two models are indistinguishable: $s_m \\simeq 1.023$ is *close enough*." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Finding the limits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So, how different can $s_m$ be from one and still be close enough? First, let's do this experimentally, by plotting the intervals as we vary $s_m$:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAggAAAGYCAYAAAAnchq9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xl8Y1d5//HP40Ve5HU8nn3JJGTfQ1hCAiQhhL2UBChb\n", "ScLaUqD8WgoFCqGlUGjTUgiUAgVCSqFA2VtaEiCBkrAlJclkT8jsM54Ze7zKsuTl+f1xrmY0smxp\n", "Zmxf2fq+Xy+9FF+de/VInlhfnXPuuebuiIiIiOSribsAERERqTwKCCIiIjKNAoKIiIhMo4AgIiIi\n", "0yggiIiIyDQKCCIiIjKNAkIVMrPnmlmPmX0h7lpERKQyKSDkMbMmM3uDmf3MzO4zs/vN7Kdm9oIj\n", "OMbrzOxuM3vAzLaa2T+bWUeRds+Mjn1vdPuJmV02wzGvjNreYWa/NbNfm9mrjvL1fRJ4P7AC0CIY\n", "IiJSVNUFhOhD+6oZHn4h8DHgXe5+urufBnwb+I6ZvaaMY78H+ATwJnc/FTgLOBv4vpnV5LV7IvB9\n", "4H/d/Qx3PwO4DfgvM3tCwTH/H/AB4Pfd/XzgZOBh4NIjeuHBlUA/8JSj2FdERKpI1QUEwrfmmb45\n", "O/B1d//fgxvc/wHYAbxttoOaWRJ4D/ANd78t2ncIeC/wZOAlec1fDNQCf5u37W+BeuCKvGMeB/wN\n", "8BZ33xYdcwJ4O/DJ2V9mUV9297+IjiEiIjKjagwIs/kacE2R7T3AtGGCAqcDjcB9Bds3R/e/k7dt\n", "PLqvz9uW++/8D+/fj37+cf4B3X2Pu9+Zv83MnhYNjTxiZo+Z2ZfMbFXBflMlXoOIiAiggHAYDybz\n", "t5lZLXA8cGuJ3VPRfeF7mvtQPjlv26eBPcBfmVmdmdUThhF2Af+c1+4pwE7guWZ2SzQn4vbC4Q4z\n", "uxD4IfBtdz8ROAloAn5kZokSdYuIiExTrQHBjqDtFYQP278q0e5RYAQ4r2D7OdF9W26Du28HLgPO\n", "Bw4AvcC5wDPdfVfevuuj2/uBV0ZzIq4DPm1m785r9xFgl7tfFx1/Ang3cCrw8rJepYiISJ4lHRDM\n", "7Hwz+03+DVhD+Oaev/0zM+y/Gvgo8Dp3f3S253L3DOGD/AVmdoUFa4APAaNAOu+4FwG3A98DOoFl\n", "wFeBX5jZJXmHbSSEk/e4++7oeb4JfAd4t5k1mlkzcAHwi4KSHiYMT1xc4m0SERGZxqrtcs9mtgW4\n", "1t1vLNGuA7gF+Jy7f+IIjv964LVAO2EY4W8J3/q3uvvzoza/Ajrc/aSCff8PaIrOgCAKNGcBq919\n", "X167vyD0aJwP7AO2E3oh8nsfALqBn7j7K4vUOQXc4O4lz84QEZHqUxd3AZUoCgc3AV84knAA4O6f\n", "BT6bd6waYCPw5bxmZxLCR6FHgJeYWb27jwMPEk6TLOzpyc2TqCEMUUwB33X31x1JrSIiIjNZ0kMM\n", "R8PM2gnh4Evu/vG87d8taJcws66CbedHwxL5LiYEsX/N27aXEBoKbQT6o3AAkHvOswranUEYtrjP\n", "3UcJwxXnFLTBzP7UzF5a5HlERERmpYCQJy8cjAJ9Zvaq3I2wlkG+7wE7zGxD3rY3A38XnfmQW8fg\n", "euCd7r4jr93HgVPN7A15z/1K4IlR+5yvAr8GrjWztqjdRYQFjz7o7rl5De8AzjCzN+Yd72LgT4Ff\n", "zfaSZ3lMRESqmIYYDncV8ATCgklPK3iscLLGHsK4fzpv2w+BPwYeMbN+QtB4bzSx8NCB3P/BzHYD\n", "f2xmb402p4DXuPsNee2mzOzZhLMUNptZGsgAf+Tun8trl5vc+CEze1dU117gue6+NdcumtCYW6fB\n", "gRdHQeK77v7Hpd4cERGpHlU3SVFERERK0xCDiIiITKOAICIiItMs6TkIZqbxExERqSruPicT0Jd0\n", "QIC5e6MqkZm9393fH3cd82Upv76l/NpAr2+x0+tbvObyi7GGGERERGQaBQQRERGZRgFhcbs17gLm\n", "2a1xFzCPbo27gHl2a9wFzLNb4y5gnt0adwHz7Na4C1gMlvQ6CGbmS3kOgoiISL65/NxTD4KIiIhM\n", "o4AgIiIi0yggiIiIyDQKCCIiIjLNkl8oSUTKo5VHRSrfQk68V0AQkYN01o9I5VroEK8hBhEREZlG\n", "AUFERESmUUAQERGRaRQQREREZBoFBBEREZlGAUFEqp6Z3WNm+8xsyswyZrZnhlvGzK6Ku96lyMx6\n", "zGwg+h0c1XtsZq+Ofk9ZM5ua6xqrjQKCiFQ9dz8LeEL0423uvrrYDbgdqLj1Iszs/dEH69PiruVo\n", "ufsq4I9zPx7lMW6s5N/TYqOAICISaA2I+Ol3UEG0UJKISPme4e6V3HWtD1iZM+pBEBEpwcxuMLNr\n", "88OBmX3HzIajrv1hM/titP0TZtZvZuNmttvMzoy2rzezD5nZnWa2Mxpvv8/M/tzMin5ZM7Nzzewb\n", "eXMgHjGz75rZ1WZWG916gD+NdvlmXtt3lXhN95hZX1T/tWZ2jZndbWYjZnaXmb0wavcHUdtBM/uV\n", "mT1lhuOdaGY3Rq+tx8y2mdmnzGx1kbb10bDI1qiG+83s7czymWRmJ5vZl81sb7TPVjP7JzNbOdvr\n", "lKOngCAiUp7DxrTd/YXA44FRYC/wR9H2NwM/B97h7mvcfXO0yzMIY+zvdfd17t4BvAt4L3Bj4ZOZ\n", "2bOj44wBJ0dj65cCrcDngbXuPhmN3V8X7faivDkTfzPriwnzLq7I7Qe0AecC64As8A0z+3ugETgH\n", "OI7wmfGfZtZaUOvjgTuAlcB5UU1PB84H7jSz4wqe/sbodX/A3buA84AEh4JO4XvxeOBXQCdwRrTP\n", "86P341dmtny21ypHRwFBRORwFxaevQC8tFhDd3+Y8KF2PPBPAGb2VqDW3T9a0LwP+Dt3/37e/t+N\n", "9nuZmZ2U225mzcAXgQHgNe4+FLXfAVzF9Al4Rzu0kNtv0t0/5u5T7j4A/DPh8+Fid//HaHs/8Cmg\n", "A3hOXq0GfAFoBl7n7vuiWrcCbwFWRfvl2l8K/B7wH+7+uajtmLt/KHqPDi8wHP8GoBb4fXffH+1z\n", "L/A2YD3wF0f5+mUWmoMgIkfN/nLhrwDp1877BaVuc/dL8zeY2ReY4UPY3T9tZs8DXmVmW4DXAE8s\n", "0u57wPeKHOKB6P4s4OHov58JdANfdvdMwXG2m9kzgH3lv6SSfl7w884S29fnbTsbOAP4dRRgDnL3\n", "X5jZPuCZZrbM3Q9wqNfif4rUcRNwUcG2s4HTgZ+4e2/BY7+K7p9PCAsyhyqmB8HMaszsHTrPWEQq\n", "1Gxh6LWED+z3Au9z9z2FDcyszsxea2a3mtmWaJx+D/APUZPmvOYnR/c7KMLdb3X3sSN/CTMq/ODN\n", "zrA9F1aSedtyPR+7Zjj2LsJnTa7d46L73UXaTnvfOPRePKlIz859QIow9CBzrGQPgpmtAD5KGGsD\n", "2Ay8zd1n+seQv2898D7gxcAEMEQYl7utoN0GwphUEqhnlv8Rzawb+CvgyYQupzbgl8Ab3H2wVE0i\n", "MncW4Nt8RXD3a0o8vt/M7iWMib/azG5w98K/Y58HXgW8B7je3UcAoi9EX5jh0A3HVnnZZjozYz7P\n", "2Cj3teXex/9x9ytmbSlzatYeBDNLADcTgsRp0S0F3GJmydn2jVwPvAS4yN3PJPwPcpOZnV3Q7m2E\n", "Maq3l6hnOaHL67fufm40yeZFwO8A7WXUIyIy58zsjwiT7K4nTM57R8Hj7YRw8KC7/00uHOQeLnLI\n", "3LDD2hmeb02Zf4MXwoPR/boZHl9LCBq54ZNH8rYXWjPL8dcXeSx39sS0IR05dqWGGK4CzgTeGU1S\n", "mQLeSZiQ84ez7WhmJwOvBz7s7n0A0YSULcAHC5q/3d2/SumJNh8E9rh7bsYu7v4b4HnA/hL7iojM\n", "puR8CjP7nJm9t2DbqcC7gVcCf0boZf0rMzsvr9k4MDnDc2wqsu1mwpkRz4omLOY/3+mEuQCn5m1O\n", "Rff1uZrM7DoWgLvfQ3jN5xWerWBmFwArgB9E8w8Avhndv6DI4S6b5fjnmtkJBcc34KvAy47hJcgM\n", "SgWEK4Ft0WxUANx9L3B/9NhsXkT4wL+lYPstwOX5/+jLWXjEzJoI/wP+Z+Fj7v5jd0/PsGNXqWOL\n", "iHDoC8psX1Rqyfu7GfWy/hvwJ+6+w92zhL9TU8C/RX+3cPdR4FvAqdFcq9wH+SXAWwufN5pfcDWh\n", "G/6fzawtan8CYUb/f7j7HXl13R3dnxPdv5LQk1GumV5zuduvAUaAf8mtSxCFhesJ8wrelGvo7rcA\n", "/04IP6+N5p81Rus2nFji+F8ws43R8dsJZ4B0An97BLVLudx9xhthEsmPi2z/LjBSYt8vE1KzFWz/\n", "E8L/POcX2efi6LFXF3nsSdFjfwB8HLiL0GV1A7Bhhhrc4bLZ6tRNN93CLfw5iL+OmF77VsJ6A5OE\n", "+VLpGW7jhEmIAB8iTOKbiP5WnhNt78k7Vh/w0Wh7Evgw8Cjhw24L8BXgr6O/bQPA5oK6zgW+ER1z\n", "D2Ho4d1AoshruI4wIXAP8AvCegSzveYfRvVNAsPA9mj718rcvhtoyTve4whzyXZF9W4jDB2vLvLc\n", "dcC10fveRxh2+ACh1zn3XuwG6oscf3f0Gh8lBIS1eW1eHT2WiercA3w87n9fc/jv1OeiTbk3iw5Y\n", "lJllgf/2sCBI/vYvAa8AmrzgFJy8NjcBT3L39oLtrwM+AzzH3X9Q8NjFwI+Bq939xoLHXkz4B5oi\n", "nHf8WUJy/Dphlus5XnAKjJm5h3kNH6Wyl0cViZ2ZuXt1TDoUWYzK+X90Lv8/LjXEUElXw2qM7je7\n", "+2c8OEBYmWwNeV1YBVo5dFqNiIiIlKHUaY69hA/YQm1Aaqbeg7x9kxbFmYJ9ociKWSUMR/d3FWy/\n", "j9DFd36xnV4KF++H0281uw+41d1vPcLnFRERqUhRz/vF83HsUgHhHuCUIts3EWaVzuZuwszS9cD2\n", "gn3HCRMdj0TutJ9ivR5TM2zna3ArYSzqH3BPFWsjIiKyGEVfem/N/Wxm187VsUsNMXwT2JibNRo9\n", "+UpCaPhGfkMzWxmdcpLzLcIQxSUFx7wEuMnDrN6yeVjz/GHCcqT5Hkc4//jXs+xeW2Q/ERERmUGp\n", "gHADoafgIxYuK1pDmIX7GIdffONCwszST+a2RR/onwHeZdGphmZ2DaEH4T0lnnemCRbvICy3+ZLo\n", "eAnC6S27gE+UOOa5JR4XERGRyKwBwd3HCRcNmSQMCdwPtACXFvQADAP9TF9b+y2EswxuM7PNwOuA\n", "yz0sfHGQmV0aXeTkK4Reh+uitcpfXlDPdwnrL/y5mT0MPES41OpTPFqMaRYrMCu6KpmIiIgcbtbT\n", "HBe76DTHv8zbdAfu0xZaEhGd5ihS6SrtNMel5gyiFcxERERkZtUWEBo5fP1yERERKaLaAgLAeaWb\n", "iIiIVLdqDAgbMeuMuwgREZFKVo0BwdApjyIiIrOqxoAAcDaHL+okIiIieao1ILQDJ8RdhIjEL1oE\n", "rsfM9pnZVHR7bhn7vTBqO2Fme8zsPxai3sXOzN4evV+T0fo3i4qZrY/qH45+/08/yuO8p9Lfh2oN\n", "CKBhBhEB3H3S3VcBT8jb/L4yds212e7uq939xXNf3dLj7te5+2rCNXoW3UI87r4jqv+63KajPM4H\n", "K/19qOaAcDJmTXEXISIVIzfs+BvgiWb2rBkbmj1/YUpa0hb7MO9c1V+x70M1B4Q6dAEnEZnur6P7\n", "2a6K9968diJLUjUHBNAwg4gUcPdvAfcBTzazZxY+bmbPARqjdjMyszVm9mkz22lmfWa2y8xuNLMT\n", "Cto1mNmfmNktZrYtarvNzP7ZzLqLHLfTzK4zs0fMbHfU9gdm9qboAnaY2Q+j40zlX/43b/x/ysxu\n", "ydv+uIJx9cvM7Foze8DMUtG2q/LaX25mP4qe44CZbTazd5lZXZF6H29mN5vZkJltN7P/NLNTZv0l\n", "TH9/9pjZQFTH1Wb2jqi2ETO73cwuMrMaM/sLM3swavtjMyu6MF5U07ei4/ZE7+VHzKy9SNtWM/tY\n", "9F7vM7O7zezqEjU/wcy+a2a90Xv0sJl92Mxayn3dlaDaA8IqzNbEXYSIVJwPRvfF5iK8L+/xosxs\n", "I3AHYWG2p7p7F/AUwuXp7zCzk/Ka58azfwicELX9HeDphAvdNRcc/muEi+hd4u5rgJOAOwlXtF0F\n", "4O6XAVdE7Q+Ob+eN/xduf7RgXP2DwFbgDGAN8NtcezN7I/DfwC+jx7oIV+h9N/DtgvfhPOCnhIv8\n", "neruG4B3Eq4GXNaHpbtnotr+ONr0ZmCLu58KnEJ4//4b+EfgYXc/BTgTOB74joWrEOfX9DzgdmAI\n", "OCmaf3Il8BLg52bWkde2Dvg+8HrgDe6+ArgQeGLUfpro+D8DDgCbot/na4CrgJ+YWWM5r7sSVHtA\n", "ALgg7gJEFi0zX/Dbwvgq8DBwoZldeujl2uVAh7t/rcT+nwRWAle5+xYAd99G+KBoJ1ymPicDfD+a\n", "tDYRtb0beDshULwq7/nbgWcAN7v7zqhtxt3fTQgJ43nHPZqx7dw+97r7F6MJnIPAm4BfWLgi7seB\n", "O9z93dFze3Sl3U8CzzWz38073j8Slrh/jbvviuq9D/gAsOwoa9vm7l+PjrUT+FcgCazN/V7cfUe0\n", "/XHA+QcPEMLW5wlXAf4Ddx+O2t9DCDinAH+T95yvJgSC6z260J+7jxBCSmFwyx3/C8BeQqDIHf9n\n", "hAsHngv8wRG+7tgoIMBpmLXFXYSIVA4Pl7nNfVDkz0V4H/Ch2fY1s2XAcwlnN9xfcNwHgWHgcjOr\n", "jbbtcfdikx4fiO7z50qNAoPANWb2qvxvo+7+BHffU/LFlefmgrpvdveHCd+a6wnf2Av9Krp/PkA0\n", "PHIRsNPdHyhoeysweZS1/bzg550ltq/P23Y50A3c5O7pgva5IaPfy9uW64X5n/yG7j4F/LhIbZcD\n", "y4EfuXu24LHD3p/FYNp4URWqBZ5Ewf8QIlKGpX156C8RAsFTzexiwt+K1cC/ldjvxOh+jZnN9IE9\n", "Qfig6gEws8uAPwJOAzqAqej5IO+bqruPm9lLgRuAG4FPmdnNwFeAb+V6IOZAzwzbT47u3xYNNeSr\n", "BUYIH5BwaK2Z3YUHcfcpM5vpOUrpLfg5O8P2THSfzNuWG9rZVaSmjJn1Ax1mtsrdewg9EE6R1zDD\n", "ttz782Ize3bBY0Z4f7qK7FeRFBCCx2P2E6YnPhGpUu4+aWYfBj5N6EUw4EPRt8dZd43u73P3kheH\n", "M7PXAp8F/gO4NNcVH81jmLaAjrvfHD32HMLY+RXA7wKbzexSd+8r8Xzl9BzP9Bpzr+197v7xMo4D\n", "0FBmu3LNVFup38uxKPc15N6fz7r7n8xXMQtFQwxBIzqjQUSmu4HQVf104Djgi2Xs8zDhg2JdsQct\n", "rMR3cd6mP4ravzkXDnJNZ9i/1t0n3P177n41oVfjC4SJeW/Ja5qbj1BfcIiVZbyGmTwY3W+YobYn\n", "mlmuB+W30f20ieBRSDmWOo5Wrv5pvxsL6+J0AoNR7wHAo4Tfw9oixyo2wb3U+3OWmS2a0+sVEA55\n", "sq7PICL53H0c+AjhA/wj5XThu/sA8F/AcjO7pEiTjwNvzfs5Q/EwsKlwg5kdBwxa3t8qd08RJgNC\n", "GJ7IyY3Bbyw4zFEtDRz5OqHeK4qcHbCCcMbCqVFd+4H/BVaY2ROL1BBHD/ZNwD7gWUVOOcxNrvxK\n", "3rZvRPcvyG8YzR8p9rvNHf9yK5jbZmYNwA+Ai4+q8hgoIBzSSZjBKiJykLt/Eqh3908dwW5vJoxR\n", "f8LMzgAws0Yzey/wNMJpgTn/Gt1/wqJL0ZvZ44C/j7YXhodm4O/MLBm1bSX0HIyT9+EWnTVxJ/B8\n", "MzsnansakFsSerYvREUfiyZBvpUQOq6PnhszO57wYfoj4Ht5u7yNMLHyY9EZELkaPkwYjz+WMy2O\n", "eLu7jxHOJGkAPp37EI++1X+QMDH03Xn7fpFwyuLVFq2eGQWLjxF6nmc6fgL4fDRREzNbSfjd7AL+\n", "5Qhqj5UCwuGeEncBIrLwzOwewixzjxbP+X7+44XzDszsf6IJiA7kLt7z6bz22wmn1/0E+H40Ie9+\n", "wiS2p+TP6nf3fwLeSJhAt93MdhDmPeQCye9Fi/ScSPiAeQNwOnCvme0G7iVMeHyau/+y4KW9iHDG\n", "wM1mtpMQTP4weuyCqO6XRYsB9QB/Gr2mb0aPXVj4Xrn7Zwmz9R8HbImO+13CegFXRmeA5Nr+hhCI\n", "hoEHorYfJwSaPmBd9DzvKnyegvf7IUIviRPCxm3R9p+XuT3//f4+4dTFJuDh6HV/i9A7ckF0Wmeu\n", "7RThjJTPAJ8xs32Efye/jbYRvVd3FTl+DXBf9Dv6KWHo6TJ3H41qfE/0b2ht3vvwZ7O9DwvN8n6X\n", "S46ZuYdzT4/EvxCdXyxSTczMfWmflSCyqJXz/+hc/n+sHoTptHCSiIhUPQWE6U4lb6lNERGRaqSA\n", "MF0NYeEkERGRqqWAUNx5hFNSREREqpICQnENhKuwiYiIVCUFhJk9mfKWJBUREVly9AE4s3bChVNE\n", "RESqjgLC7HTKo4iIVCUFhNmtxazoRTdERESWMgWE0tSLICIiVUcBobRTMFsWdxEiIiILKY7LbS42\n", "BjwV+E7chYjMNzNbuhdnEZEjooBQnrMx+xnufXEXIjJfdKEmEcmnIYby1AAXx12EiIjIQlFAKN8Z\n", "mK2IuwgREZGFoIBQPkO9CCIiUiUUEI7MqZitjrsIERGR+aaAcGQMuCTuIkREROabAsKROwmzdXEX\n", "ISIiMp8UEI7OpXEXICIiMp8UEI7O8ZhtjLsIERGR+aKAcPTUiyAiIkuWAsLR24jZCXEXISIiMh8U\n", "EI6NehFERGRJUkA4NmsxOznuIkREROaaAsKxuwQzXeRGRESWFAWEY7cKODXuIkREROaSAsLcUC+C\n", "iIgsKQoIc6MbOCvuIkREROaKAsLcuQyzRNxFiIiIzAUFhLnTCjwt7iJERETmggLC3LoAs2VxFyEi\n", "InKsKiYgmFmNmb3DzDJmdlUZ7Z9hZlNm9oWFqK9MtcCz4y5CRETkWJUMCGa2wsz+zcwejG5fN7O1\n", "5RzczOrN7ANm9oCZbTaz28zswiLtNgA/Bl4C1ANe4rg1wN9HP87aNgYnYXZi3EWIiIgci1kDgoVJ\n", "dzcDdcBp0S0F3GJmyTKOfz3hQ/8idz8T+Dxwk5mdXdDubcCngLeXWffVwI4y28bh2ZjVxl2EiIjI\n", "0SrVg3AVcCbwTnefcvcp4J3A8cAfzrajhSWIXw982N37ANz9c8AW4IMFzd/u7l8FSq4lEAWTa4E/\n", "K9U2Rl3ABXEXISIicrRKBYQrgW3uvjW3wd33AvdHj83mRYQP/FsKtt8CXG5mzXnHnCq3YOAdwH+5\n", "+4NHsE8cnoZZa9xFiIiIHI1SAeEswjf+QlsJPQul9p0Ethds38KhIYsjYmZrgDcQehAqXQJ4ZtxF\n", "iIiIHI1SAWE5MFxk+xDQbGYNJfYddffCSYRD0X1XeSUe5oPA9e6+/yj2jcNZmK2PuwgREZEjVSog\n", "VMwZAmZ2DnAJh85eWCyeq+s0iIjIYlNX4vFewgqBhdqAlLtnSuybNDMr6EVoi+77yi8TCMHg2hLP\n", "Oc1L4eLcf18GW98QhkcW0mrg8cAdC/y8IiKyxJnZxeR9zs2lUgHhHuCUIts3AZtL7Hs38DJgPYfP\n", "Q9gEjBMmOpbFzNoIcxb+n5m9reDhF5rZbwiTKX+3cN+vwa3lPs88uhSz+3BPx12IiIgsHe5+K3mf\n", "c2Y2Z3P0Sg0xfBPYaGYb8558JSE0fCO/oZmttMO70r9FGKK4pOCYlwA3uftouUW6+5C7r3b3c9z9\n", "3Nwtevg70c/TwkEFaWb6+yAiIlKxSgWEGwg9BR8xs9poBcMPA48RFjYCIFodcTfwydw2d38Y+Azw\n", "LjPritpdQ+hBeE+J5z2SMfvFMr5/PiFciYiIVLxZA4K7jxNO1ZskDAncD7QAlxb0AAwD/YSQkO8t\n", "wNeB28xsM/A64HJ3vye/kZldamZbgK8Qeh2uM7MtZvbyYnWZ2S1RewdeHLV9a1mvOD41wPM1YVFE\n", "RBYDm34W4tJhZu7wl3HXUeAm3G+PuwgREVl6ovMC5uSLaMVczbGKXEI05CIiIlKpFBAWXj3wuxpq\n", "EBGRSqaAEI/1wJPjLkJERGQmCgjxuVRDDSIiUqkUEOJTD7xQQw0iIlKJFBDitQF4UtxFiIiIFFJA\n", "iN8zMFsWdxEiIiL5FBDip7MaRESk4iggVAYNNYiISEVRQKgcGmoQEZGKoYBQOXRWg4iIVAwFhMqy\n", "EQ01iIhIBVBAqDyXYbYq7iJERKS6KSBUnjrgJZg1xF2IiIhULwWEytQFvCDuIkREpHopIFSuMzB7\n", "fNxFiIhIdVJAqGzPwWxl3EWIiEj1UUCobHXASzFLxF2IiIhUFwWEyqf5CCIisuAUEBaHMzE7L+4i\n", "RESkeiggLB6ajyAiIgtGAWHxqCesj6D5CCIiMu8UEBaX5cDz4i5CRESWPgWExedszM6NuwgREVna\n", "FBAWp+dhtjbuIkREZOlSQFic6oCXY9YWdyEiIrI0KSAsXi3AKzRpUURE5oMCwuK2CrgCM4u7EBER\n", "WVoUEBa/U4BnxF2EiIgsLQoIS8NFmJ0ddxEiIrJ0KCAsHS/AbH3cRYiIyNKggLB01AEvw6wj7kJE\n", "RGTxU0BYWpKE0x8b4i5EREQWNwWEpWclcKXObBARkWOhgLA0nQQ8M+4iRERk8VJAWLqegtkFcRch\n", "IiKLkwLC0nY5ZufEXYSIiCw+CghLmwG/g9kpcRciIiKLiwLC0lcDvBizTXEXIiIii4cCQnXIXf1R\n", "l4gWEZGyKCBUjwTwSsy64y5EREQqnwJCdWkGfl+rLYqISCkKCNWnDXg1Zi1xFyIiIpVLAaE6LQNe\n", "hVlj3IWIiEhlUkCoXquAV2CWiLsQERGpPAoI1W0DoSdBF3cSEZHDKCDIBsLERQ03iIjIQQoIArAO\n", "uAqzprgLERGRyqCAIDmrgasxS8ZdiIiIxE8BQfKtJIQEnQIpIlLlFBCkUDdwDWZtcRciIiLxUUCQ\n", "YroIIUENltkTAAAgAElEQVQrLoqIVCkFBJlJJyEkdMZdiIiILLyKCghmVmNm7zCzjJldFXc9Qjsh\n", "JOgCTyIiVaasgGBmK8zs38zswej2dSvz0sFmVm9mHzCzB8xss5ndZmYXFmm3Afgx8BKgHvAibZrM\n", "7A1m9jMzu8/M7jezn5rZC8qpRY5KG/AazDbGXYiIiCyckgHBwlK8NwN1wGnRLQXcYuWdEnc94UP/\n", "Inc/E/g8cJOZnV3Q7m3Ap4C3z3KsFwIfA97l7qe7+2nAt4HvmNlryqhFjk4TYTGl0+MuREREFkY5\n", "PQhXAWcC73T3KXefAt4JHA/84Ww7mtnJwOuBD7t7H4C7fw7YAnywoPnb3f2rgM1ySAe+7u7/e3CD\n", "+z8AOwgBQ+ZPHfBizC6IuxAREZl/5QSEK4Ft7r41t8Hd9wL3R4/N5kWED/xbCrbfAlxuZs15x5wq\n", "o5avAdcU2d4DzDTjfrbAIUfGgGdh9mzM9L6KiCxh5QSEswjf+AttJfQslNp3EthesH0Lh4YsyubB\n", "ZP42M6sl9GbcOsNuTzuS55CyPJnQm1AXdyEiIjI/ygkIy4HhItuHgGab/UqAy4FRdy+ccDgU3XeV\n", "8fylXEEYI/+rGR6/mBAgZG6dTpiXoOs3iIgsQeUEhGlnE1QKM1sNfBR4nbs/OkvTKwmz8WVubSSc\n", "4aAFlURElphyuoh7gdYi29uAlLtnSuybNDMr6EXIfVj3lVfmdBY+lL5PmAD57zO1ewf0N0PnGLz2\n", "BPjO6+Gxo31OKaobeC1mX8F9d9zFiIhUEzO7mNBTPufKCQj3AKcU2b4J2Fxi37uBlwHrOXwewiZg\n", "nDDR8YhF4eAm4Avu/onZ2v4t/AvwRkIoOREFhPnQSlhQ6Xu43xN3MSIi1cLdbyVvDp6ZXTtXxy5n\n", "iOGbwEbLWyjHzFYSQsM38hua2Uo7fHb7twhDFJcUHPMS4CZ3Hz3Sgs2snRAOvuTuH8/b/t0ZdhkF\n", "vg5MESbXHdHESClbPXAFZs/CrKJW6BQRkSNXzh/yGwg9BR8xs1oLf/w/TPgm/qlco2h1xN3AJ3Pb\n", "3P1h4DPAu8ysK2p3DaEH4T0lnnfaaXR54WAU6DOzV+VuhA//meyM9oOw2NJcTI6U4i4AXqnJiyIi\n", "i1vJgODu48AzCacr3h/dWoBLC3oAhoF+QkjI9xbCN/jbzGwz8Drgci/oijazS81sC/AVQq/DdWa2\n", "xcxentfsKuAJwFOBfwVuzLuV+tD/ZVR7Angp4RuvzI8TgDcQeppERGQRsulnIC4dZuYOf5m3qYGw\n", "smMXYX7Et2MprHpkgW/jflRzTURE5MhE5wTMyUJ21TZWnCGsxjgBnA2cF285S17orTF7hlZeFBFZ\n", "XKotIADsA74X/fdzgVUx1lItngq8HLPGuAsREZHyVGNAgHDq5p1ALWE+QvPszWUOnAS8EbM1cRci\n", "IiKlVWtAAPgfYA/QCbwcTVpcCJ2ERZUu0JCDiEhlq+aAMEE4Y2IQWEdYjrma34+FUgs8izDkoJ4b\n", "EZEKVe0fiMPAl4Ax4GTCnARZGCcBf0DeAlwiIlI5qj0gQLhexJcJPQqPR5eHXkhtwFWYPV1DDiIi\n", "lUUBIdhBWDY6tyz0ufGWU1VqCO/5qzErdlEwERGJgQLCIQ8Srg4J8ALChZ1k4WwiDDnofRcRqQAK\n", "CIe7A/gp4ToQLwXWxltO1UkSruPwO5g1xF2MiEg1U0CY7hbgLsKlsF+BLuwUh/OAP8RsU9yFiIhU\n", "KwWE4r4HPEpYQOlVhG+2srA6CPMSnoOZ1qgQEVlgCgjFTRGuQLmb8EH1SsKFnmRhGfAkwtyE9XEX\n", "IyJSTRQQZpYlnP7YD6wGXg3oWgLx6AKuwewyzGrjLkZEpBooIMwuBdwIDABrgKvQdRviUgNcRLie\n", "w+q4ixERWeoUEEobAL4AHCBc+fEqNCchTiuA12P2LMwScRcjIrJUKSCUZ4gQEnoJH1BXA1rUJz41\n", "wAXAmzA7Ke5iRESWIgWE8o0ANwD7gOWEkNAWYz0SJpC+ArOXahVGEZG5pYBwZFKEkNADLAOuIXxI\n", "SbxOA96M2RN1TQcRkbmhgHDk0sAXgV2EcHANISxIvBoIV+N8HWar4i5GRGSxU0A4OmPAvxIu8tRG\n", "CAnLY61IctYCb8Dsci3XLCJy9BQQjl4G+BKwFWghzEnQN9fKUAM8BXgLZudq2EFE5MgpIByb3GJK\n", "jxFOfXwNcHKsFUm+FuCFhNMitRKjiMgRUEA4duOEkHAPUA+8DHhyrBVJoTXAazG7EjOdeSIiUgYF\n", "hLkxCXyLcCVIgGcBz0Pvb6U5kzDs8HRdAEpEZHb6AJtbPwW+QQgM5xMuF62JcpWlHriEcFrkGXEX\n", "IyJSqczd465h3piZO/xlDE+9Dng54boN+wlDEAMx1CGl7QJ+iPuWuAsRETlWZubuPicTsxUQ5k9Y\n", "5Q+6CQss/TuwM6ZapLRHCUGhJ+5CRESOlgJCmWIOCBCGF14KHM+heQr3xViPzM6Be4Ef494fdzEi\n", "IkdKAaFMFRAQIMzzeC7w+OjnnxEmM07FVpGUMgncCfwE91TcxYiIlEsBoUwVEhByLgCeCRiwjTCZ\n", "cTjWiqSULPBz4HbcM3EXIyJSigJCmSosIABsBF5MWMBnFPgm8NtYK5JypIFfAL/EfSzuYkREZqKA\n", "UKYKDAgQVly8gjAvAcKpkT9BQw6LwRghKPxCQUFEKpECQpkqNCBAGGZ4KnAxh4Yc/gMYibEmKZ+C\n", "gohUJAWEMlVwQMg5DriSMOSQIgw5PBZnQXJExoBfAj9XUBCRSqCAUKZFEBAgDDlcCWyKfv4pcCvh\n", "lDtZHMaAOwg9CuoFEpHYKCCUaZEEBAjDDE8jDDlAWFDp20BfXAXJUZkA7gZuw/1A3MWISPVRQCjT\n", "IgoIOZuAFwGthA+bHxPGupfuL2lpcuAB4Ge47467GBGpHgoIZVqEAQGgEXg2cHb08w7gO6g3YbHa\n", "QggKOp1VROadAkKZFmlAyDkJeAFhAuME8CPChLil+wtb2nqA24H7cJ+MuxgRWZoUEMq0yAMChN6E\n", "5wBnRT9vJ/QmaHx78RohTGi8QxMaRWSuKSCUycz8a6fxk7jrOFYbBug6Zy8nNUySmDSmHuzisfu7\n", "2cWc/BOQOEzUMHXvCvZ972R2bl6p9S9EZI68n2sVEMqwVAICQMMEdefv5nFrRlgJMNDA0G9W8Uhv\n", "Uh8ui92OdgZvOp6dPzyB3skaDSGJyDFQQCjPUgoIORsH6Do76k1wYEcbu+9axZZMHRNx1ybHZqiB\n", "sZ9tYPd/ncSe/UnG465HRBYhBYTyLMWAAJCYoPasvRx33CDrDMjWMP7gcrY81MUeDTssfpM1TD24\n", "nN6bj2f37RsYiLseEVlEFBDKs1QDQs6yNM3n7uHEZWN0AAw2MPybVTyyP6nLSC8Vfc2M3rae3f91\n", "Ej39TeolEpESFBDKs9QDAgAOx/ez4oz9nJAbdtjZxp67VvLYWL0+UJaK3KTGH5zA7jvXMhR3PSJS\n", "oeYwINTNxUEkRgaPLWPfjnb6ztrLxuMGWLd+iNWrRuh+qCsMO0xp4tuiVzdFzTk9rDqnh1X7k6R+\n", "uZae/z6RHs1VEJH5oh6EJaYzGnboioYdRutIP9DNlsc62K/5CUvLZA1TjyzjwE830nPLJvp0BoSI\n", "aIihTNUYEABwOG6A5aft5/jkBE0AQwmG713BY7vaNOltKUolyP7favbefDw9D3aTirseEYmJAkJ5\n", "qjYgRMyxk/pYdXIfxzVMkgDoa6L/nhU8pvUTlq7drQz9fD09Pzye/X3NGoIQqSoKCOWp9oCQUzdJ\n", "zWm9rDvhABvqnFqAPS3su2cFW4YaGYu7PpkfkzVM/baT/tvXs/eWTfSm65mKuyYRmWcKCOVRQDhc\n", "4zh1Z+xj48ZB1taATYHvbGPPfd1sH2kgE3d9Mn8ytUw80E3v/25k7+3rGdB8BZElaikGBDOrAd4O\n", "fAB4g7t/cQ6OqYBQRGuGhjP3sWnNMCsNmALf3UrPfd1sV4/C0pdKkL1rJftu3cTeu1dpzQyRJWUh\n", "T3M0sxXAR4HHR5s2A29z911l7FsPvA94MeGSxUPAO9z9toJ2G4AbgSRQzyyXNDazVwJ/BhhQA3zM\n", "3f+lVC1yyHADmdvX8+CyNNtP28fGVSlWrBtm9dphVu9uYe/93WwfaGI07jplfiSzJC7cwboLd7Bu\n", "oJH03avY/9ON7NNFo0Qk36wBwcwSwM3Ag8Bp0ebPA7eY2bnuXmq29PXAxcCF7t5nZq8FbjKzp7j7\n", "3Xnt3gZ8CugBbpmlnpcBnwMucvc7zOxM4OdmVuPunylRixQ40MTozzbyQEearaf1smHNMKvWjrBy\n", "zQgr9ybZf1832w40a0b8UtYxRtPTt7Lh6VvZ0N9E+q6V7Pvpcey/b4XCgki1m3WIwcxeD3waON7d\n", "t0bbVgK7gD939+tm2fdk4H7gte5+Q972e4Gt7v78vG017j5lZhcDPwaudvcbC45XA2wDfuTuV+dt\n", "/wTwMmCNu2cL9tEQwxFoy9B42n42rB1iVU3ooWFfM733d7NdyzdXlwNNjN4V9Szcv0IhUWTRWMAh\n", "hiuBbblwAODue83s/uixGQMC8CLCh0xhj8AtwBvNrNndR6NjljO7+onA2hmO9ybgEuAHZRxHZjDU\n", "wNgv1vFwMsu20/ezft0Qq1eMsnzFNpb3NzL46DJ2bmund27+6UklW5am+dItbLx0Cxv7m0jfu4Le\n", "X6yj9441DOr3L1IdSgWEswjDC4W2ApeWse8ksL1g+5boeU8D7ihd4mHHy+1feDyAM1FAmBOpBJlf\n", "reXRe7vZfmov6zYMsqZzjPYn7Kb99H2Mbelg5yNd9IzXMhl3rTL/OtM0PXUb65+6jfWpBNn7l9P7\n", "y3X0/nw9/eO1OhtCZKkqFRCWQ9Gu5SGg2cwa3H2m0+OWA6M+fQwjd6GZrvLLPHg8itRztMeTEkYT\n", "ZO9cw2P3rGTbiX2sOn6Adc0TNJ7ey+NOOsCmnW3seaiLncM6RbJqJLMknrCbNU/YzZrX38nEQ8vp\n", "u3MNvT/bwIHhBgVGkaWkVEDQtwNhvJbJ+1ew64Fudm0cYPnj+lnXOUb7pgHWHTfAur1J9j/cxc69\n", "SYZ0vYfq0TBJ3Vl7WXnWXla++m6mtrUzuHklfbevp29LJ+m46xORY1MqIPQCrUW2twGpWXoPcvsm\n", "zcwKehHaovu+8ss8eDyK1DPr8T7fw3G5/z4zycATWnUtgqPlBls76d3aSW93itaT+1i3coTuValw\n", "G06Q2trO7sc62Zut07fJalI7Rc3x/XQe30/nCx/kcX3NjN7XTe+v19J3xxqGtDCTyDy5g+N47NDn\n", "3FwqFRDuAU4psn0TYT2E2dxNOLtgPYfPQ9gEjBPOcDgSudMijwN+WnC8XK3TvGYVW4/weaQM+5MM\n", "70/yQDLLYyf3smb9EKtbsyTP3M+Jp/ZyQk8Lex9dxh6d/VCdukZpfto2NjxtGxvSdYw/0sWBu1dx\n", "4BfrOKBLVIvMofPZyvl5n3Pv5+lzdehSAeGbwKfNbKO7b4ODpzmeAvx5fsNo+7683oJvAR8inF2Q\n", "vyriJcBNuTMYjsCvgJ3R/vmnQF5C6D249QiPJ3MglSDzf2vYcvcqtm4coHvTAKuXjdGxbpjV64ZZ\n", "PZRgZGsHux/rZJ8mNVanpgnqc0MRr7oH72lh5IHlHLhzDQf+b7V6F0QqVal1EOoJZxo8ALySMCfh\n", "c8BTgHNzH/JmdiHhW/2n3f1Neft/ivABnlso6RrgE8AF7j7tG3/eOgjXFFtq2cx+D7iBsFDSndFC\n", "SbcDf+Luny3SXusgxKAjTfOJB1i9dphV9VMhhE4Yk7tb2bulg559SYY1V0EAxuqYeKyT/s0rOfDz\n", "dRzY3aYJryLHZCGvxZC31PL5hIAwballMzuL8MH+j+7+13nb64BrgZcQhhVmWmr5UkLwaARWAAeA\n", "EeDd7v6VgravAN4Z/TjrUssKCPGqnaJm0wDdx/WzujNDe257qp70zlZ6Hutkry4SJfl6m0k90kX/\n", "XSvp/9U6BlIJ9TqJHJGleLGm+aCAUDmWjZI8vp9Va0ZY2TBJPYS02d/IwPZ2erZ20KshCMk3WcPU\n", "7laGH+qi/zer6ddwhEgZFBDKo4BQecyxdUN0HjfAqu4Uy2ujJZ0njKm9SfZv66BndysDWq1PCmVq\n", "mdjWweAD3fTftYqB+7sZ0b8TkQIKCOVRQKhsiQnqNg3QvWGQVR2Zg6erkqllvCfJ/h3t7NvTwqDm\n", "K0gx6TrGt3Yy8FAXA3etYuCBblIKDFL1FBDKo4CweLSP0bSpn5Vrh1nZPEFjbvtYLdmeFvZtb2e/\n", "FmKS2aTqyW7rYPDB5SEwPLRcgUGqkAJCeRQQFiGH7lFaNgyyYvUIK5omaMg9lK4jsyeEhX37mxlR\n", "WJDZjNYzvqONwUe6GLxnJQObVzKiOQyy5CkglEcBYZFzWJmibcMg3atGWNE4SSL3ULqOzN4kvbta\n", "6d3TyqCb/vDL7LK1TO5sY+jRZQzc383gb1YzlK6nnCvJiiweCgjlUUBYQhxWjdC+YYjuVSN0N+SF\n", "hfEaJvY107e7ld6dbRyYqNUffSltsoapfUlSWzsYfKiLobtWMah1GGTRU0AojwLCEuWwIkXr+iG6\n", "V46wPDlBU+6hSWOqr4n+Pa307mijL12vZX2lfEMNjG1vZ+jRZQzet4Khe1doWEIWGQWE8iggVIeO\n", "NM3rh1i+eoTl7ZnDL+Y12MDwviQHdrfQpxUc5UiN1zC5p5XhbR0MP7yMoc0rGVIvg1Q0BYTyKCBU\n", "n2SWxPrBEBY603Tk1lkAyNYw3tvMgT0tHNjVxoFMHRNx1iqL00iCzI52hrZ0MPzgcoY2r2RYKz5K\n", "xVBAKI8CQnWrm6RmzQgdq4fp6h6lK/+MCAcGGxjal+RATwv9+5IMa6KjHI0pw/uaGd3ZxvBjnQw9\n", "1MXwA92kMnWaCyMxUEAojwKCHOTQOUbz2mGWrRyhq2OM9pq83oXxGib7G+nfl6R/Tyv9Aw2kNRwh\n", "Rys3AXJHG8NbOhl+YDlDDy1nVPMZZN4pIJRHAUFmkpigds0wnStTdC4fpbM5b6IjwFgtmd5m+vdG\n", "gUGTHeVYTYTQMLKzjZGtHQw/0sXIg8vV0yBzTAGhPAoIUq7WDA2rQ2BYtixNZyK6THVOqp7RviYG\n", "9icZ2NPCgAKDzIXJGqZ6mxnd1crw1g5GfruMkQeXMzLcoDkNcpTmMCDUlW4isvQNN5AZbqDn4eX0\n", "4LB8lJbVI3R2j9LZMUZ7cpzm5DjNG4ZYA3mBoZmBnhYGRxNk434NsvjUTlGzcoSWlSO0nLcnbHPD\n", "BxoZ62lhZEcbI1s6GXmoi5Gd7Tp7QhaWAoJIIYPeJCO9SUaAHTVT2IpRWleM0LE8TUfRwFBHur+J\n", "wb4mBve1MKg5DHK0zLHONE2daZpO3U93bnu6jvG9LYzsaiW1vZ2Rx5aReriLlFaDlPmiIQaRI1Qz\n", "hXWP0royRcfy0RAYap2a/DbZGsYHGhnsa2Jof5LB/c0MT2mCmswxN7y/kXRPC6mdbYxsbyf1SBep\n", "rR2kdaGqKqU5COVRQJCFUDOFdaVpWZGivStNe8cY7Q2T1Oe3mTSmhhIMDzQx1NfE8L4kQ6mEuoxl\n", "fmRrmexrZrSnhdSuVlJbO0g91klKwxRVQAGhPGbmvD/uKqTqOBzfDxduh4u2w4U74PT905vtaoVf\n", "rINfroVfroM71sBoYno7EZGyvR8UEMqggCCVYtkoPHEXPHknPGknPGkXdI4d3mbC4L4V8Os1ISzc\n", "sQY2r4SsZgqJSLner4BQFg0xSMVy6BijqXuUtmVp2jrGaGvN0lL4f/UU+EiC1GAjw/2NDPc1MXyg\n", "iZTmM8hCmKhhqr+J9P4wXDG6q43R7e2MPrqMUS0vXaF0mqPIImcw0ER6oIk0sBfC0tBdaVq6Rmnt\n", "HKO1PUNr8zjNbVla2rK0rB9iNRwKDUMNjAw0MtLfxHBfE6nxWv3BlrlVN0VNd4pkd4rkaQXDZCMJ\n", "Mr3NjO5NMtrTSnpXK6PbOkhvb2dMK0YuDQoIIhViopapvS0M7W1hKLetfpLa5aO0LEtHoWGM1uYJ\n", "mnKhYd1waOfAaB3p4Sg0DDQy0tfEyGg9WZ1uKfOhJUtDS5aG4wbozN8+WcPUQCNjvU2M7mshvaeF\n", "0Z1tpLe3k97TSkZnVyweCggiFWy8lsk9rQzuaWUwty0xQW1XmpbONC0dGVraMrQksySTEzQlJ2ha\n", "lTp07ny2homRBCNDDaQGGxjpbyLV30hqolbnzsv8qJ2ipmuU5q5Rmk/uO/yx8Rom+5tI9zWT3t9M\n", "uqeF9O5W0ls7FB4qkQKCyCKTrZseGmqmsGVjJJelaWkfo6U9Q0tLlmRiirplY3QsG6Mj1zbX2zDS\n", "QGooQWqokdRAI6mBBtKa2yDzqX6K2hUpWlakaDm14LHxGiYHGxnrayLd28zY3pYQIHa0h2GL8Vr9\n", "21xoCggiS8BUDd7bzEhvMyMHNzokx2lYlibZEUJDsjVDsnmc5lxvw8oUyw8eA3y0nvRIgtRwA6OD\n", "DSE4DCo4yAKon6J2+SjJ5aMkC3se3PDhBJkDofdhrLeZsb1J0rtbGdvRTnp/UtdGmQ8KCCJLlUEq\n", "QSaVILOjnQO5zbVTWMcYzZ1jtLSN0dyaJdmSJdk0QWPLOM0t4zSvSh06zBR4up6xVD2p4QSjUXgY\n", "HWhkNFuniZEy/8yxtgyNbRkajxuY/ni2NvQ+HGgMvQ+9Scb2Jhnb08rYzjbGBhuZWPiqFz8FBJEq\n", "M1mD9zWT6msmlb+9bpKazjGaO8ZItmVIRsGhuXGCxuQ4TclxmlaMHn6sTC3ZkXpGUwlGo/CQHmxg\n", "dLiBMY0ny0JJTFKbO9uisPcBYKyOicFGxvrDEMbY/iTpfUkye1tCgOhvUoAoRgFBRIBwFsX+JCP7\n", "k3nDFITg0J6hqX2MZFuW5tZMuFBVc5bmhkkSDZMkuvLmOMDBXod0KgxZjI4kSA81MDrUQDqlMytk\n", "gTVOUNcYXTWz2OPZWiaHGkKA6G8i05sbxmghs6eFsT2tZKvx1E0FBBGZ1UQtU8V6HMyhNUNjRyaE\n", "hpYsTS1ZmpvHaWqcpCF3xcsVo3Tl7zdpTKXrQnhIJUiPJEgPhwCRHkmQUXiQhZaYPDT/odjjU4an\n", "EmQHGxgbaCRzoImx3mYyvc2hF6KnhcxSnAehgCAiR8UNhhoZG2pkDA7NcYDQ69CRobktQ1MuPDSP\n", "h1tiivqWcZIt4yQpGLLIzXeIAsRYKkE6lWAsChBjWgxK4lDjWGuGhtYMDeuGireZqGFquIHMUAOZ\n", "gQYyA01k+prI7E8yti9JZm+S7P4k2cU09KaAICJzbqKWqWlnVUQSE9S1Z2hszdDUkqWpZZym5ixN\n", "zRM0N0xSn5vvsDw9/bjZGsajADE2GiZOjuUCxHADmckare8g8aiboqYzTVNnmqaNM7SZrGFqJEF2\n", "OEFmsJFMfyOZgUayvc1k9ifJ7EuS6Wkhm6mrjH/HCggisqCydUzsr5s+1wFCz0NbhqbWLI0tWZqS\n", "4zRGPQ+NjVHvQyJDfXuG1mLHztSSTdeFAJGuJ5OqZ2w0wdhIPZlh9UBIzGqnqGkfo7F9jMaZeiIA\n", "0nWMjzSQHYqCxEAj2f7QI5GNhjaye1vIzvfaEAoIIlIxJmqZOtBM6kDBfAfg4LoOrRkaW8ZpTGZp\n", "bA4BorFxgsbGCRpykyY7MrQVO/54DRNjdWSiADGWriMzGoJEJpVgLFVPVms+SNyaJqhvmqC+O1V8\n", "TgSEtSFG6xhPJcgONZAdaiAz2ED2U3NYhwKCiCwOees6wKFVJA8+7JDM0hD1PuTCQ0PTxKEAUT9F\n", "XX2WutZs8T+8DmSjXogoSGTS9eGWim6jChFSAcyx5DiJ5DiJFXlxWgFBRKSAG4w0kBlpKB4g8PDN\n", "rCUEiIaCANHQOEFDIuqBaJgkxJBiz0MIEZlaMmN1ZNN1ZMYOBYls1CORzdQyoTMyZDFTQBCR6mCQ\n", "rmc8Xc/4/iTDxZrUTGHJ8XCVwubxcGuaoKFxnIbGyekhoi0789NNGlOZWrKZOjKZWrJRj0R2rD6E\n", "itEQJhQkpGIpIIiIRKZq8OEGxoYbGJupjTnWPE4iFyKaxkk0RT0QjRMkGiZpaJggUefUNk/Q2DxB\n", "42zPOWlMRT0S2UxduB+rC7d0dD9aTzZdX52L9Uh8FBBERI6Ah0VzcnMhZlQ/SW0yS6J5nIbm0AuR\n", "aJog0TBBonGShkQIE4k6p7ZpgsamCRpnP2KYZJmtJZutZTwvUIznAsVYHePperKjdWR1SW85VgoI\n", "IiLzYLyWyYEm0gNNFFnR4ZD6SWqbx0k0j5NonAghojEKEg0Th4YzEpMk6qeoq5+iLlnGmn25nols\n", "LePRLZupZTxTR3Ys3I9HvRTj6XrGtYaEFFJAEBGJ0Xgtk4O1pAcbZw8SuUmWTSFI1OcFifpciGiY\n", "oD4xSaJ+kkStU3OwZ6IME8bUeC3Z8ZoQKDK1jGfrovvo5yhU5G4TbhryWMoUEEREFoO8SZYl2zrU\n", "T1HbNH4wSNQfFiYmqE9MhTCRmKS+fpL6OqemboLGJsoLFBCGPHKBYryWiWwN4+O1B0PFRKbusGAx\n", "kallfKKGKU3KXBwUEERElhoLPRPjtUwOMfOEy4M8XLAo1zPRMEF94yT1UY/EYbf6yRAu6qLhjvop\n", "6v5/e/cfLFdZ33H8/cnu3oRQKEhGLL9CqAOWQsDqWCFMG6AEGem0irXa0lKolLGVkalasMoAoh0o\n", "dqh2BCz+YLB2kAyiLbRAbcPYibRoxRAIKSgBpyOGH1KgCXjv7v32j+fZ3GXP/bG7Z/fubvi8ZnbO\n", "nuc+59zvN+fe537znB+7vM4enYbWgKhXmJpaQn0qLacmK+n9ZLrGoj45U2DUc4FR990ei88FgpnZ\n", "K51gskpjstphQUF6MNXSNDNRW9agmmcnahOpqKhONHbNUtRqDaq1aWrVBrUKqNJ81kQXn38YQH0J\n", "9a+IrRkAAA7ASURBVHqatai3FBj1qVRg1HOBMZWLjPpkLiwmK9R9B0j3XCCYmVnXQvBSjamXOjnl\n", "0aIyzZJldarLZgqK6tLGTFFRm6Zaa1CtNd+n9Vo1qDTXO56uaNEQ060FRn7fmKrsKjZ2LSdTsdHY\n", "VWikV+OVNoPhAsHMzBZNYwnTOyaY3DHBPI+ZKlKgpamYqE6kGYtqa1Ex0ciFxUxRUa1Oz7wqwZJd\n", "Mxc9qotGs7CotxUZufBo5CJj13JypvBoTKb2sSk0XCCYmdnICxG9zFikjdPHMS9t5AIjXaRZyTMV\n", "1YmZgqLSLDJaiotKdZpqNahUg0q1QanPBA2gkQuNRio0WouOXe+n2t63Fh3N9ckKjUHeSeICwczM\n", "dm9KnxRarzC5g+5mLnbtIqCWCoxKLc9itBYZtVxI1KapVFvWmwVGJXYtl/Sj0GhqiOmGaDSLjfJ7\n", "nOECwczMbAGRLuSsT1apw0LPvJybAtUaVCbSq1pLRUYlnxapVKfT+1xYVKovLzQqlaBSyeuVoFIJ\n", "llSCJUxT62O6gAsEMzOzRRMi+lFopJ2lUye16VxsNKjwOG/oT6QuEMzMzMbTzKmT6Y4eoNWlJf3e\n", "oZmZmY0/FwhmZmZW4ALBzMzMClwgmJmZWcGCBYKkV0v6sqSt+bVe0oGd7FxSTdLlkh6StFnSRklr\n", "5uh7gaQHJW2S9F+SfmOWPhOSLm7p95Ck6yW9ppN4zMzMrDPzFgiSJoB/Id3tcGR+7QA2SNqzg/3/\n", "DfBbwAkRcTTwBeAuSce0fZ+LgI8Ap0fEMcCFwHpJb2nb31XARcDv5H5rgDcDt0sak4dXmpmZjb6F\n", "ZhDOAo4GLoyI6YiYJv3xPgx473wbSjoCOBe4IiKeAYiIzwPbgE+09NsHuBj4TERsy/2+AdwFfLJt\n", "t+8G7oqITbnfT4DPA68HDl8wWzMzM+vIQgXCGcDjEfFYsyEitgNb8tfm8zZAwIa29g3AOknL8/pb\n", "gD3m6HdkLjSapqDwtKjmen2BeMzMzKxDCxUIq0n/42/3GGlmYaFtG8AP29q3MXPKotmv2d7ej7bv\n", "8zHgZEknAUg6FDgPuDEifrBAPGZmZtahhZ6kuAJ4YZb254HlkpZGxFyPilwB7IyI9k+aej4v92vp\n", "xyzfp70fEfFZSQ3gFkkv5m2vBT6wQB5mZmbWhYVmEAb2MZK9kHQV8BfAqRFxAHAQaQbi31tOWZiZ\n", "mVlJC80gPA3sNUv73sCOeWYPmtvuKUltswh75+UzLf3I3+fZufpJ+kXSTMHFEXEvQEQ8Ken9wPeA\n", "84Er24O49kkOar4/ci9+8kv7vOx7mJmZja3v/i/7bnmBVw1i3wsVCPcDr5ulfRWweYFtNwHvAg7m\n", "5dchrCJdbLilpR/AobP0a8YAcFRePtL2fZrrq5nFvz0Vr10gTjMzs7F0Ttu6pL7N/C90iuGrwEpJ\n", "K1u++f6kouGWtqD2b3sWwa2kUxQntu3zRNKtijvz+h3Azjn6PRgRD+f17Xm5sq3fyravm5mZWUkL\n", "FQg3kGYKrpRUkbQEuAJ4lHRxIAD56Yg/Aj7TbMt/2P8W+LCk/XK/s0kzAx9p6fcccDnwJ5JW5X6/\n", "BqwDPtgSyzfJpxIk/Xzut5x0WmEncH2XuZuZmdkc5j3FEBFTkk4BriadEghSwXBSywwApDsQniUV\n", "Ca3OBy4BNkqaIt2ZsC4i7m/tFBFXSnoJuE1SnXR75Dsi4s6WPtOSTgY+DHw9380wATwIHBcRD3WZ\n", "u5mZmc1BxbsQdx/5+kg/gtnMzF4R+vl3z5/maGZmZgUuEMzMzKzABYKZmZkVuEAwMzOzAhcIZmZm\n", "VuACwczMzApcIJiZmVmBCwQzMzMrcIFgZmZmBS4QzMzMrMAFgpmZmRW4QDAzM7MCFwhmZmZW4ALB\n", "zMzMClwgmJmZWYELBDMzMytwgWBmZmYFLhDMzMyswAWCmZmZFbhAMDMzswIXCGZmZlbgAsHMzMwK\n", "XCCYmZlZgQsEMzMzK3CBMMYkrR12DIO0O+e3O+cGzm/cOT8DFwjjbu2wAxiwtcMOYIDWDjuAAVs7\n", "7AAGbO2wAxiwtcMOYMDWDjuAceACwczMzApcIJiZmVmBImLYMQyMpN03OTMzs1lEhPqxn926QDAz\n", "M7Pe+BSDmZmZFbhAMDMzs4JXbIEg6eOSpiWdNexYbPch6eck3SFpetixDILz62gfIzu27M7Hb3fO\n", "bVjGrkCQ9GpJX5a0Nb/WSzqwy30cBPwpEPk1MsrmJ+kYSV+X9F1JD+V9XDnImLtRJr88AHwu57VJ\n", "0oOSPiqpNui4OyHp7cBG4FC6/LmSVJN0ec5ts6SNktYMIs5e9ZpfPm6X5WO2Oed4i6SjBhVrL8oc\n", "v5Z9jPLYUiq/UR5bSv7ujfS4AiDpWEnXS9oi6f4c46ckrehg297HlogYmxcwAWwCvkIqbpYANwAP\n", "A3t2sZ8bgX8EpoHfH3Ze/coPOB54Cjixpe2PgUeHnVvZ/HLf+4D7gX1z27HATuCvh51bjqc5QN0A\n", "THe57XXAVmC/vP6HwA7gmGHnVTa/nNt/Awfm9aXAzTm/o4adVz+OX8s+RnJsKZvfGIwtvf5sjvy4\n", "kmPaCqwH9sjrBwAP5d+rZQts2/PYMvTEu/xHOjf/4h3a0rY/UAc+2OE+3gB8H1g3ar/EZfIDlH9g\n", "Lm9rrwKnDju3PuR3ZN72/W3tXwN+POzcmscgL7sdpI4AGsAftLU/ANw27Lz6kN+1wDltbYfl4/np\n", "YedVNr+W7Ud2bCl5/MZhbOk1t5EfV3I8W4DD2trOybG/fZ7tSo0t43aK4Qzg8Yh4rNkQEdtJ/3hn\n", "dLiPvwL+HJjse3TllcnvBNIPw22tjRFRj4g7+xxnr8rkV8/L9mm/GjDVrwDLiPyb14O3kQbhDW3t\n", "G4B1kpaXCqxPSuT3PuCLbW1P5OU+vUfUXyXyaxrlsaVMfiM/tpTIbeTHlWx1RDza1tbJ71CpsWXc\n", "CoTVwLZZ2h8Djl5oY0m/CSyNiJv7HFe/lMnv+Lxcns/vPpDPN31C0rJ+BllCz/lFxMPA3wPnSVoJ\n", "IOkk4CTgkv6GuehWk6r8H7a1byP9L+3IRY+ojyKiMcsAfnhe3r3I4QzEGIwtZYzD2NKTcRlXIqI+\n", "S/PhpOstvjnPpqXGlmoXMY6CFcALs7Q/T/rhXRoRP51tw3zByRWkaZlR1XN+wMF5eSPwzoi4J18E\n", "9s/AG4FT+x5t98rkB3AWcDXwiKSngOXA+yLiC/0PdVGtAHbO8kf0+bzcb5HjWQx/RJrm/NKwAylr\n", "TMaWMsZhbClj7MYVSRXStQSfi4jvz9O11NgybjMIZaYA3ws8EBHf6lcwA1Amv2Yl/6WIuAcgIh4A\n", "rgROkfQrZYPrg57zy/9TuZs0IK2MiANJVf5lkj7Vn/BsMUg6GXgn6Y/NKE3j9mocxpYyxmFs6ckY\n", "jysXAz8FLhjkNxm3AuFpYK9Z2vcGdswze7APcFF+Fb7cv/BK6ym/rPk/8++1tTfX31gytn4ok985\n", "wBrgQxHxBEBE3Af8JXC+pF/ud7CL6GlgT0ntP4t75+UzixzPwEg6hnQh2a9HxNYhh1PaGI0tZYzD\n", "2NKrsRtXJJ0NvAM4LSJeXKB7qbFl3AqE+4FVs7SvAjbPs92bSRejrJd0n6T7gOvz1z6W2z7a31B7\n", "0mt+kK4yhuIxbczRPgxl8mteo/BIW3tzfXWJuIZtE+n4HNzWvop0odSWRY9oACStBm4Ffjsi/mPY\n", "8fTJuIwtZYzD2NKrsRpXJP0e6TkbJ0XE0x1sUmpsGbcD+1VgZfNiEgBJ+wOvA25p7Shp/2bVFBF3\n", "RMQhEfH65gt4T+56cW77+CLlMJ+e8sv+ifQL2/4D3XwYzbf7H27XyuS3PS9X8nIr274+KuY8nTJL\n", "brfm/ie2dT0RuCsidg4gvrK6ya9ZHHwNOLM5FZ8fUHPdYMPsWUf5jdHY0q6b4zcOY0urbnIbm3FF\n", "0pnAnwEnR8STue10See29Onv2LKY93KWfZFuPdkE3ARUSAXOF0kPi1je0m8N6Qf6mnn2tZZ0D+lZ\n", "w86rX/mRbrN6EviFvH4AqRK+Y9i5lc2P9BCU54A7gZ/JbYeQ7jvfCkwMO7+WWG9gjnux5zl21/Ly\n", "h5mcTXqYyeph51M2P9L/0p7KOZ7Z8roA2DDsfPpx/Nr6jNzYUja/UR9bes1tXMYV4HeBF4EPtP0O\n", "fRa4ZIFj1/PYMlZ3MUTElKRTSFecbiFVRptJ0y2tldALwLPAj9r3Iek1wD2kC28C+KSkS0nTnvcO\n", "NoP59SG/D5HOOf2DpDrpLpVbGJHbdcrkFxGPSXoTcCnwbUmTpILjdtIDXIZ+77mka4DTSFcOh6Rt\n", "pByPiJmL8eY6dueTjtNGSVOkq4zXRcT9ixJ8B0rkdynwKuC8/Gp19wBD7krJ4zfSYwuUzm+kx5Ze\n", "cxuHcSX7NOlJtFe1tQdwWX7/f/R5bGk+fcrMzMxsl3G7BsHMzMwWgQsEMzMzK3CBYGZmZgUuEMzM\n", "zKzABYKZmZkVuEAwMzOzAhcIZmZmVuACwczMzApcIJiZmVmBCwQzMzMrcIFgZmZmBWP1YU1mNlok\n", "rQAuZOYDYh6OiNuHGJKZ9YlnEMysjOuAmyLiamAn8O4hx2NmfeJPczSznkm6D3gMuAH4T2BnRDw/\n", "zJjMrD88g2BmZZwH7AvcRCoQlg43HDPrFxcIZtYTSftGxL0RsRY4AHgKOGG4UZlZv7hAMLOuSVoO\n", "/I+k03LTc8B2YOPwojKzfvI1CGbWE0mXAo8DewKHADdHxHckHQ+cDDwD/Bg4FthGKiIOAZ6IiK8M\n", "JWgz65hvczSznkTEpXN8aTnwNPCzEXGNpADeGhHvkfQm4F2ACwSzEedTDGbWVxHxDWAtsD43rQH+\n", "Lr//VeBbQwjLzLrkAsHMBuG1EfGD/P44ZoqCtwL/Kum44YRlZp1ygWBmfSXpEODe/H4ZsD0iJvOX\n", "HwVOB74zpPDMrEO+SNHMzMwKPINgZmZmBS4QzMzMrMAFgpmZmRW4QDAzM7MCFwhmZmZW4ALBzMzM\n", "ClwgmJmZWYELBDMzMytwgWBmZmYF/w/o5j834Cw5eQAAAABJRU5ErkJggg==\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "s_m_values = numpy.linspace(0.4, 2.0)\n", "v_exact_m = numpy.zeros_like(s_m_values)\n", "interval_lower = numpy.zeros_like(s_m_values)\n", "interval_upper = numpy.zeros_like(s_m_values)\n", "for i, s_m in enumerate(s_m_values):\n", " v_exact_m[i] = (2.0**s_m*v_values[0] - v_values[1]) / (2.0**s_m - 1.0)\n", " error_m = abs(v_exact_m[i] - v_values[0])\n", " interval_lower[i] = v_exact_m[i]-error_m\n", " interval_upper[i] = v_exact_m[i]+error_m\n", "pyplot.figure(figsize=(8,6))\n", "pyplot.plot(s_m_values, v_exact_e*numpy.ones_like(s_m_values), 'g-', linewidth=2, \n", " label='Exact model')\n", "pyplot.plot(s_m_values, v_exact_m, 'r-', linewidth=2, label='Measured model')\n", "pyplot.fill_between(s_m_values, v_exact_e-error_e, v_exact_e+error_e, facecolor='green', \n", " alpha=0.5, edgecolor='None', label='Exact model interval')\n", "pyplot.fill_between(s_m_values, interval_lower, interval_upper, facecolor='red', \n", " alpha=0.5, edgecolor='None', label='Measured model interval')\n", "pyplot.legend()\n", "pyplot.xlabel(r\"$s_m$\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We see a few things. Firstly the lower limit is identical for both models for all $s_m$. This shouldn't be surprising: one of the edges of the interval will always be $\\udt{\\dt}$, from the definitions of the error and the interval.\n", "\n", "Second, we see that for small enough $s_m$ the predicted solution for the measure model falls outside the interval for the exact model: this occurs when $s_m \\simeq 0.6$. For large enough $s_m$, the predicted solution for the exact model falls outside the interval for the measured model: this occurs when $s_m \\simeq 1.6$. \n", "\n", "This gives a very wide range of values for $s_m$ that are \"close enough\". Also, it's specific to this data. However, we can do a general calculation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The general interval" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We have a definition for our two models, defining two intervals and the solutions that should fall within them. We can do a symbolic calculation to check when this happens. First, we write out the inequalities that need to be satisfied:\n", "\n", "$$\n", "\\begin{equation}\n", "\\left| \\frac{2^{s_e} y^{(h)} - y^{(2h)}}{2^{s_e} - 1} - \\frac{2^{s_m} y^{(h)} - y^{(2h)}}{2^{s_m} - 1} \\right| \\le \\left| \\frac{y^{(2h)} - y^{(h)}}{2^{s_e} - 1} \\right|\n", "\\end{equation}\n", "$$\n", "\n", "and\n", "\n", "$$\n", "\\begin{equation}\n", "\\left| \\frac{2^{s_e} y^{(h)} - y^{(2h)}}{2^{s_e} - 1} - \\frac{2^{s_m} y^{(h)} - y^{(2h)}}{2^{s_m} - 1} \\right| \\le \\left| \\frac{y^{(2h)} - y^{(h)}}{2^{s_m} - 1} \\right| .\n", "\\end{equation}\n", "$$\n", "\n", "Noting as above that only two need solving (as one edge of the inequality will always agree), we can solve:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAJkAAAA/BAMAAAABN3d6AAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\n", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMARM1UEDKrie+7Inbd\n", "mWYDwv/QAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADw0lEQVRYCe2YTWgTQRTH//lsssmGguC1tSge\n", "PDRQDwqWBoXqQTAIFj0UI3gQFY14yEGC8RMPHgKi0JMLnpTW1lPRIuTgB1SxEaTiodKDKCoWqy1V\n", "UdZ5szubTXZ38tEc+w4zb9/Hb9/Mzm4eQZeud6MdclvXk+jq6+tsBwzr+gYYrSnUfll0xJMWci14\n", "+KQbbcI0etMOOdIyZNnhMDPDetPoTdvoSCuSxZXWMU8uwJOmiuo7ppJGKLxpeGKECNrQZjNFTOMp\n", "YOzdTeB1iFOYXUJ7bKQJWvCqwJhzHghmcL4TI1tTpsmdFrjM3ONGiKDhlpkipktAOIVIAUN6mmzh\n", "np6LPVuc+zY4u8S88XmKqexbDS3EYiIlhJcDWngCnxYo1r22GNFU7vOkJQqAf4nR4mk1nSiqFm0b\n", "aXbhtFiBm+wr3T11hh2d/NeHzKN2c3d8KbHwAP6zH+iK7j82c4I7KgOn+ajAqpWGphGdYOZXMWaP\n", "GqV3ZSkoqgVpMkyk2YXTQsvcZKstnkVoOVwCf3f8Ge5+xkflfWXfuME+cJqyyE022uEksKIWDFq8\n", "TG6VjyJXEwqw8yXJJjIYtJ/cZ6MNdAK/leUgOxvsCWRoNA8lqZ4iqe2fMjmZpkROC5Rxz5MiHMa+\n", "/eGXttoiZfgWA6xAknCRDcPAI34lGzit9pmOIHQF/qxvwwGNcukAKc9zsyW6kAqn0fFkImob0o9j\n", "LHcE6NV/lZmdbubXdb1EQTJRj/045XwXzIxoMnjnBekXZAiHzz/BTaI24d/OlM908VZYGpr3pXhY\n", "LW1vGrhBnoPc3ejw0QispQVzU3kGZA812SiJ4p4awbU0CxHsttT6SiJrxHjS0F8fYkXcNTVvmjjH\n", "VopEeVOXJkn2dHnX5pkicQgaO/arFXYXQZPcsAnXGs11s+4b1i+uTjJK9s3R6ChFKHMjaYQ1L5yE\n", "5mh0/BoG0bEI71dYQnM0Ot+Ao8A14FwLtTlo08B14HQae9pAU0rsVyNFNH+nB67OSu2NTqzMGTOp\n", "mhbARpbTqhudecrzrQCJbtJcRE6ranTi/NsezwCBkguJTHJaVaMT4bs1x5JC31uiVTU6nMY3r0Ua\n", "1WY1Onyl/VA0+Eot1VbV6ETn2RrLiGmtPYWaRqejDIzm8qz1VLPN1+ZodNj6enX9L2t30s3TRIbV\n", "6LA3y5BRodTOshNixlqNDnvrDWnprTdzrUYnqhmW1r5IJs1qdNjXkougmn7b1MBKK9Gr+ZJXKA1r\n", "TdVWl7pGq7tFrgG0b239V2pX+/6V6tP+A/XNQ3RzkyOMAAAAAElFTkSuQmCC\n" ], "text/latex": [ "$$\\left [ \\frac{\\log{\\left (2^{s_{e} + 1} - 1 \\right )}}{\\log{\\left (2 \\right )}}\\right ]$$" ], "text/plain": [ "⎡ ⎛ sₑ + 1 ⎞⎤\n", "⎢log⎝2 - 1⎠⎥\n", "⎢────────────────⎥\n", "⎣ log(2) ⎦" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import sympy\n", "sympy.init_printing()\n", "yh, y2h, se, sm = sympy.symbols('y^h, y^{2h}, s_e, s_m')\n", "Eq1 = sympy.Eq((2**sm*yh-y2h)/(2**sm-1)-(2**se*yh-y2h)/(2**se-1) , (y2h-yh)/(2**sm-1))\n", "sympy.solve(Eq1, sm)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAIkAAAA/BAMAAAAmmfaSAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA\n", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMARM1UEDKrie+7Inbd\n", "mWYDwv/QAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAD40lEQVRYCe2YTUhUURSAz+j8z5tpQKpdTla4\n", "KHBgNgmZD4JsITEISS3EKVpZkK2EYsSKokWQUAQG0YO2mi4CCze2NdBZBOFCcFcmiYJiRfE659z7\n", "3ryfueNMugm6i3vPPefc751773vnDAPNppmB3bSXppmF5lwuXQVyaLWKkU1NuU6kqL2KL3QYOF/Z\n", "3uNQR5WUUBoiRjgDfccgNbzsWCLEvus4JqRaTbkEoBmhnxGjC1ag5KPAKVQFCkKvphxFSjq+kVp7\n", "A62ndeHt7IkCw0KjpCSnyKFxk/rnoNPgbkzRdFZalN5Wtw9Msl1j1sTasseKU6YkxFYtSvCBx6/I\n", "c9F7TGLKlPg6TywKPPO43qN5SjzKYWrk4EjBFJhnm4oS4gM5CPsdBBK9lMWqlNQImkNHck/Zq9yV\n", "KSdZ+ZZ7ZyxdMzcBDhRX36ElmcEuappi3+zKnU2ZWLhGimadegclNAexqcAmzNMbGRslq7/ZFGnq\n", "z5PgoGiDENoKzwK92tBQoN7fvJTJNPk4KP1ZgO3kiKBoJTSajraO80hLy4m7LS0FFPeRCcdJXOSi\n", "dKYBfsS3gnzHu4rld3x6Ok/0MoWyQ7nZO4osfiRtv0G9Y0fREgQ2GjEgauFRMYrsIGUcbMotuEJa\n", "zx2NQeg+NAwGDl8wyJoYoR4bZQchcW9T5kQYX1hrxdJrDsDE0GWANvN7CS1446JRdpAiDTblPfD1\n", "eN5d6RnLBl99IPmOVFjZQU5tCkCnjrrjrLdikU7QjsIKTT5ZGtCmbBEgaNgTelhQhOyldOcBnpDj\n", "RdtbkR0itPFUgd28lODQTBFBeElZtlfKDsLwjQaNfcs3LdfYQzAjRX92YENgMICEz8LJG4tcikOH\n", "ECtkBzb05Np1iI8KJzVFvn8VsgOvfEyfUVLfiSLstfXqWGpb747FkQPqFRG0t7HUE7/f95+M5bXY\n", "x1f/dlCj2JGv+ONbGl8ay0PYqIRRUHzFv8GAsxDZAPvzcsEUFF/xxy/4KsBDgNuu5XJSK2UO4BHA\n", "jTyc2wUlPosZWSdKQ7oCpkoszuKfKPHaBR2SQnKj1BR38V+mZYFtTH0ZkjxNTXEVfy1L67QCVoRZ\n", "kjxNTXEV/yifxhIuDq17CDRVU1zFnyl8OHVSKBa7+POOOiBuQGC2rliizuIfW8a9lCBh1He6nuJP\n", "JWx8qIg/s5KDtcfiK/64jzbT/IU/bPK1UyxPu/jjFyDauCU4R9UdSR+7+HM9JWVdX6OkdGP8XPxj\n", "htDUlxkkxS7+mKW4WTRpl8MOOyo7/03GLK+uSao5lqq0/5TKx0Pnsif/Vpyp/m9F5ac7tU25nPEH\n", "mzNHZ8UJAgUAAAAASUVORK5CYII=\n" ], "text/latex": [ "$$\\left [ \\frac{\\log{\\left (\\frac{2^{s_{e}}}{2} + \\frac{1}{2} \\right )}}{\\log{\\left (2 \\right )}}\\right ]$$" ], "text/plain": [ "⎡ ⎛ sₑ ⎞⎤\n", "⎢ ⎜2 1⎟⎥\n", "⎢log⎜─── + ─⎟⎥\n", "⎢ ⎝ 2 2⎠⎥\n", "⎢────────────⎥\n", "⎣ log(2) ⎦" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Eq2 = sympy.Eq((2**sm*yh-y2h)/(2**sm-1)-(2**se*yh-y2h)/(2**se-1) , -(y2h-yh)/(2**se-1))\n", "sympy.solve(Eq2, sm)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So, for Euler's method where $s_e=1$ we find the interval must be:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Acceptable interval is [0.584963, 1.58496].\n" ] } ], "source": [ "print(\"Acceptable interval is [{:.6g}, {:.6g}].\".format(log(1.0+0.5)/log(2.0), \n", " log(2.0**2-1.0)/log(2.0)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This matches well with the results above, and is completely independent of the data, and indeed the method: the only thing that matters is the expected convergence rate $s_e=1$. As we vary the expected convergence rate, the acceptable *measured* convergence rate also varies, and in fact the acceptable interval around $s_e$ gets larger:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAhIAAAGQCAYAAAD7rYnxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xm4ZGV57/3vveeh5wlo6EmEZkaExCgYAdEjKhonnBKN\n", "x/jyxsQ35DXG4SQB5eiBI4knmmhIYo4xMRrHaNCDRgVjiIIzKiIk0AwiIN0t3XRDd9N9nz/Wqt3V\n", "xe7uXWvX3jXs7+e61lVVa9p39bDrV896nmdFZiJJklRFX7sLkCRJ3csgIUmSKjNISJKkygwSkiSp\n", "MoOEJEmqzCAhSZIq6/ogERGHRcRVEbGn3bVIkjTXDLS7gOmIiOcDlwM7gaYmxIiIDcDmSTa9PjO/\n", "PP3qJEnqfV0dJIDXA2cDFwNHN3lsZuYpLa9IkqQ5pNuDxBmZmRHR7jokSZqTurqPRDq/tyRJbdXV\n", "QWK6IuKyiLg2In4cEZ+PiPPaXZMkSd1kLgeJ+4BvZebpwPHAp4FPR8RvtbcsSZK6R/TC1YGI+ADw\n", "isycVjCKiCuBJwMrMnNHK2qTJKmXdXtny1a7HngmcBzwndrKiOj+tCVJUpMy86CjGeZkkIiIEaA/\n", "M7c1bNpdPvY3HjOVP8xuFREXZ+bF7a5jpvj+ulcvvzfw/XW7OfD+pvQlupf6SOz3DUfEIbHvGNGX\n", "AH88ya6nAg8DN7a4NkmSelIvBYlJWwwi4nTgbuDPGza9NCJOq9vvxcBzgf+ZmdtnrEpJknpIV1/a\n", "iIj3AucCy4CMiNsoWibWZ+aucretFFNh31136OeAI4D3RsQgsAjYBFyQmX89W/V3kGvaXcAMu6bd\n", "Bcywa9pdwAy6pt0FzLBr2l3ADLum3QXMsGvaXUAn6IlRGzMtIrKX+0hIktRoqp99vXRpQ5IkzTKD\n", "hCRJqswgIUmSKjNISJKkygwSkiSpMoOEJEmqzCAhSZIqM0hIkqTKDBKSJKkyg4QkSarMICFJkioz\n", "SEiSpMoMEpIkqTKDhCRJqswgIUmSKjNISJKkygwSkiSpMoOEJEmqzCAhSZIqM0hIkqTKDBKSJKky\n", "g4QkSarMICFJkiozSEiSpMoMEpIkqTKDhCRJqswgIUmSKjNISJKkygwSkiSpMoOEJEmqzCAhSZIq\n", "M0hIkqTKDBKSJKkyg4QkSarMICFJkiozSEiSpMoMEpIkqTKDhCRJqswgIUmSKjNISJKkygwSkiSp\n", "MoOEJEmqrOuDREQcFhFXRcSedtciSdJc09VBIiKeD1wLrAWyyWMHI+KSiPhRRHw/Iq6NiNNnok5J\n", "knpVVwcJ4PXA2cDXgWjy2PcALwLOyMwTgb8BvhARJ7e2REmSele3B4kzMnNDswdFxHrgNcClmbkR\n", "IDPfD9wGvL2lFUqS1MO6OkhkZlOXM+o8j6IF4+qG9VcDT4+IsWkVJknSHNHVQWIaTgJ2A3c0rL8N\n", "GACOm/WKJEnqQnM1SCwDtk/SorGlfFw6y/VIktSVBtpdgCSpe0VEUFwqDoovp/WPtYUmXlfd1o59\n", "qXvkIOtasW/zx8U+z4u6++rO8ejtxfM97GKK5mqQuB8Yj4hoaJVYUD5ubDwgIi6ue3lNZl4zc+VJ\n", "6lQR0Qf0NyyTrTvQ0tfwfN8P4qCPfvoJ+uijn6CfPvqIcl3QB+W24rE4X+zz2LfPvjHxs/Zuq/38\n", "IMiGdbV9su4c+waFYjmMPoIsP4ayfCfF79Xa8yhfFY+114/+SNx73FT2nXzdgbY1s71Wb1FTfT3x\n", "qGP3fR4Tx7DP8TnJno8+T+O++z5v/Hn7/gzq/vz2PWM2HAdMsu4uDuVnHArAZvrZypTM1SDxPeAl\n", "wCr27SexDtgF3Nh4QGZePCuVSXNY+e22HxiqW6p9YAf9DDBIf7n0TSwDBIPlMrDPIwyUH7gDUK5n\n", "YinWr6Sv/HjN8qN07+O+H9X7Vlz/Ud5P/Ud4LTow8bz+A3nvsvc15c+jrONA+9Y/b9z30cdSrttN\n", "8Ejd63337dtn370f9upup9R9Hn6II9jKSVM5rJeCxH5HcETEIcB9da0PnwLeAZwF/G3drmcBX8jM\n", "7TNWpdQjym/mQwdZBoEhBhhhiDEGyqWPUfoYJRglGAFGCIY5jBH66aOfZJAsP75zPx/MjR/OUfeB\n", "XfsunfSxp+Hx0ev6J33cTT+7yp9frKs9lzShl4LEpJm4nK3yX4ErgNcCZObNEfGXwJsj4srM3BgR\n", "r6JokXjZbBUszYbyW37xgX6gD3sYIhhimHEGGWOAUfoaPvRrH/gwzEoGGSAZIMvv8sVjscTE4xBR\n", "7reHAXZPLIP7LDsYYjuD7KbfD2qpm3R1kIiI9wLnUozCyIi4jaJlYn1m1jqKbAU2A3c3HP464CLg\n", "2ojYRTFi4+mZecOsFC81ISL6gXFg3sQSzGOMpQwyTn/5gR/l0scwlN/0D2O4/CCvfdjXf+Dv+6Ff\n", "NObvpp89DE76of8IQ+xgqNzHJm1pzovqczrNHWWfTH9lqqXKloIR6sMBzGOIhYyxjEGW0sdS+lhM\n", "MI8R9jBKMgaMEYzTxwiPTHzgD06yDJWP/uuV1IwPcQS38OqpfPZ1dYuE1IkiYoDGcBDMY5xlDLOU\n", "AZYQLOEwFjLEAKNkGRCC8YkLCDsZZSdj7GCcLYyyyWvzkjqRQUKagrL1YIzGgDDCYkZZygBL6WcJ\n", "wSIOZ5wR9jA20XrQxxjBKLsmAsI4OxnnHgbZ0873JUnTZZDQnBYRg8B86sNBH/OZxzKGynDQx+Ky\n", "9aCvbDlIxqHslZCMspMRdjLGTsZ5gFHu91KCpLnCIKGeFREjwGHAImAeoyxmhGUMsKRsPVjMEYww\n", "uk/fgz7GgRF2MTpxeWEn49zNgK0HktTIIKGeEBGjwGEEh7GQoxnmaFZxCEtIFlJrPdg90XJQhION\n", "DJeT7kiSKjFIqOvUhYaVLOQohlnPKlawlGQ5wVJ2sJQHWcqddlCUpJllkFBHi4gxai0Ni1jPEEex\n", "mhUsYQ8r6CtDw1aWGBokqR0MEuoYZWhYOREahjmK1Szfp6VhGVtZwh1ejpCkzmCQUFtExDi1yxOL\n", "OJph1rOapWVo6GMpD7GMBw0NktTZDBKacWVoWEk/K1lYXp5Yw1KWsqcMDQ+zjK0sNjRIUrcxSKil\n", "ImIecBh9HM4ijmaIo1nDEpaSrCBYwsMsZyuLDA2S1AsMEqqsDA0r6WMliziGIR7LGpawbKKlobg8\n", "YWiQpJ5lkNCURMR89rY01C5PLGbZREvDQyxnKwsNDZI0lxgktI/ynhKNoeFo1rKIZexmOf0sYbuh\n", "QZIEBok5r5xGei0DHM5CjuFQHssIC+suT2xnGQ+ykNsNDZKkRgaJOSoiFjPKkzmcc1nJEMuJiZaG\n", "BTxgaJAkTYVBYg4pL1usYiHnsJbTORY4lvtYwI521yZJ6k4GiTkgIvqBY1nGs1jGsRzPDtZzN0Ps\n", "bndtkqTuZpDoYRExQj+ncgjP5QiWczwPso4NXraQJLWKQaIHTfR/WMkzeCyjHMcmDuX2dtclSeo9\n", "BokeMdH/YUHZ/+EY4DjuYwH3tbs2SVLvMkh0uYjoA46r6/+w0/4PkqTZYpDoUvv0fzic5RzPNtZx\n", "O31ku2uTJM0dBokuU/Z/OIOVnMuRjHA8m+3/IElqF4NEFyj7PxxR9n84w/4PkqROYZDoYGX/h2NZ\n", "WvZ/OIFd9n+QJHUSg0QHmuj/sILncAQryv4Pd9j/QZLUaQwSHaSh/8Moxzv/gySpsxkkOkBErKrr\n", "/xAcy70stP+DJKnzGSTaZJ/+D+s5luPZxTH2f5AkdReDxCwr+z88nhU81/4PkqRuZ5CYJRGxqOz/\n", "8EyOLO9/cZj9HyRJ3c0gMcMm+j+sqZv/wf4PkqQeYZCYAQ39H47jeHawnrsZtv+DJKm3GCRaKCKG\n", "y/tfPIeVHMLxbOMx3v9CktS7DBIt0ND/YYTj2Gz/B0nSXGCQmIaIOIIFPJU1/LL9HyRJc1FLg0RE\n", "nAcsBj4MHAYsy8xvt/JntFtd/4dzWc/xHM9O+z9IkuaqVrdIBPCPwHmZ+cmIeALQE0Fiov/DCp7D\n", "4RP9H5z/QZI0p7U6SPwS8EVgW/l6e4vP3z4reRePKe9/Yf8HSZKA1geJK4HvAjdFxJHA4cBnW/wz\n", "2uPFPGD/B0mS9tXXypNl5r8DZwH/AuwE3tHK87fVQna0uwRJkjpNpRaJiHgW8FLgtcAwcAZwbWbe\n", "l5k/Ad7TuhIlSVKnqnpp42jgq8AYcB3wM+DeiLgoM7/ZquIOJiJWAO8CTi1XfR+4sAwzBzt2A7B5\n", "kk2vz8wvt6xISZJ6WOU+Epl5RUQ8F1gBPA54ALgUmJUgERFDFJdQbgKOK1f/DXB1RJySmdv2e3Ah\n", "M/OUmaxRkqReV7WPxMqIOBX4deC6zNycmXuAO1pW2cG9EjgReGNm7il//huBxwC/OYt1SJI0Z1UN\n", "EpcBbwbWAr8PEBHnsnfY52x4AXB7Zm6orcjMe4Eby22SJGmGVQoSmXl/Zr4wM0/JzOsjYjHwcWBN\n", "a8s7oJOA2yZZv4GipeKgIuKyiLg2In4cEZ8vZ+aUJElT1JLhn5m5GViemRe34nxTtAzYOsn6LcBY\n", "RAwf5Pj7gG9l5unA8cCngU9HxG+1tkxJknpXy+aRyMzZnsVyWlNTZ+YTMvOj5fNHMvO9wOeAd0wh\n", "hEiSJKY5s2VEDGXmzlYV06T7gfmTrF8AbMvMKhNIXQ88k2IUyHf22fJRzpx4/hg2cBobKpxfkqTO\n", "9E3WcitrAbiXBVM9bLpTZH8AeNk0z1HVDcAxk6xfRzGfxH5FxAjQP8kQ0dodPPsfddD5XNN8iZIk\n", "dYnT6r4kf4gj2MKUpkiY7qWNwWkePx2fBNZExEQHz4g4hCJcfKJ+x4g4JCKibtVLgD+e5JynAg9T\n", "jPyQJEkH0dJ7bcyyD1C0PFwWEf0R0UcxIdatwPtqO0XE6cDdwJ83HP/SiDitbr8XA88F/mcb+ntI\n", "ktSVWn33z1mTmbsi4mkUU2TfSNH58vvA2Q1BYCvFVNh31637HHAE8N6IGAQWAZuACzLzr2ejfkmS\n", "ekHXBgmAzLwPePlB9rmBYqho43H/vVwkSVJF3XxpQ5IktZlBQpIkVWaQkCRJlRkkJElSZdMNEle1\n", "pApJktSVphUkMvP9rSpEkiR1Hy9tSJKkygwSkiSpMoOEJEmqzCAhSZIqm7EgERFPLO9jIUmSelRL\n", "g0REvDgi/iQiXgjcRHG7bkmS1KNa3SJxGPARYB3wKeCsFp9fkiR1kFbf/fOOzLweuB54Z4vPLUmS\n", "OkyrWyQWRsRfR8SZETHU4nNLkqQO0+ogsQ74LPBs4OqI+GSLzy9JkjpIqy9tfDczP0XRP4KIGGnx\n", "+SVJUgdpdYvEoRHxpog4EiAzH27x+SVJUgdpdZBYCjwAvCMivhUR72vx+SVJUgdp9aWNLwFjmfk+\n", "gIhY3eLzS5KkDlKpRSIinhURfx8RCyJieUQ8LyJWZOa/Z+YXa/tl5h2tK1WSJHWaqi0SRwNfBcaA\n", "64CfAfdGxEWZ+c1WFSdJkjpb5T4SmXkF8ARgBfA04Dzg/BbVJUmSukDVFomVEXEq8OvAdZm5GSAi\n", "vJQhSdIcUjVIXAb8BbAWuAAgIs4FtrWmLEmS1A0qBYnMvB94Ye11RCwGPo7315AkaU5pyfDPzNwc\n", "Ecszc3srzidJkrpDyyakMkRIkjT3tHpmS0mSNIcYJCRJUmUGCUmSVJlBQpIkVWaQkCRJlVUa/hkR\n", "TwHOBEYz800RcSbwrczc2sLaJElSh2uqRSIi5kfEF4GrgYuAV5SbzgVuiIh1La5PkiR1sGYvbVwK\n", "jFIEh9XAfQCZ+UbgzeV2SZI0RzR7aeNc4OTaJYyIyNqGzPxIRLyhlcVJkqTO1myLxK6D9INYNJ1i\n", "JElSd2k2SGyLiBdOtiEingVsnH5JkiSpWzR7aeMS4OMRcS1wLbA8Iv4AeBxwHvCCFtcnSZI6WFNB\n", "IjM/FREvo7hd+Bnl6rcBdwAvy8wrW1yfJEnqYE3PI5GZ/xgRHwXWA8uA+4EfZ2Ye+EhJktRrKk1I\n", "VYaGmxrXR8R7M/O1065KkiR1hQMGiYh4JTDVloYAnjXtipoQESuAdwGnlqu+D1yYmT+ZwrGDwB8B\n", "LwQeAbYAv5+Z185QuZIk9ZyDtUj87ybPN2uXNyJiCPgXipaR48rVfwNcHRGnZOa2g5ziPRTTfJ+e\n", "mRsj4tXAFyLiSZn5vZmqW5KkXnKwIPEj4JkUrQ1T8dnpldOUVwInAs/NzD0AEfFG4CfAbwKX7+/A\n", "iFgPvAZ4dWZuBMjM90fE7wJvB549w7VLktQTDhYk3p2Zt0/1ZBHx7mnW04wXALdn5obaisy8NyJu\n", "LLftN0gAz6MIR1c3rL8auCAixjJze4vrlSSp5xwwSGTmFZOtj4ijgF8EVgJ3A9dn5i3723+GnMQk\n", "HT6BDcDZUzh2N8Ww1Xq3UfyZHAd8c5r1SZLU85oatRERY8AVwEvZd1bMPRHxD8AFmflQC+s7kGXA\n", "ZNN1bwHGImI4M3cc4NjtkwxZ3VI+Lm1RjZIk9bRmh3/+KfAU4E3At4HNwBKKURO/Dbybou/BbJjd\n", "eSs+ypkTzx/DBk5jw6z+fEmSZtI3WcutrAXgXhZM9bBmg8TzgFMy886G9V+KiI9QhIvZChL3A/Mn\n", "Wb8A2HaA1ojaseMREQ2tErU/uEffM+R8rqlYpyRJne+0ui/JH+IItnDKVA5r9qZdd0wSIgDIzDuA\n", "u5o833TcAKybZP06ivkkDuR7FO991STH7gJunHZ1kiTNAc0GiW9HxOMm21Cun6zz40z5JLAmItbU\n", "1XAIcAzwiYbaDomI+iGsn6K4NHJWwznPAr7giA1Jkqam2Zktv0Nx989/AX5I0TlxAXAC8ByKm3nN\n", "lg9Q9Mu4LCJeXtZ5KXAr8L7aThFxOvCvFJ1EXwuQmTdHxF8Cb46IK8sJqV5F0SLxsll8D5IkdbWq\n", "M1tesJ/1l1NMWT3jMnNXRDyt/Hk3UgSJ7wNnN7QobKXoFHp3wyleB1wEXBsRuyhC0dMz84YZL16S\n", "pB7RzTNbkpn3AS8/yD43UAz3bFz/CPCH5SJJkipo9cyW75lmPZIkqYscsLNlhZkq3z+NWiRJUpdp\n", "dtTGwVzX4vNJkqQO1uyEVETEqcCrKUY4DNdvAo5qUV2SJKkLNNUiERHnUgylPAU4gyI89FHcvOsp\n", "zO48EpIkqc2abZG4CDgnM78WEd/JzIkJnSLiRcATW1qdJEnqaM32kRjJzK9NdmxmfgymNi+3JEnq\n", "Dc0Gid11z3dFxMrai4hYRDE9tSRJmiOaDRJ3R8QlETECfAX4fERcGBEXlq+92ZUkSXNIs30k/gQ4\n", "H1gOvIOiT8SflNtuBV7autIkSVKnaypIZObVwNW11xFxBvBY4BAgMtMWCUmS5pBmh3/+W/3rzNyT\n", "mTeXLz8YEe+b5DBJktSjmr20MT7Zysz8akQcCXxv+iVJkqRucdAgERFrgDUUk0/Ni4hfnmw3YBUw\n", "v7XlSZKkTjaVFolXAX9U9/qa/eyXwCXTLUiSJHWPqQSJD7A3PPwV8BsULRD1dgEbMvMnLatMkiR1\n", "vIMGiczcAGwAiIj/lZlfmeGaJElSl2h2+OefA0TEUcAvUtys627g+sy8pfXlSZKkTtZUkIiIMeAK\n", "iomn6oeO7omIfwAuyMyHWlifJEnqYM0O//xTituFvwn4NrAZWAKcCvw28G7gNa0sUJIkda5mg8Tz\n", "gFMy886G9V+KiI9QhAuDhCRJc0SzN+26c5IQAUBm3gHcMf2SJElSt2g2SNwYEY+bbEO5/tsN695T\n", "tTBJktT5mr208S3gcxHxaeCHwBZgAXAC8FTgXRHxinLfAJ4DvK5FtUqSpA7TbJC4vHy8YD/b/6zh\n", "dTZ5fkmS1EWaDRI/Ap7Jo2e23J/PNnl+SZLURZoNEu/OzNununNEvLvJ80uSpC7SVGfLzLxiJveX\n", "JEndpdkWCQAi4inAmcBoZr4pIs4EvpWZW1tYmyRJ6nBNtUhExPyI+CJwNXARUBuhcS5wQ0Ssa3F9\n", "kiSpgzU7j8SlwChFcFgN3AeQmW8E3lxulyRJc0SzlzbOBU6uXcKIiInhnZn5kYh4QyuLkyRJna3Z\n", "FoldB+kHsWg6xUiSpO7SbJDYFhEvnGxDRDwL2Dj9kiRJUrdo9tLGJcDHI+Ja4FpgeUT8AfA44Dzg\n", "BS2uT5IkdbCmgkRmfioiXga8EzijXP02irt+viwzr2xxfZIkqYM1PY9EZv5jRHwUWA8sA+4HfpyZ\n", "3ldDkqQ5ptKEVGVouKn2OiIWUNwJVJIkzSHNTkj1qxGxOSLuaNj0+Yj4u4gYaWFtkiSpwzU7auPX\n", "gPcDxzasfxawjV6ekOo+5rW7BEmSOk2zlzYOA57R2B8iMzdFxG8D32pZZZ3mk/TxWNbweO5jCQ+1\n", "uxxJkjpBs0FieH+dKjPzkYgYbUFNneke3sQmnsStvJD1LOcU7mUBO9pdliRJ7dRskNgSEc/JzM80\n", "boiIZwM/b01ZUxMRFwKvAR4pl7dl5qencNzFwKuATQ2bvpKZF052TGbuBK6JiOvYyFO4mV/heIY4\n", "mZ8yzq5pvRFJkrpUs0HircCnIuJq4BsUH8SLgV8AzgKe39ry9i8i3gS8HvjFzLwtIs4BPlcGnasO\n", "cngCf5iZH2z252bmQ8BVEXEtmzmHm3gmJxKcxE8ZZnfz70SSpO7V7IRUV0bES4E/Bs6p23QH8NLZ\n", "mpAqIhYBfwi8MzNvK2v7YkR8AbgcOFiQAIjp1FDec+RTEXENm3gGN/I0TuYRjuceBtkznXNLktQt\n", "qkxI9fGI+ATtnZDqGRS3M7+6Yf3VwDsjYn1m/ng2CsnMzcCHI+JLbOI8fsCTOYWHOYZ76cdJuiRJ\n", "Pa1bJ6Q6qXy8rWF97fWJwMGCxDMi4teAFcAu4Erg0vLSRdMy8z7g/RHxee7neXyfU3k82zmK+6bX\n", "9iFJUufq1gmplpWPjbc0r4WZpQc5fjvwIPD8zDwJeDXwq8CXIqJSuKrJzLtyc76Hm3gbV7GBT7KO\n", "21hi24QkqRd1xIRUEXFOROyZwvLlKudvlJnvzMzXZOaW8vV3gTcCvwSc36KfcSubeCff51I+y0b+\n", "mbXcxcJWnFuSpE7RKRNSXQscM4X9tpeP95eP84HNddsXlI8bK9Rwffn4BOAfGjeWQ0ZrrsnMaw52\n", "wvLP6UcRcQmbOJG7eAlrWcep/IxDeLBCjZIkzYxvspZbWQvAvROfpwfVERNSlf0Sbm7ikO+Vj2sp\n", "RozUrCsfbzjQwRGxPDN/1rC6NnSzfz81XtxEfY3H7gG+FxE/YCOncQfncyRrONVZMiVJHeI0NnAa\n", "GwD4EEewhVOmclizlza2RMRzJtswyxNSXUXROnFWw/qzgB9m5kQoiYixiGi8pHB7RDS+91PLx2+3\n", "tNI6mbk7H8nruIc3cx0f4GOM8RXW8ADDM/UzJUmaSV05IVVmPhARlwCvj4gP1k1I9XTgvIbdvwMs\n", "jog1dSMyRoC3RsRFmbknItZQ9O+4iUkua8xA/TuBr0TE9Wzil7mZ53EcQzzOWTIlSd2lKyekKmu5\n", "LCIeBq6MiEcoLk28MDM/37Dr3cBOiim0a14OvAz4bkT0A2PA/6GY7fLhma++UAabz0/MkvljnsUJ\n", "BCc7S6YkqTtElXmkIiKom5AqM28q178nM1/X2hLbLyIyM2d8NoiIWMw8nsFyzuFkdjtLpiSpLT7E\n", "EdzCq6fy2VcpSDzqJEV/g2cBf5WZh077hB1mtoJE3c9bwQKezQqezCnscJZMSdKsaiJITGvypYg4\n", "GXglxWWCFeCHXSuUs2T+TUR8no08j+9zGqewnaOdJVOS1FmaDhIRsYKij8ErKaaq3gV8Ffgs8NqW\n", "VjfHZeZPgD+LiHXcxwv5PifweLawjo0GCklSJ5hSkIiIIeA5FOHhv5THfYViYqjH1maILDs9qsXK\n", "USmXs4n13MP5rOYxPJ7NHMED7a5NkjS3HbSPRES8F3gxxTDPzcDfAn+RmTdHxG2Zue6AJ+gBs91H\n", "4kDK/ignsoIXs5aVnMr9zpIpSWqpFveRuIBiaOUbgD/LzB3TrU/VNcySeSq382Iey1oez30snZhC\n", "XJKkWTGVILGa4s6YLwdOiYi/yMx/m9mydDCZuRu4PiK+y0Z+iVt5EetZzincw0IMe5KkWdHU8M+I\n", "+AWKfhInAh8H3pCZq+u2H10/PXWv6KRLG/sTESMM8xSW8Sscx7CzZEqSKpvpeSTKzpfPpriteB/F\n", "rJBXAp/JzMc3fcIO1w1BoiYi5jHGU1nKszmRPk7ip4xgJ1hJ0tTN5oRUEbGc4rLHK4ATMnNoWifs\n", "QN0UJGoiYlE5S+bTOIk9nMBPnSVTkjQlsz2z5cTJIr6XmSe37IQdohuDRE1ELGcB57GcJ3MKOzmW\n", "e5wlU5J0QLM1s+UkGm/rrTbLzJ+xd5bMX+EH/IKzZEqSWqWlQSIzN7XyfGqdcpbMP3eWTElSK7W6\n", "RUIdrm6WzKO5h/NZxZEcz4OsZjND3rpcktQcg8QclEXHmB9HxNu5nxO4k7MY4UQOp4/V7GI1G5nP\n", "znbXKUnqfAaJOaycJfMG4IaIGOEuHsuPOIVxnsByRllDsorNLGeblz8kSZMxSAiAzHwY+AHwg4j4\n", "B37Kam7hBBbwJBawpgwVWzmCnzvqQ5JUY5DQo5TTb98G3BYRV3Ivy7mVY1jCExllPauA1exgNRsZ\n", "dbIrSZrLDBI6oLI/xX3l8q8RMY87OIobOY1RTuVQBlnDHlaxiSU81OZyJUmzrKUTUvWqbp6QaiZF\n", "xCCwjnFOYj5PZBGLWQus4gEOYwt9XgKRpK7UxgmpNIdk5i7gZuDmiPgE97CS/+RYFnM646xhNcEq\n", "tjm0VJJ6l0FCLVFeAvlJuXwxIhaxgaNZwhMY5SRW0s9qHmE1G1ngbc4lqVcYJDQjMvPnwPXA9eXQ\n", "0iO5qRxauowVrAFWsZkVPOjQUknqXgYJzbhyaOkPgR/uM7R0IU9iPqtZQ0wMLR3wDqWS1E0MEppV\n", "5SRYG4ANEfFZ7mUZt5VDS0dYzyqiHFq6iTF2tblcSdJBGCTUNmW/ip+Vy1cjYpw7OZobOZUxTuMQ\n", "BsuJsDaCjRZZAAASQElEQVSxlO1tLleSNAmHf06Bwz9nX0QMAOsY4yTm8yQWs7jsV/EAKx1aKkkz\n", "yuGf6naZ+QhwC3BLRHySezmsHFr6JMZYx2pgFQ+xmk0MO7RUktrFIKGOV14CubtcvhQRC9nAepbw\n", "i4xyMivpYw27WcVGFjq0VJJmk0FCXSczH2Dv0NJhfsKR3MTjGOeJLOOQsl/FzzmErQ4tlaSZZZBQ\n", "V8vMHcCNwI0R8RHuYRW3cDyLOJ35rGY1sIIdLGI7S9juDJuS1FoGCfWMcmjp7eXyuYhYxn9yNAs5\n", "mmHW0sfhzKOfxexhCX0sZCeL2MYSttvPQpKqMUioZ2Xm/cD9wL8DREQfsBhYTrCcBaxlmHX0czjj\n", "DLKYZDF9LKoLGCPeJl2SDsQgoTmjbLHYWC43AV+FiYCxiL0BY00ZMFYxxgCLybIFY1d5iWQbowYM\n", "SQKDhFQLGJvK5cfAvwFERAALgeXAChawhhHW0s8qRhmuu0TyyEQLhrNxSppjDBLSfpTDTn9eLrcA\n", "18JEwFhAETCWM5/VjLKWPtYwygiLyhaMRRMBYxtj7HIEiaReZJCQmlQGjAfK5T+Ar8FEwJhPLWDM\n", "YxVjrKOP1YwwxqKyBWMRu1lYXiKZx04DhqRuZpCQWqQMGFvK5T+Br8NEwBinFjDGy4DRz2qGmTcR\n", "MBazh4VsYzHbmc8OA4akbmCQkGZYGTAeLJfbKCbTAiAixrm9DBhjHM54GTCGOLQMGFEGjO0sZhsL\n", "DBiSOotBQmqjzNwGbKO4tfo3ausjYow7yoAxykrGeQwDrGaQQ1nE7jJgwAK2M84ORtnFODvp92Zm\n", "kmaXQULqQJm5nb2Ta02IiFHuZBmwnBFWMo919Jc9L2AFQwQjJKMko8AYwSh9jLCLYXYxyk5G2cUY\n", "OxnhEVs3JE2XQULqIpn5EHBnuXy7flvZF2OEoj/G3iUYZ5wlDLGEgTJ0BIvpY4xh9kyEjtEydIyS\n", "DLOTkbrgMc5OBtkzy29XUhfo6iBRTiT0e8AlwP+TmX/b5pKktin7YjxULvcfbP+I6KcxdMA4Qyxg\n", "lKUMsph+FhEsIljCAIOMNASPMfoYYfc+wWOMXYyxiz4vs0hzQdcGiYhYDXyQ4pffIDT3Sysing78\n", "d4pvcIPA3wKXlb+MpZ6XmbvZO8rkgMrWjiEma+0YZTHDLGFgIngsJJjPENRdZgnGyqUWOkYmQsdO\n", "htjtZRapO3VtkAAuBN4H3ANc3cyBEXEG8M/AizLzMxFxBHAdxSRDb2l1oVK3KwP2jnLZdLD9y9bC\n", "URqDxwDzGWUJQyymv7yzSbCMfkYYYU8ZPOr7duxhgN0MsJt+9jDIbgbL14MTyx6G2G0LiNQe3Rwk\n", "fi8z90TEmRWOvQz4WmZ+BiAz74qIdwFvj4j3ZOZPW1moNNeU047XRqQcVEQMAmMUgWMeteAxzAIG\n", "GaOfUQbKHhzBMFH26AhGKVoVh+kn6CcZIBmEukcYJBiceCye95eBZKAurNQCylC5fqh8bWuJtF9d\n", "GyTKX1RNi4jDgCcCb23YdDXFJY7nAFdMrzpJzcjMXeydLbRp5aWXforLL0MU/5cbn+9d18cQw4wx\n", "wBgDjNBX9vboY2QinOwNKUMMQBk4ioAyUJ6ttgwQDJUhpQgzkweUwbqAMlS2shhS1OW6NkhMw4nl\n", "420N629r2C6pS5SXXh4pl+2tPHcZUh4dRvb3fJBhBhljgFEGGCMYoZ9RghGKgDJCMA8YJhgggD6g\n", "j6QfCJJ+slxXLP2TPo+J5/37vA76CfpI+tizz2PUPe+v29Zfbutv2Lb3sXhe1OUlJO1jLgaJZeXj\n", "1ob1tQ5nS2exFkkdrgwpO8ulpcq+JLUoUL9Mtq65bQMM0s8gfQzQzwB9DNJXXtgpHov2lZhYam0r\n", "g+U5BgiGodxv77qYCD4x8VNzYl192Im6x9jP6yhDTxCT7BOP2qev9odXrqMu3NReF8dk3TL5tvrj\n", "6vdtPK5xW1/dcyb2Z7/P9+736OcH2rdLdESQiIhzgC9MYddrMvPsma5HkmZDeYl2D0VLSlc4QPiZ\n", "LOjU9o1JHidbN/VtRcjop79sg+kr22GKxyLi9JW11B6DvokYFHXrqFs/2Tb2eR37rNsbeaAWV/aN\n", "RDS8p/rXtbjQN8nrWqionbs+dBSvi2171+89cy2MxKOO2/fYveetvaodu4XdTFFHBAmK2zMfM4X9\n", "WtFkWRtfP79h/YLyceNkB0XExXUvr8nMa1pQiyR1lW4MP92ovKT26Ajw6BCyv9dV9j29XKCJKRU6\n", "IkiUs/XdPEs/7vvl49qG9evKxxsmOygzL56heiRJ2kd5SW22+6P8U7kAEBFvmMpBfQffpbtFxFhE\n", "LKy9Lod2fg04q2HXs4BdFPNLSJKkKeilILG/rinfAW6JiNG6db8PPCkizgMoJ6S6ELjcOSQkSZq6\n", "6NYZoSPibOD9FOO8V1DMtvcg8JbM/HDdfldTjNR4fDlWvba+NkX2MMWwrb/NzEv387MyM7uoD60k\n", "SdMz1c++rg0Ss8kgIUmaa6b62ddLlzYkSdIsM0hIkqTKDBKSJKkyg4QkSarMICFJkiozSEiSpMoM\n", "EpIkqTKDhCRJqswgIUmSKjNISJKkygwSkiSpMoOEJEmqzCAhSZIqM0hIkqTKDBKSJKkyg4QkSarM\n", "ICFJkiozSEiSpMoMEpIkqTKDhCRJqswgIUmSKjNISJKkygwSkiSpMoOEJEmqzCAhSZIqM0hIkqTK\n", "DBKSJKkyg4QkSarMICFJkiozSEiSpMoMEpIkqTKDhCRJqswgIUmSKjNISJKkygwSkiSpMoOEJEmq\n", "zCAhSZIqM0hIkqTKDBKSJKkyg4QkSarMICFJkiozSEiSpMq6OkhERF9E/H5E7IiIV7a7HkmS5pqB\n", "dhdQVUSsBj4IjAODQDZx7MXAq4BNDZu+kpkXtqpGSZJ6XdcGCeBC4H3APcDVTR6bwB9m5gdbXpUk\n", "SXNINweJ38vMPRFxZsXjo5XFSJI0F3VtH4nM3NPuGnrFNMJYV/D9da9efm/g++t2vf7+pqprg0QL\n", "PCMivhgRN0TEtyLirREx2u6i2uTMdhcww85sdwEz7Mx2FzCDzmx3ATPszHYXMMPObHcBM+zMdhfQ\n", "Cbr50sZ0bAceBC7IzC0R8TjgE8DTIuKXM/OR9pYnSVJ36IgWiYg4JyL2TGH5cit+Xma+MzNfk5lb\n", "ytffBd4I/BJwfit+hiRJc0FkTnnU5MwVUVxSWDWFXbdn5l0Nx54JfBn49emMwiiHk24A3pOZv9Ow\n", "rf1/SJIkzbLMPOjAhI64tJGZDwE3z9bPi4jlmfmzhtW7y8f+xv2n8gcpSdJc1BGXNmZSRIxFxMKG\n", "1bdHRON7P7V8/PYslCVJUk/opSCxv1aD7wC3NIzIGAHeWgsTEbEGuBS4CfiHGa1SkqQe0rVBIiLO\n", "jojbgA9TzFR5eUTcFhEvbdj1buBeoH4kxsuBxwHfjYgfAteUy5Mz8+G6n3FYRFwVEc5ZoY4VEV8t\n", "OyOvbnctkuaejuhs2Yki4vnA5cBO4KjMfFTfiW5VDnf9LeB0ioDVD3wRuCQz729nba0QEUcCv8ne\n", "Md7zKcLkpZn5uXbVNRMi4gXAxyjC9LrMvKPNJU1bRKwFfgDcMsnmMzPzgVktaAaUf2+/A4wBiynu\n", "+/Onmfn3bS1smiLiAxS/Vx5s2LQEOARYmJk7ZruuVoqI04BLgDUUvz8fBv44M/+xrYW1SET8MvBW\n", "4AiK+1j9kGIm6R/t75iubZGYBa8Hzga+Tu9Np/0RYBFwamaeBDwNeDpwbUSMtLWy1jgXeDFwfmae\n", "BhwD/BvwmfI/SU+IiCGKS3Kfo/f+jX4jM0+ZZOmFEPG7FB9Ev1b++1xP0dn87LYW1hoJvLrx7w34\n", "P8CneiBErAW+BNwHnFD+/nw/8OGI+JU2ltYSEfEUivf32cw8KjPXUoxm/NeIOGJ/xxkk9u+MzNzQ\n", "7iJmyB7gjeVoGTLzbuCdwFHAM9tZWIvcBVyUmbcCZNHsdhnFv/fntLOwFvst4DrgG+0uRFNTfhD9\n", "D+B1mXk7QDkB3u8Bf96+ylrmCoq+ZhMiYhx4CfCXbamotZ5J0cL5J7XbNGTmFcAWivfY7S4BfpqZ\n", "l9etexPFXbb/2/4O6ojhn50oe/uaz0mTzN750/Jx0WwX02qZ+U+TrK6N3Gkc9tuVImIJxYfPLwGv\n", "bnM5mrpfo2gO32dyvcz8KXv/D3atzPz6JKvPB+7NzGbv0tyJar83B2srIiIoLg/vaktFrXUaRevt\n", "hMzcGhG3U3wJ+83JDrJFYg7azxTgR1M0S/7rLJcz4yLicIpve9+iN771AfwR8HeZeWe7C5khh0TE\n", "30XEdRHx44j4UESc0O6iWuBJFC1mz4yIqyPixoj494j4r+0ubAa9BvirdhfRIh+maHH5g4gYL0f+\n", "vYUiRPxxWytrjQeZPBfsAQ6NiHmTHWSQEBHRT/Gt9q8z8z/aXU+rRMSREfEfwJ0UfQiel5mNncC6\n", "TkQcBbwIeHu7a5khuym++f1JZj6B4lvSLuC6sqNbN1tVLhcDL8/M4yg6dV8REW9pZ2EzISKOAx4P\n", "fKDNpbREZm4FngqMAvdTdOJ+BfCs8lYL3e47wAkRMXG1opyHaV35csFkBxkkBPCHwA7gwnYX0kqZ\n", "+Z+Z+ViKyxq3AN+LiNPbXFYrXAb8j/KXWs/JzDsz86TM/E75eivw/wLbgHe0tbjpG6H4EPpvZd8k\n", "MvOTwKeBt/TgHYh/A/inXhgNBhAR6yn6JN0GLM7M5RStg1+cZOqBbvQHwFLgHRExWP57fBd7L+k8\n", "NNlBBok5LiJeBbwQOLfW+bLXZObWzPxdim8P7213PdMREU8Gjgf+YrLNs1zOrCnnd/kBRZ+QbraV\n", "4hJi47fX71IMBT121iuaIeWool+lNzpZ1lxC8a38d2pzDpXDPj8PvC8iBg90cKfLzG8A5wAnUQz7\n", "/ApwA/D3wLbM3DzZcXa2nMMi4teA/x84u1e+MQBExEj9xGJ1fgC8ICIGM7NbO0adQ9Gx6xtFHy8A\n", "Di0fPxcRO4E3Z+ZV7SiuFSJiAfDQJH9Hu+n+Lz83ASfz6PdRu9dPt7+/er8C/DwzW3LX5g5xInDX\n", "JMNYb6F4v2uZfP6TrpGZX6EIEBMi4nMUUyFMqpf+0c6knhvBERG/Cvw+8NTMvK9c9+yIeE17K2uJ\n", "qyJism+ua4EHujhEkJkXZeZjG8bo11onzi3XdW2IKL0beEH9ivLb7Yl0/71wPlM+ntSw/gRgO8W3\n", "wF7xG/ROJ8uae4GVZb+yemsoOiR29aiwiFgdESc1rFsInMEB/i4NElPTU03GEfFyin8UHwCeHhG/\n", "WgaL84CV7aytRZLiXipLoBieFRH/H0WnvXe3tbKZEQ2P3S6BN0TEoTDRGfidFNdu39rOwlrgHymu\n", "sV9UtrwQEWdQBKe398rlxfL+RU8G/ne7a2mx91Bc2nhbbUVEnAU8D/j7zPx5uwprkbOBj0TEYpiY\n", "A+SvgH/JzI/t7yCnyN6PiHgvxQyJyyiuXd5B8QtufTd/owWIiI0U80U0fvAk8NbMfNujj+oeEfEk\n", "im9Dv0DRSWiEoof1ezPzw+2srZXKmfTeRfF3uYDivjK7MvMxbS1smsphnhdQfBBB8X/wRooP2q/s\n", "98AuUf6Svgz4LxSd13YA787M97e1sBaKiLcCx2Tmi9tdS6tFxNMpJmk6lOL3yx6KL2V/tp+h9V0j\n", "Ik6lmC33KGAzxSW3jwGXZ+bu/R5nkJAkSVV5aUOSJFVmkJAkSZUZJCRJUmUGCUmSVJlBQpIkVWaQ\n", "kCRJlRkkJElSZQYJSZJUmUFCkiRVZpCQJEmVGSQkSVJlA+0uQJJqImIZ8EaKG5AB3JyZn21jSZIO\n", "whYJSZ3kL4CPZOa7gO3AS9tcj6SD8O6fkjpGRHwH2EBxW+brgO2ZuaWdNUk6MFskJHWSC4DFwEco\n", "gsRwe8uRdDAGCUkdISIWZ+b1mXkmsBL4GXBGe6uSdDAGCUltFxFjwF0RcW656gHgXuDa9lUlaSrs\n", "IyGpI0TExcDtwDiwGvhoZn6z3PYk4NnA14HMzH9uV52S9mWQkNTRIuJw4GrgccBu4MWZ+cH2ViWp\n", "xnkkJHW65wM3AU+maK34cHvLkVTPICGp0z0EXJWZnweIiNXAHe0tSVKNlzYkdbSIGAfeAvw7MAb8\n", "Z2Z+u71VSaoxSEiSpMoc/ilJkiozSEiSpMoMEpIkqTKDhCRJqswgIUmSKjNISJKkygwSkiSpMoOE\n", "JEmqzCAhSZIq+7+6ayBNI7PtMwAAAABJRU5ErkJggg==\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "s_e = numpy.arange(1,10)\n", "upper_limit = numpy.log(2.0**(s_e+1)-1.0)/numpy.log(2.0)\n", "lower_limit = numpy.log(2.0**(s_e-1)+0.5)/numpy.log(2.0)\n", "pyplot.figure(figsize=(8,6))\n", "pyplot.fill_between(s_e, lower_limit-s_e, upper_limit-s_e, facecolor='green', alpha=0.5)\n", "pyplot.xlabel(r'$s_e$')\n", "pyplot.ylabel(r\"Acceptable $s_m-s_e$\")\n", "pyplot.ylim(-1.5, 1.5);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Summary" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If all you care about is the answer that the algorithm gives you, then the measured convergence rate doesn't matter very much. Use Richardson extrapolation to estimate the exact solution, given multiple numerical solutions, and check that the estimated error is in a range that you're comfortable with." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### More reading" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "See also [this page from NASA on grid convergence](http://www.grc.nasa.gov/WWW/wind/valid/tutorial/spatconv.html). Also [this paper by Liu](http://ocw.mit.edu/courses/mathematics/18-304-undergraduate-seminar-in-discrete-mathematics-spring-2006/projects/xtrpltn_liu_xpnd.pdf), which is rather mathematical, on Richardson extrapolation and its extensions." ] } ], "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.4.3" } }, "nbformat": 4, "nbformat_minor": 0 }