From cfde5859f594b9c0a55cea9bef86fe43a4332317 Mon Sep 17 00:00:00 2001 From: "Ryan C. Cooper" Date: Thu, 2 Jan 2020 17:04:41 -0500 Subject: [PATCH] added problems to 01 and 02 --- ...1_Interacting_with_Python-checkpoint.ipynb | 291 +- .../02-Numerical_error-checkpoint.ipynb | 567 - .../02_Getting-started-checkpoint.ipynb | 10916 +--------------- .../03-Numerical_error-checkpoint.ipynb | 891 ++ notebooks/01_Interacting_with_Python.ipynb | 289 +- notebooks/02-Numerical_error.ipynb | 574 - notebooks/02_Getting-started.ipynb | 10769 +-------------- notebooks/03-Numerical_error.ipynb | 891 ++ .../05_consistent-coding and functions.ipynb | 1017 -- notebooks/4_NumPy_Arrays_and_Plotting.ipynb | 1644 --- .../5_Linear_Regression_with_Real_Data.ipynb | 1246 -- 11 files changed, 2540 insertions(+), 26555 deletions(-) delete mode 100644 notebooks/.ipynb_checkpoints/02-Numerical_error-checkpoint.ipynb create mode 100644 notebooks/.ipynb_checkpoints/03-Numerical_error-checkpoint.ipynb delete mode 100644 notebooks/02-Numerical_error.ipynb create mode 100644 notebooks/03-Numerical_error.ipynb delete mode 100644 notebooks/05_consistent-coding and functions.ipynb delete mode 100644 notebooks/4_NumPy_Arrays_and_Plotting.ipynb delete mode 100644 notebooks/5_Linear_Regression_with_Real_Data.ipynb diff --git a/notebooks/.ipynb_checkpoints/01_Interacting_with_Python-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/01_Interacting_with_Python-checkpoint.ipynb index d6d1366..6a71510 100644 --- a/notebooks/.ipynb_checkpoints/01_Interacting_with_Python-checkpoint.ipynb +++ b/notebooks/.ipynb_checkpoints/01_Interacting_with_Python-checkpoint.ipynb @@ -824,7 +824,7 @@ "metadata": {}, "source": [ "## Reflection point\n", - "When we created `sum_xy` and `diff_xy` two new variables were created that depended upon previously created variables. " + "When we created `sum_xy` and `diff_xy` two new variables were created that depended upon previously created variables `x` and `y`. How else can we accomplish this? Could we make a function? Could we combine the commands in one block as a script?" ] }, { @@ -911,9 +911,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "**None is not Zero**: `None` is a special variable indicating that no value was assigned or that a behavior is undefined. It is different than the value zero, an empty string, or some other nil value. \n", "\n", @@ -924,7 +922,10 @@ "cell_type": "code", "execution_count": 33, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -967,7 +968,10 @@ "cell_type": "code", "execution_count": 35, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -1006,7 +1010,10 @@ "cell_type": "code", "execution_count": 37, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -1066,7 +1073,10 @@ "cell_type": "code", "execution_count": 40, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -1228,182 +1238,113 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Recommended Readings\n", + "# Problems\n", + "\n", + "1. Calculate some properties of a rectangular box that is 12.5\"$\\times$11\"$\\times$14\" and weighs 31 lbs\n", + "\n", + " a. What is the volume of the box?\n", + " \n", + " b. What is the average density of the box?\n", + " \n", + " c. What is the result of the following logical operation, `volume>1000` (in inches^3)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Use the variables given below, `str1` and `str2`, and check the following \n", + "\n", + " a. `str1str2`\n", + " \n", + " d. How could you force (b) to be true? [Hint](https://docs.python.org/3/library/stdtypes.html?highlight=str.lower#str.lower) or [Hint](https://docs.python.org/3/library/stdtypes.html?highlight=str.lower#str.upper)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "str1='Computational Mechanics'\n", + "str2='computational mechanics'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. The following code has an error, fix the error so that the correct result is returned:\n", "\n", - "- [\"Yes, Python is Slow, and I Don’t Care\"](https://hackernoon.com/yes-python-is-slow-and-i-dont-care-13763980b5a1) by Nick Humrich, on Hackernoon. (Skip the part on microservices, which is a bit specialized, and continue after the photo of moving car lights.)\n", - "- [\"Why I Push for Python\"](http://lorenabarba.com/blog/why-i-push-for-python/), by Prof. Lorena A. Barba (2014). This blog post got a bit of interest over at [Hacker News](https://news.ycombinator.com/item?id=7760870)." + "```y is 20 and x is less than y```" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 8, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" + "ename": "TypeError", + "evalue": "'<' not supported between instances of 'str' and 'int'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0my\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'y is 20 and x is less than y'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'" + ] } ], "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" + "x='1'\n", + "y=20\n", + "\n", + "if x \n", - "\n", - "Each time you use an operation, e.g. `+ - / *` you lose some precision as well. \n", - "\n", - "Consider $\\pi$ again\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " no operations 64 bit pi = 3.1415926535897931159979635\n", - "\n", - "1000 operations 64 bit pi = 3.1415926535897922278195438\n", - "\n", - "First 26 digits of pi = 3.14159265358979323846264338\n" - ] - } - ], - "source": [ - "double=np.array([pi],dtype='float64')\n", - "double_operated=double\n", - "for i in range(0,1000):\n", - " double_operated=double_operated*1.0e-16\n", - " double_operated=double_operated*1.0e16\n", - "print(' no operations 64 bit pi = %1.25f\\n'%double) # 64-bit\n", - "print('1000 operations 64 bit pi = %1.25f\\n'%double_operated) # 64-bit after 1000 additions and 1 subtraction\n", - "print('First 26 digits of pi = 3.14159265358979323846264338')" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "realmax = 1.79769313486231570815e+308\n", - "\n", - "realmin = 2.22507385850720138309e-308\n", - "\n", - "maximum relative error = 2.22044604925031308085e-16\n", - "\n" - ] - } - ], - "source": [ - "print('realmax = %1.20e\\n'%np.finfo('float64').max)\n", - "print('realmin = %1.20e\\n'%np.finfo('float64').tiny)\n", - "print('maximum relative error = %1.20e\\n'%np.finfo('float64').eps)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Machine epsilon\n", - "\n", - "Smallest number that can be added to 1 and change the value in a computer" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "summation 1+eps/2 over 1000000 minus 1 = 0.0\n", - "1000000 *eps/2 = 1.11022302463e-10\n" - ] - } - ], - "source": [ - "s=1;\n", - "N=1000000\n", - "eps=np.finfo('float64').eps\n", - "for i in range(1,N):\n", - " s+=eps/2;\n", - "\n", - "print('summation 1+eps/2 over ',N,' minus 1 =',s-1)\n", - "print(N,'*eps/2 =',N*eps/2)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# 2- Truncation error\n", - "## Freefall is example of \"truncation error\"\n", - "### Truncation error results from approximating exact mathematical procedure\n", - "\n", - "We approximated the derivative as $\\delta v/\\delta t\\approx\\Delta v/\\Delta t$\n", - "\n", - "Can reduce error by decreasing step size -> $\\Delta t$=`delta_time`" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Truncation error as a Taylor series " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Taylor series:\n", - "$f(x)=f(a)+f'(a)(x-a)+\\frac{f''(a)}{2!}(x-a)^{2}+\\frac{f'''(a)}{3!}(x-a)^{3}+...$\n", - "\n", - "We can approximate the next value in a function by adding Taylor series terms:\n", - "\n", - "|Approximation | formula |\n", - "|---|-----------------------------|\n", - "|$0^{th}$-order | $f(x_{i+1})=f(x_{i})+R_{1}$ |\n", - "|$1^{st}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+R_{2}$ |\n", - "|$2^{nd}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+\\frac{f''(x_{i})}{2!}h^{2}+R_{3}$|\n", - "|$n^{th}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+\\frac{f''(x_{i})}{2!}h^{2}+...\\frac{f^{(n)}}{n!}h^{n}+R_{n}$|\n", - "\n", - "Where $R_{n}=O(h^{n+1})$ is the error associated with truncating the approximation at order $n$." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "![3](https://media.giphy.com/media/xA7G2n20MzTOw/giphy.gif)\n", - "\n", - "$n^{th}$-order approximation equivalent to \n", - "an $n^{th}$-order polynomial. " - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0,0.5,'velocity (m/s)')" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(t,v_an,'-',label='analytical')\n", - "plt.plot(t,v_numerical,'o-',label='numerical')\n", - "plt.legend()\n", - "plt.xlabel('time (s)')\n", - "plt.ylabel('velocity (m/s)')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "celltoolbar": "Slideshow", - "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.6.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/.ipynb_checkpoints/02_Getting-started-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/02_Getting-started-checkpoint.ipynb index 32f369d..e9f2736 100644 --- a/notebooks/.ipynb_checkpoints/02_Getting-started-checkpoint.ipynb +++ b/notebooks/.ipynb_checkpoints/02_Getting-started-checkpoint.ipynb @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 10, "metadata": { "slideshow": { "slide_type": "subslide" @@ -65,17 +65,17 @@ }, "outputs": [], "source": [ - "function i=code(j)\n", - " % Example of bad variable names and bad function name\n", - " for w=1:j\n", - " i(w)=w;\n", - " end\n", - "end" + "def code(i):\n", + " '''Example of bad variable names and bad function name'''\n", + " m=1\n", + " for j in range(1,i+1):\n", + " m*=j;\n", + " return m" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, "metadata": { "slideshow": { "slide_type": "subslide" @@ -83,18 +83,18 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans =\n", - "\n", - " 1 2\n", - "\n" - ] + "data": { + "text/plain": [ + "3628800" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "code(2,3)" + "code(10)" ] }, { @@ -105,12 +105,26 @@ } }, "source": [ - "## Choose variable names that describe the variable" + "## Choose variable names that describe the variable\n", + "\n", + "You might not have recognized that `code(i)` is meant to calculate the [factorial of a number](https://en.wikipedia.org/wiki/Factorial), \n", + "\n", + "$N!= N*(N-1)*(N-2)*(N-3)*...3*2*1$. \n", + "\n", + "For example, \n", + "\n", + "- 4! = 24\n", + "\n", + "- 5! = 120\n", + "\n", + "- 10! = 3,628,800\n", + "\n", + "In the next block, we have rewritten `code` so the output is unchanged, but another user can read the code *and* help debug if there is an issue. " ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": { "slideshow": { "slide_type": "subslide" @@ -118,20 +132,21 @@ }, "outputs": [], "source": [ - "function count_vector=counting_function(max_value)\n", - " % Good variable names and better help documentation\n", - " % \n", - " % counting function creates a vector from 1 to max_value where each \n", - " % index, i, is stored in each vector spot\n", - " for i=1:max_value\n", - " count_vector(i)=i; % set each element in count_vector to i\n", - " end\n", - "end " + "def factorial_function(input_value):\n", + " '''Good variable names and better help documentation\n", + " \n", + " factorial_function(input_number): calculates the factorial of the input_number\n", + " where the factorial is defined as N*(N-1)*(N-2)*...*3*2*1'''\n", + " factorial_output=1 # define 0! = 1\n", + " for factor in range(1,input_value+1):\n", + " factorial_output*=factor; # mutliply m by 1*2*3*...*N (factor)\n", + " return factorial_output\n", + " " ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 13, "metadata": { "slideshow": { "slide_type": "subslide" @@ -139,26 +154,115 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "cnt_v =\n", - "\n", - " 1 2 3 4 5 6 7 8 9\n", - "\n" - ] + "data": { + "text/plain": [ + "24" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "cnt_v=counting_function(9)" + "factorial_function(4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Defining the function with descriptive variable names and inputs helps to make the function much more useable. \n", + "\n", + "Consider the structure of a Python function:\n", + "\n", + "```python\n", + "def factorial_function(input_value):\n", + "```\n", + "This first line declares that we are `def`-ining a function that is named `factorial_function`. The inputs to the line are given inside the parantheses, `(input_value)`. We can define as many inputs as we want and even assign default values. \n", + "\n", + "```python\n", + " '''Good variable names and better help documentation\n", + " \n", + " factorial_function(input_number): calculates the factorial of the input_number\n", + " where the factorial is defined as N*(N-1)*(N-2)*...*3*2*1'''\n", + "```\n", + "The next 4 lines define a help documentation that can be accessed with in a couple ways:\n", + "\n", + "1. `?factorial_function`\n", + "\n", + "2. `factorial_function?`\n", + "\n", + "3. `help(factorial_function)`\n", + "\n", + "\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mfactorial_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Good variable names and better help documentation\n", + " \n", + "factorial_function(input_number): calculates the factorial of the input_number\n", + "where the factorial is defined as N*(N-1)*(N-2)*...*3*2*1\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/UConn/ME3255/ME3255-CompMech/CompMech01-Getting-started/notebooks/\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "factorial_function?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + " factorial_output=1 # define 0! = 1\n", + "```\n", + "\n", + "This line sets the variable `factorial_output` to 1. In the next 2 lines we update this value based upon the mathematical formula we want to use. In this case, its $1*1*2*3*...*(N-1)*N$\n", + "\n", + "```python\n", + " for factor in range(1,input_value+1):\n", + " factorial_output*=factor; # mutliply m by 1*2*3*...*N (factor)\n", + "``` \n", + "\n", + "These two lines perform the computation that we set out to do. The `for`-loop is going to start at 1 and end at our input value. For each step in the `for`-loop, we will mulitply the factorial_output by the factor. So when we calculate 4!, the loop updates factorial_output 4 times:\n", + "\n", + "1. i=1: factorial_output = $1*1=1$\n", + "\n", + "2. i=2: factorial_output = $1*1*2=2$\n", + "\n", + "3. i=3: factorial_output = $1*1*2*3=6$\n", + "\n", + "4. i=4: factorial_output = $1*1*2*3*4=24$\n", + "\n", + "\n", + "\n", + "```python\n", + " return factorial_output\n", + "```\n", + "\n", + "This final line in our function returns the calculated value, `factorial_output`. We can also return as many values as necessary on this line, \n", + "\n", + "for example, if we had variables: `value_1`, `value_2`, and `value_3` we could return all three as such,\n", + "\n", + "```python\n", + " return value_1,value_2,value_3\n", + "```" + ] }, { "cell_type": "markdown", @@ -199,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -217,7 +321,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -226,7 +330,7 @@ "array([ 3, 5, 8, 17])" ] }, - "execution_count": 2, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -246,16 +350,16 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 1., 1., 1., 1., 1.])" + "array([1., 1., 1., 1., 1.])" ] }, - "execution_count": 38, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -266,16 +370,16 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 0., 0., 0.])" + "array([0., 0., 0.])" ] }, - "execution_count": 39, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -300,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -309,7 +413,7 @@ "array([0, 1, 2, 3])" ] }, - "execution_count": 40, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -320,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -329,7 +433,7 @@ "array([2, 3, 4, 5])" ] }, - "execution_count": 41, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -340,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -349,7 +453,7 @@ "array([2, 4])" ] }, - "execution_count": 42, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -360,16 +464,16 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5])" + "array([2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5])" ] }, - "execution_count": 43, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -393,25 +497,25 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 2. , 2.02040816, 2.04081633, 2.06122449, 2.08163265,\n", - " 2.10204082, 2.12244898, 2.14285714, 2.16326531, 2.18367347,\n", - " 2.20408163, 2.2244898 , 2.24489796, 2.26530612, 2.28571429,\n", - " 2.30612245, 2.32653061, 2.34693878, 2.36734694, 2.3877551 ,\n", - " 2.40816327, 2.42857143, 2.44897959, 2.46938776, 2.48979592,\n", - " 2.51020408, 2.53061224, 2.55102041, 2.57142857, 2.59183673,\n", - " 2.6122449 , 2.63265306, 2.65306122, 2.67346939, 2.69387755,\n", - " 2.71428571, 2.73469388, 2.75510204, 2.7755102 , 2.79591837,\n", - " 2.81632653, 2.83673469, 2.85714286, 2.87755102, 2.89795918,\n", - " 2.91836735, 2.93877551, 2.95918367, 2.97959184, 3. ])" + "array([2. , 2.02040816, 2.04081633, 2.06122449, 2.08163265,\n", + " 2.10204082, 2.12244898, 2.14285714, 2.16326531, 2.18367347,\n", + " 2.20408163, 2.2244898 , 2.24489796, 2.26530612, 2.28571429,\n", + " 2.30612245, 2.32653061, 2.34693878, 2.36734694, 2.3877551 ,\n", + " 2.40816327, 2.42857143, 2.44897959, 2.46938776, 2.48979592,\n", + " 2.51020408, 2.53061224, 2.55102041, 2.57142857, 2.59183673,\n", + " 2.6122449 , 2.63265306, 2.65306122, 2.67346939, 2.69387755,\n", + " 2.71428571, 2.73469388, 2.75510204, 2.7755102 , 2.79591837,\n", + " 2.81632653, 2.83673469, 2.85714286, 2.87755102, 2.89795918,\n", + " 2.91836735, 2.93877551, 2.95918367, 2.97959184, 3. ])" ] }, - "execution_count": 44, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -422,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -431,7 +535,7 @@ "50" ] }, - "execution_count": 10, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -442,16 +546,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 2. , 2.2, 2.4, 2.6, 2.8, 3. ])" + "array([2. , 2.2, 2.4, 2.6, 2.8, 3. ])" ] }, - "execution_count": 11, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -462,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -471,7 +575,7 @@ "array([-1. , -0.75, -0.5 , -0.25, 0. , 0.25, 0.5 , 0.75, 1. ])" ] }, - "execution_count": 12, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -491,7 +595,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -500,23 +604,21 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "Now that we've saved it with a variable name, we can do some computations with the array. E.g., take the square of every element of the array, in one go:" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 1. 0.5625 0.25 0.0625 0. 0.0625 0.25 0.5625 1. ]\n" + "[1. 0.5625 0.25 0.0625 0. 0.0625 0.25 0.5625 1. ]\n" ] } ], @@ -534,14 +636,14 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 1. 0.75 0.5 0.25 0. 0.25 0.5 0.75 1. ]\n" + "[1. 0.75 0.5 0.25 0. 0.25 0.5 0.75 1. ]\n" ] } ], @@ -559,7 +661,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -584,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -611,14 +713,14 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n", + "/opt/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n", " \"\"\"Entry point for launching an IPython kernel.\n" ] }, @@ -629,7 +731,7 @@ " 4. , 2. , 1.33333333, 1. ])" ] }, - "execution_count": 50, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -651,7 +753,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -677,7 +779,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -694,7 +796,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -704,7 +806,7 @@ " [3, 5]])" ] }, - "execution_count": 53, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -722,7 +824,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -732,7 +834,7 @@ " [ 0, 4]])" ] }, - "execution_count": 54, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -750,7 +852,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -760,7 +862,7 @@ " [3, 1]])" ] }, - "execution_count": 55, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -778,7 +880,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 38, "metadata": {}, "outputs": [ { @@ -788,7 +890,7 @@ " [3, 1]])" ] }, - "execution_count": 56, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -814,7 +916,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -823,7 +925,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -854,7 +956,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -863,7 +965,7 @@ "(2, 3, 4)" ] }, - "execution_count": 59, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -883,9 +985,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "When we have multidimensional arrays, we can access slices of their elements by slicing on each dimension. This is one of the advantages of using arrays: we cannot do this with lists. \n", "\n", @@ -894,7 +994,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -904,7 +1004,7 @@ " [3, 4]])" ] }, - "execution_count": 60, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -915,7 +1015,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 43, "metadata": {}, "outputs": [ { @@ -924,7 +1024,7 @@ "1" ] }, - "execution_count": 61, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -936,7 +1036,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -945,7 +1045,7 @@ "2" ] }, - "execution_count": 62, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -976,7 +1076,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -985,7 +1085,7 @@ "array([1, 3])" ] }, - "execution_count": 63, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -1004,7 +1104,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -1013,7 +1113,7 @@ "array([1, 2])" ] }, - "execution_count": 64, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } @@ -1044,7 +1144,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -1059,7 +1159,7 @@ " [20, 21, 22, 23]]])" ] }, - "execution_count": 65, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" } @@ -1077,7 +1177,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -1087,7 +1187,7 @@ " [12, 16, 20]])" ] }, - "execution_count": 66, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } @@ -1111,7 +1211,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -1121,7 +1221,7 @@ " [12, 16]])" ] }, - "execution_count": 67, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -1139,7 +1239,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -1148,7 +1248,7 @@ "array([5, 6])" ] }, - "execution_count": 68, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -1195,7 +1295,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ @@ -1205,7 +1305,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 52, "metadata": {}, "outputs": [], "source": [ @@ -1215,15 +1315,15 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[37, 62, 29, 48, 89, 21, 93, 82, 90, 65]\n", - "[46, 20, 26, 52, 76, 77, 78, 17, 80, 89]\n" + "[78, 71, 32, 12, 88, 84, 7, 49, 93, 13]\n", + "[24, 70, 98, 72, 17, 48, 82, 55, 87, 54]\n" ] } ], @@ -1244,15 +1344,15 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 43 µs, sys: 0 ns, total: 43 µs\n", - "Wall time: 49.1 µs\n" + "CPU times: user 30 µs, sys: 8 µs, total: 38 µs\n", + "Wall time: 41 µs\n" ] } ], @@ -1265,14 +1365,14 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[83, 82, 55, 100, 165, 98, 171, 99, 170, 154]\n" + "[102, 141, 130, 84, 105, 132, 89, 104, 180, 67]\n" ] } ], @@ -1291,7 +1391,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ @@ -1301,15 +1401,15 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[61 75 51 76 48 80 69 79 91 0]\n", - "[87 67 74 97 76 91 37 43 69 11]\n" + "[ 3 67 98 94 87 71 28 60 12 24]\n", + "[29 59 1 45 85 92 17 0 15 58]\n" ] } ], @@ -1328,15 +1428,15 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 58, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 37 µs, sys: 0 ns, total: 37 µs\n", - "Wall time: 42.2 µs\n" + "CPU times: user 27 µs, sys: 7 µs, total: 34 µs\n", + "Wall time: 39.6 µs\n" ] } ], @@ -1377,17 +1477,16 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0. 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5 0.55\n", - " 0.6 0.65 0.7 0.75 0.8 0.85 0.9 0.95 1. 1.05 1.1 1.15\n", - " 1.2 1.25 1.3 1.35 1.4 1.45 1.5 1.55 1.6 1.65 1.7 1.75\n", - " 1.8 1.85 1.9 1.95 2. ]\n" + "[0. 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5 0.55 0.6 0.65\n", + " 0.7 0.75 0.8 0.85 0.9 0.95 1. 1.05 1.1 1.15 1.2 1.25 1.3 1.35\n", + " 1.4 1.45 1.5 1.55 1.6 1.65 1.7 1.75 1.8 1.85 1.9 1.95 2. ]\n" ] } ], @@ -1398,7 +1497,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ @@ -1411,38 +1510,38 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To plot the resulting arrays as a function of the orginal one (`xarray`) in the x-axis, we need to import the module `pyplot` from **Matplotlib**." + "# Introduction to plotting\n", + "\n", + "To plot the resulting arrays as a function of the orginal one (`xarray`) in the x-axis, we need to import the module `pyplot` from **Matplotlib**.\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" + "import matplotlib.pyplot as plt" ] }, { - "cell_type": "code", - "execution_count": 90, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def setdefaults():\n", - " plt.rcParams.update({'font.size': 22})\n", - " plt.rcParams['lines.linewidth'] = 3\n", - "\n" + "# Set up default plotting parameters\n", + "\n", + "The default Matplotlib fonts and linewidths are a little small. Pixels are free, so the next two lines increase the fontsize and linewidth" ] }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ - "setdefaults()" + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['lines.linewidth'] = 3" ] }, { @@ -1461,22 +1560,22 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 92, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1509,12 +1608,12 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 65, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1527,13 +1626,13 @@ ], "source": [ "#Plot x^2\n", - "pyplot.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n", + "plt.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n", "#Plot x^3\n", - "pyplot.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n", + "plt.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n", "#Plot sqrt(x)\n", - "pyplot.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n", + "plt.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n", "#Plot the legends in the best location\n", - "pyplot.legend(loc='best'); " + "plt.legend(loc='best'); " ] }, { @@ -1560,6 +1659,8 @@ "source": [ "## What we've learned\n", "\n", + "* Good coding habits and file naming\n", + "* How to define a function and return outputs\n", "* How to import libraries\n", "* Multidimensional arrays using NumPy\n", "* Accessing values and slicing in NumPy arrays\n", @@ -1574,6 +1675,8 @@ "source": [ "## References\n", "\n", + "1. [Best practices for file naming](https://library.stanford.edu/research/data-management-services/data-best-practices/best-practices-file-naming). Stanford Libraries\n", + "\n", "1. _Effective Computation in Physics: Field Guide to Research with Python_ (2015). Anthony Scopatz & Kathryn D. Huff. O'Reilly Media, Inc.\n", "\n", "2. _Numerical Python: A Practical Techniques Approach for Industry_. (2015). Robert Johansson. Appress. \n", @@ -1581,10454 +1684,79 @@ "2. [\"The world of Jupyter\"—a tutorial](https://github.com/barbagroup/jupyter-tutorial). Lorena A. Barba - 2016" ] }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" - ] - }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "metadata": {}, "source": [ - "# Thanks" + "# Problems\n", + "\n", + "1. Create a function called `sincos(x)` that returns two arrays, `sinx` and `cosx` that return the sine and cosine of the input array, `x`. \n", + "\n", + " a. Document your function with a help file in `'''help'''`\n", + " \n", + " b. Use your function to plot sin(x) and cos(x) for x=$0..2\\pi$\n", + "\n" ] }, { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "# Freefall Model (revisited)\n", - "\n", - "\n", - "Define time from 0 to 12 seconds with `N` timesteps \n", - "function defined as `freefall`\n", - "\n", - "m=60 kg, c=0.25 kg/m" + "def sincos(x):\n", + " '''help'''\n", + " # your code here, replace '''help''' with your documentation\n", + " \n", + " return sinx, cosx\n", + " " ] }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, + "metadata": {}, "source": [ - "## Freefall example\n", - "\n", - "Estimated the function with a $1^{st}$-order approximation, so \n", + "2. Use a for-loop to create a variable called `A_99`, where every element is the product\n", + "of the two indices from 0 to 9 e.g. A_99[3,2]=6 and A_99[4,4]=16. \n", "\n", - "$v(t_{i+1})=v(t_{i})+v'(t_{i})(t_{i+1}-t_{i})+R_{1}$\n", + " a. time your script using `%%time` \n", + " \n", + " b. Calculate the mean of `A_99`\n", "\n", - "$v'(t_{i})=\\frac{v(t_{i+1})-v(t_{i})}{t_{i+1}-t_{i}}-\\frac{R_{1}}{t_{i+1}-t_{i}}$\n", - "\n", - "$\\frac{R_{1}}{t_{i+1}-t_{i}}=\\frac{v''(\\xi)}{2!}(t_{i+1}-t_{i})$\n", - "\n", - "or the truncation error for a first-order Taylor series approximation is\n", - "\n", - "$R_{1}=O(\\Delta t^{2})$\n" + " c. Calculate the standard deviation of `A_99`\n", + " \n" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], - "source": [ - "function [v_analytical,v_terminal,t]=freefall(N)\n", - " % help file for freefall.m\n", - " % N is number of timesteps between 0 and 12 sec\n", - " % v_an...\n", - " t=linspace(0,12,N)';\n", - " c=0.25; m=60; g=9.81; v_terminal=sqrt(m*g/c);\n", - "\n", - " v_analytical = v_terminal*tanh(g*t/v_terminal);\n", - " v_numerical=zeros(length(t),1);\n", - " delta_time =diff(t);\n", - " for i=1:length(t)-1\n", - " v_numerical(i+1)=v_numerical(i)+(g-c/m*v_numerical(i)^2)*delta_time(i);\n", - " end\n", - " % Print values near 0,2,4,6,8,10,12 seconds\n", - " indices = round(linspace(1,length(t),7));\n", - " fprintf('time (s)|vel analytical (m/s)|vel numerical (m/s)\\n')\n", - " fprintf('-----------------------------------------------\\n')\n", - " M=[t(indices),v_analytical(indices),v_numerical(indices)];\n", - " fprintf('%7.1f | %18.2f | %15.2f\\n',M(:,1:3)');\n", - " plot(t,v_analytical,'-',t,v_numerical,'o-')\n", - "end\n", - " " - ] + "source": [] }, { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "time (s)|vel analytical (m/s)|vel numerical (m/s)\n", - "-----------------------------------------------\n", - " 0.0 | 0.00 | 0.00\n", - " 2.0 | 18.62 | 18.62\n", - " 4.0 | 32.46 | 32.46\n", - " 6.0 | 40.64 | 40.65\n", - " 8.0 | 44.85 | 44.85\n", - " 10.0 | 46.85 | 46.85\n", - " 12.0 | 47.77 | 47.77\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t30\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t40\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t50\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t6\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t8\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t12\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tgnuplot_plot_2a\n", - "\n", - "\t\t \n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "[v_analytical,v_terminal,t]=freefall(10000);" + "3. Use the two arrays, X and Y, given below to create A_99 using numpy array math rather than a for-loop. \n", + "\n", + " a. time your script using `%%time` \n", + " \n", + " b. Calculate the mean of `A_99`\n", + "\n", + " c. Calculate the standard deviation of `A_99`\n", + " \n", + " d. create a filled contour plot of X, Y, A_99 [contourf plot documentation](https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.contourf.html)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 72, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans = 1.4400e-06\r\n" - ] - } - ], + "outputs": [], "source": [ - "(12/10000)^2" + "# given X and Y arrays\n", + "X,Y=np.meshgrid(np.arange(0,10),np.arange(0,10))" ] } ], @@ -12049,9 +1777,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/notebooks/.ipynb_checkpoints/03-Numerical_error-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/03-Numerical_error-checkpoint.ipynb new file mode 100644 index 0000000..c49ee15 --- /dev/null +++ b/notebooks/.ipynb_checkpoints/03-Numerical_error-checkpoint.ipynb @@ -0,0 +1,891 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Freefall Model\n", + "## Computational solution\n", + "\n", + " \n", + "\n", + "Here is our first computational mechanics model. \n", + "\n", + "An object falling is subject to the force of \n", + "\n", + "- gravity ($F_g$=mg) and \n", + "- drag ($F_d=cv^2$)\n", + "\n", + "Acceleration of the object:\n", + "\n", + "$\\sum F=ma=F_g-F_d=mg - cv^2 = m\\frac{dv}{dt}$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Computational models do not solve for functions e.g. v(t), but rather functions at given points in time (or space):\n", + "\n", + "\n", + "Therefore, we define time from 0 to 12 seconds\n", + "\n", + "t=[0,2,4,6,8,10,12]'" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "t=np.array([0,2,4,6,8,10,12])\n", + "# or \n", + "t=np.linspace(0,12,7)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Define constants and analytical solution (meters-kilogram-sec)\n", + "\n", + "g=9.81 m/s$^2$, c=0.25 kg/m, m=60 kg\n", + "\n", + "$v_{terminal}=\\sqrt{\\frac{mg}{c}}$\n", + "\n", + "$v(t)=v_{terminal}\\tanh{\\left(\\frac{gt}{v_{terminal}}\\right)}$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "at time 0 s, speed is 0.00\n", + "at time 2 s, speed is 18.62\n", + "at time 4 s, speed is 32.46\n", + "at time 6 s, speed is 40.64\n", + "at time 8 s, speed is 44.85\n", + "at time 10 s, speed is 46.85\n", + "at time 12 s, speed is 47.77\n" + ] + } + ], + "source": [ + "c=0.25 \n", + "m=60\n", + "g=9.81 \n", + "\n", + "\n", + "def v_analytical(t,m,g,c):\n", + " v_terminal=np.sqrt(m*g/c)\n", + " v= v_terminal*np.tanh(g*t/v_terminal)\n", + " return v\n", + "\n", + "v_an=v_analytical(t,m,g,c)\n", + "\n", + "for i,v in enumerate(v_an):\n", + " print('at time %2.0f s, speed is %1.2f'%(t[i],v))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Define numerical method\n", + "#### Finite difference approximation\n", + "\n", + "$\\frac{v(t_{i+1})-v(t_{i})}{t_{i+1}-t_{i}}=g-\\frac{c}{m}v(t_{i})^2$\n", + "\n", + "solve for $v(t_{i+1})$\n", + "\n", + "$v(t_{i+1})=v(t_{i})+\\left(g-\\frac{c}{m}v(t_{i})^2\\right)(t_{i+1}-t_{i})$\n", + "\n", + "or\n", + "\n", + "$v(t_{i+1})=v(t_{i})+\\frac{dv_{i}}{dt}(t_{i+1}-t_{i})$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 19.62 , 36.03213 , 44.8328434 ,\n", + " 47.702978 , 48.35986042, 48.49089292])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v_numerical=np.zeros(len(t));\n", + "for i in range(1,len(t)):\n", + " v_numerical[i]=v_numerical[i-1]+((g-c/m*v_numerical[i-1]**2))*2;\n", + "\n", + "v_numerical" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Display time, velocity (analytical) and velocity (numerical)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time (s)|vel analytical (m/s)|vel numerical (m/s)\n", + "\n", + "-----------------------------------------------\n", + " 0.0 | 0.00 | 0.00\n", + "\n", + " 2.0 | 18.62 | 19.62\n", + "\n", + " 4.0 | 32.46 | 36.03\n", + "\n", + " 6.0 | 40.64 | 44.83\n", + "\n", + " 8.0 | 44.85 | 47.70\n", + "\n", + " 10.0 | 46.85 | 48.36\n", + "\n", + " 12.0 | 47.77 | 48.49\n", + "\n" + ] + } + ], + "source": [ + "print('time (s)|vel analytical (m/s)|vel numerical (m/s)\\n')\n", + "print('-----------------------------------------------')\n", + "for i in range(0,len(t)):\n", + " print('%7.1f | %18.2f | %15.2f\\n'%(t[i],v_an[i],v_numerical[i]));" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Set default values for plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['lines.linewidth'] = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'velocity (m/s)')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t,v_an,'-',label='analytical')\n", + "plt.plot(t,v_numerical,'o-',label='numerical')\n", + "plt.legend()\n", + "plt.xlabel('time (s)')\n", + "plt.ylabel('velocity (m/s)')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Errors in Numerical Modeling\n", + "\n", + "## 1 - Truncation\n", + "## 2 - Roundoff " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# 1- Truncation error\n", + "## Freefall is example of \"truncation error\"\n", + "### Truncation error results from approximating exact mathematical procedure\n", + "\n", + "We approximated the derivative as $\\delta v/\\delta t\\approx\\Delta v/\\Delta t$\n", + "\n", + "Can reduce error in two ways\n", + "\n", + "1. Decrease step size -> $\\Delta t$=`delta_time`\n", + "\n", + "2. Increase the accuracy of the approximation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Truncation error as a Taylor series \n", + "\n", + "The freefall problem solution used a first-order Taylor series approximation\n", + "\n", + "Taylor series:\n", + "$f(x)=f(a)+f'(a)(x-a)+\\frac{f''(a)}{2!}(x-a)^{2}+\\frac{f'''(a)}{3!}(x-a)^{3}+...$\n", + "\n", + "First-order approximation:\n", + "$f(x_{i+1})=f(x_{i})+f'(x_{i})h$\n", + "\n", + "\n", + "We can increase accuracy in a function by adding Taylor series terms:\n", + "\n", + "|Approximation | formula |\n", + "|---|-----------------------------|\n", + "|$0^{th}$-order | $f(x_{i+1})=f(x_{i})+R_{1}$ |\n", + "|$1^{st}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+R_{2}$ |\n", + "|$2^{nd}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+\\frac{f''(x_{i})}{2!}h^{2}+R_{3}$|\n", + "|$n^{th}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+\\frac{f''(x_{i})}{2!}h^{2}+...\\frac{f^{(n)}}{n!}h^{n}+R_{n}$|\n", + "\n", + "Where $R_{n}=O(h^{n+1})$ is the error associated with truncating the approximation at order $n$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "In the .gif below, the error in the function is reduced by including higher-order terms in the Taylor series approximation. \n", + "\n", + "![3](https://media.giphy.com/media/xA7G2n20MzTOw/giphy.gif)\n", + "\n", + "$n^{th}$-order approximation equivalent to \n", + "an $n^{th}$-order polynomial. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "# 1- Roundoff\n", + "\n", + "## Just storing a number in a computer requires rounding\n", + "\n", + "1. digital representation of a number is rarely exact\n", + "\n", + "2. arithmetic (+,-,/,\\*) causes roundoff error\n", + "\n", + "[Consider the number $\\pi$](https://www.piday.org/million/). How many digits can a floating point number in a computer accurately represent?" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "double precision 64 bit pi = 3.14159265358979311599796347\n", + "\n", + "single precision 32 bit pi = 3.14159274101257324218750000\n", + "\n", + "First 26 digits of pi = 3.14159265358979323846264338\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "pi=np.pi\n", + "double=np.array([pi],dtype='float64')\n", + "single=np.array([pi],dtype='float32')\n", + "print('double precision 64 bit pi = %1.26f\\n'%double) # 64-bit\n", + "print('single precision 32 bit pi = %1.26f\\n'%single) # 32-bit\n", + "print('First 26 digits of pi = 3.14159265358979323846264338')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to store the number in a computer you can only use so many bits, shown below is the 64-bit standard for floating point numbers:\n", + "\n", + " \n", + "\n", + "Each time you use an operation, e.g. `+ - / *` you lose some precision as well. \n", + "\n", + "Consider $\\pi$ again\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "no operations 64 bit pi = 3.14159265358979311599796347\n", + "\n", + "20 operations 64 bit pi = 3.14159265358979089555191422\n", + "\n", + "First 26 digits of pi = 3.14159265358979323846264338\n" + ] + } + ], + "source": [ + "double=np.array([pi],dtype='float64')\n", + "double_operated=double\n", + "for i in range(0,10):\n", + " double_operated=double_operated*(i+1)*1.0e-16\n", + " double_operated=double_operated*1/(i+1)*1.0e16\n", + "print('no operations 64 bit pi = %1.26f\\n'%double) # 64-bit\n", + "print('20 operations 64 bit pi = %1.26f\\n'%double_operated) # 64-bit after 1000 additions and 1 subtraction\n", + "print('First 26 digits of pi = 3.14159265358979323846264338')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the previous block of code, we see $\\pi$ printed for 3 cases:\n", + "\n", + "1. the 64-bit representation of $\\pi$\n", + "\n", + "2. the value of $\\pi$ after it has gone through 20 math operations ($\\times (0..10)10^{-16}$, then $\\times (0..10)10^{16}$)\n", + "\n", + "3. the actual value of $\\pi$ for the first 26 digits\n", + "\n", + "All three (1-3) have the same first 14 digits after the decimal, then we see a divergence between the actual value of $\\pi$ (3), and $\\pi$ as represented by floating point numbers. \n", + "\n", + "We can get an idea for computational limits using some built-in functions:\n", + "\n", + "- `np.info('float64').max`: the largest floating point 64-bit number the computer can represent\n", + "\n", + "- `np.info('float64').tiny`: the smallest non-negative 64-bit number the computer can represent\n", + "\n", + "- `np.info('float64').eps`: the smallest number that can be added to 1" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "realmax = 1.79769313486231570815e+308\n", + "\n", + "realmin = 2.22507385850720138309e-308\n", + "\n", + "maximum relative error = 2.22044604925031308085e-16\n", + "\n" + ] + } + ], + "source": [ + "print('realmax = %1.20e\\n'%np.finfo('float64').max)\n", + "print('realmin = %1.20e\\n'%np.finfo('float64').tiny)\n", + "print('maximum relative error = %1.20e\\n'%np.finfo('float64').eps)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Machine epsilon\n", + "\n", + "Smallest number that can be added to 1 and change the value in a computer.\n", + "\n", + "In the following example, we will add $eps/2$ to s=1 1,000$\\times$. The result should be $s=1+500\\cdot eps$, but because $eps/2$ is smaller than floating point operations can track, we will get a different result depending upon how we do the addition.\n", + "\n", + "a. We make a `for`-loop and add $eps/2$ 1000 times in the loop\n", + "\n", + "b. We multiply $1000*eps/2$ and add it to the result" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "summation 1+eps/2 over 1000 minus 1 = 0.0\n", + "500.0 *eps= 1.11022302463e-13\n" + ] + } + ], + "source": [ + "s1=1;\n", + "N=1000\n", + "eps=np.finfo('float64').eps\n", + "for i in range(1,N):\n", + " s1+=eps/2;\n", + "\n", + "s2=1+500*eps\n", + "print('summation 1+eps/2 over ',N,' minus 1 =',(s-1))\n", + "print(N/2,'*eps=',(s2-1))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Freefall Model (revisited)\n", + "\n", + "\n", + "Define time from 0 to 12 seconds with `N` timesteps \n", + "function defined as `freefall`\n", + "\n", + "m=60 kg, c=0.25 kg/m" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Freefall example\n", + "\n", + "Estimated the function with a $1^{st}$-order approximation, so \n", + "\n", + "$v(t_{i+1})=v(t_{i})+v'(t_{i})(t_{i+1}-t_{i})+R_{1}$\n", + "\n", + "$v'(t_{i})=\\frac{v(t_{i+1})-v(t_{i})}{t_{i+1}-t_{i}}-\\frac{R_{1}}{t_{i+1}-t_{i}}$\n", + "\n", + "$\\frac{R_{1}}{t_{i+1}-t_{i}}=\\frac{v''(\\xi)}{2!}(t_{i+1}-t_{i})$\n", + "\n", + "or the truncation error for a first-order Taylor series approximation is\n", + "\n", + "$R_{1}=O(\\Delta t^{2})$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Computer model error = truncation + roundoff\n", + "\n", + "In the function `freefall(N)`, the speed of a 60-kg object is predicted in two ways:\n", + "\n", + "1. The analytical 64-bit representation, \n", + "$v(t)=v_{terminal}\\tanh{\\left(\\frac{gt}{v_{terminal}}\\right)}$\n", + "\n", + "2. The numerical 32-bit$^{+}$ Euler approximation for `N`-steps from 0 to 2 seconds\n", + "\n", + "$^{+}$Here, we use a 32-bit representation to observe the transition from truncation error to floating point error in a reasonable number of steps. \n", + "\n", + "We can reduce truncation error by decreasing the timestep, $\\Delta t$. Here, we consider the speed from 0 to 2 seconds, so `N=3` means $\\Delta t$= 1 s and `N=21` means $\\Delta t$=0.1 s\n", + "\n", + "|N= | $\\Delta t$=|\n", + "|---|---|\n", + "|3 | 1 s|\n", + "|21| 0.1 s|\n", + "|201| 0.01 s|\n", + "|??| 0.05 s|\n", + "|?? | 0.001 s|\n", + "\n", + "What is N for 0.05 s and 0.001 s in the table above?\n", + "\n", + "Answer (0.05 s): 41 \n", + "\n", + "Answer (0.001 s): 2001 \n", + "\n", + "Highlight lines above for answer." + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def freefall(N):\n", + " ''' help file for freefall(N)\n", + " computes the velocity as a function of time, t, for a\n", + " 60-kg object with zero initial velocity and drag \n", + " coefficient of 0.25 kg/s\n", + " N is number of timesteps between 0 and 2 sec\n", + " v_analytical is the 64-bit floating point \"true\" solution\n", + " v_numerical is the 32-bit approximation of the velocity\n", + " t is the timesteps between 0 and 2 sec, divided into N steps'''\n", + " t=np.linspace(0,2,N)\n", + " c=0.25\n", + " m=60\n", + " g=9.81\n", + " v_terminal=np.sqrt(m*g/c)\n", + "\n", + " v_analytical = v_terminal*np.tanh(g*t/v_terminal);\n", + " v_numerical=np.empty(len(t),dtype=np.float32)\n", + " delta_time =np.diff(t)\n", + " for i in range(0,len(t)-1):\n", + " v_numerical[i+1]=v_numerical[i]+(g-c/m*v_numerical[i]**2)*delta_time[i];\n", + " \n", + " return v_analytical,v_numerical,t\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare solutions\n", + "\n", + "We can compare solutions in a figure in a number of ways:\n", + "\n", + "1. plot the values, e.g. $v_{analytical}$ and $v_{numerical}$\n", + "\n", + "2. plot the difference between the values (the absolute error) e.g. $v_{numerical}-v_{analytical}$\n", + "\n", + "3. plot the ratio of the values e.g. $\\frac{v_{numerical}}{v_{analytical}}$ (useful in finding bugs, unit analysis, etc.)\n", + "\n", + "4. plot the ratio of the error to the best estimate (the relative error) e.g. $\\frac{v_{numerical}-v_{analytical}}{v_{analytical}}$\n", + "\n", + "We will make use of methods (1) and (4) in this example. \n", + "\n", + "We can visualize how the approximation approaches the exact solution with this method. The process of approaching the \"true\" solution is called **convergence**. " + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n=2\n", + "\n", + "v_analytical,v_numerical,t=freefall(n);\n", + "\n", + "plt.plot(t,v_numerical,'o',label=str(n)+' Euler steps')\n", + "plt.plot(t,v_analytical,label='analytical')\n", + "plt.title('First 2 seconds of freefall')\n", + "plt.xlabel('time (s)')\n", + "plt.ylabel('speed (m/s)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Try adjusting `N` in the code above to watch the solution converge. You should notice the Euler approximation becomes almost indistinguishable from the analytical solution as `N` increases. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convergence of a numerical model\n", + "\n", + "You should see that the more time steps we use, the closer the Euler approximation resembles the analytical solution. This is true only to a point, due to **roundoff error**. In our `freefall` function, the numerical result is saved as a 32-bit floating point array. Our best approximation of the freefall function is the 64-bit analytical equation `v_terminal*np.tanh(g*t/v_terminal)`.$^{+}$ \n", + "\n", + "In the next plot, we consider the relative error for the velocity at t=2 s, as a function of `N`. \n", + "\n", + "$^+$ Note: In practice, there is no reason to restrict the precision of our floating point numbers. The function was written this way to highlight the effect of roundoff error without significant computational resources. You would need significantly more timesteps to observe floating point error with 64-bit floating point numbers. " + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [], + "source": [ + "N=100\n", + "error=np.zeros(N)\n", + "n=np.logspace(2,5,N) # create an array from 10^2 to 10^5 with N values\n", + "for i in range(0,N):\n", + " v_an,v_num,t=freefall(n[i])\n", + " error[i]=(v_num[-1]-v_an[-1])/v_an[-1] #calculate relative error in velocity at final time t=2 s\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2. , 2.03030303, 2.06060606, 2.09090909, 2.12121212,\n", + " 2.15151515, 2.18181818, 2.21212121, 2.24242424, 2.27272727,\n", + " 2.3030303 , 2.33333333, 2.36363636, 2.39393939, 2.42424242,\n", + " 2.45454545, 2.48484848, 2.51515152, 2.54545455, 2.57575758,\n", + " 2.60606061, 2.63636364, 2.66666667, 2.6969697 , 2.72727273,\n", + " 2.75757576, 2.78787879, 2.81818182, 2.84848485, 2.87878788,\n", + " 2.90909091, 2.93939394, 2.96969697, 3. , 3.03030303,\n", + " 3.06060606, 3.09090909, 3.12121212, 3.15151515, 3.18181818,\n", + " 3.21212121, 3.24242424, 3.27272727, 3.3030303 , 3.33333333,\n", + " 3.36363636, 3.39393939, 3.42424242, 3.45454545, 3.48484848,\n", + " 3.51515152, 3.54545455, 3.57575758, 3.60606061, 3.63636364,\n", + " 3.66666667, 3.6969697 , 3.72727273, 3.75757576, 3.78787879,\n", + " 3.81818182, 3.84848485, 3.87878788, 3.90909091, 3.93939394,\n", + " 3.96969697, 4. , 4.03030303, 4.06060606, 4.09090909,\n", + " 4.12121212, 4.15151515, 4.18181818, 4.21212121, 4.24242424,\n", + " 4.27272727, 4.3030303 , 4.33333333, 4.36363636, 4.39393939,\n", + " 4.42424242, 4.45454545, 4.48484848, 4.51515152, 4.54545455,\n", + " 4.57575758, 4.60606061, 4.63636364, 4.66666667, 4.6969697 ,\n", + " 4.72727273, 4.75757576, 4.78787879, 4.81818182, 4.84848485,\n", + " 4.87878788, 4.90909091, 4.93939394, 4.96969697, 5. ])" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.log10(n)" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Truncation and roundoff error \\naccumulation in log-log plot')" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.loglog(n,error,'o')\n", + "plt.xlabel('number of timesteps N')\n", + "plt.ylabel('relative error')\n", + "plt.title('Truncation and roundoff error \\naccumulation in log-log plot')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above plot \"Truncation and roundoff error accumulation in log-log plot\", we see that around N=20,000 steps we stop decreasing the error with more steps. This is because we are approaching the limit of how precise we can store a number using a 32-bit floating point number. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What we've learned\n", + "\n", + "* Numerical integration with the Euler approximation\n", + "* The source of truncation errors\n", + "* The source of roundoff errors\n", + "* " + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "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.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/01_Interacting_with_Python.ipynb b/notebooks/01_Interacting_with_Python.ipynb index 65c3837..6a71510 100644 --- a/notebooks/01_Interacting_with_Python.ipynb +++ b/notebooks/01_Interacting_with_Python.ipynb @@ -911,9 +911,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "**None is not Zero**: `None` is a special variable indicating that no value was assigned or that a behavior is undefined. It is different than the value zero, an empty string, or some other nil value. \n", "\n", @@ -924,7 +922,10 @@ "cell_type": "code", "execution_count": 33, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -967,7 +968,10 @@ "cell_type": "code", "execution_count": 35, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -1006,7 +1010,10 @@ "cell_type": "code", "execution_count": 37, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -1066,7 +1073,10 @@ "cell_type": "code", "execution_count": 40, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -1228,182 +1238,113 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Recommended Readings\n", + "# Problems\n", + "\n", + "1. Calculate some properties of a rectangular box that is 12.5\"$\\times$11\"$\\times$14\" and weighs 31 lbs\n", + "\n", + " a. What is the volume of the box?\n", + " \n", + " b. What is the average density of the box?\n", + " \n", + " c. What is the result of the following logical operation, `volume>1000` (in inches^3)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Use the variables given below, `str1` and `str2`, and check the following \n", + "\n", + " a. `str1str2`\n", + " \n", + " d. How could you force (b) to be true? [Hint](https://docs.python.org/3/library/stdtypes.html?highlight=str.lower#str.lower) or [Hint](https://docs.python.org/3/library/stdtypes.html?highlight=str.lower#str.upper)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "str1='Computational Mechanics'\n", + "str2='computational mechanics'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. The following code has an error, fix the error so that the correct result is returned:\n", "\n", - "- [\"Yes, Python is Slow, and I Don’t Care\"](https://hackernoon.com/yes-python-is-slow-and-i-dont-care-13763980b5a1) by Nick Humrich, on Hackernoon. (Skip the part on microservices, which is a bit specialized, and continue after the photo of moving car lights.)\n", - "- [\"Why I Push for Python\"](http://lorenabarba.com/blog/why-i-push-for-python/), by Prof. Lorena A. Barba (2014). This blog post got a bit of interest over at [Hacker News](https://news.ycombinator.com/item?id=7760870)." + "```y is 20 and x is less than y```" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 8, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" + "ename": "TypeError", + "evalue": "'<' not supported between instances of 'str' and 'int'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0my\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'y is 20 and x is less than y'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'" + ] } ], "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" + "x='1'\n", + "y=20\n", + "\n", + "if x \n", - "\n", - "An object falling is subject to the force of \n", - "\n", - "- gravity ($F_g$=mg) and \n", - "- drag ($F_d=cv^2$)\n", - "\n", - "Acceleration of the object:\n", - "\n", - "$\\sum F=ma=F_g-F_d=mg - cv^2 = m\\frac{dv}{dt}$\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "Define time from 0 to 12 seconds\n", - "\n", - "t=[0,2,4,6,8,10,12]'" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "t=np.array([0,2,4,6,8,10,12])\n", - "# or \n", - "t=np.linspace(0,12,7)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Define constants and analytical solution (meters-kilogram-sec)\n", - "\n", - "g=9.81 m/s$^2$, c=0.25 kg/m, m=60 kg\n", - "\n", - "$v_{terminal}=\\sqrt{\\frac{mg}{c}}$\n", - "\n", - "$v(t)=v_{terminal}\\tanh{\\left(\\frac{gt}{v_{terminal}}\\right)}$" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "at time 0 s, speed is 0.00\n", - "at time 2 s, speed is 18.62\n", - "at time 4 s, speed is 32.46\n", - "at time 6 s, speed is 40.64\n", - "at time 8 s, speed is 44.85\n", - "at time 10 s, speed is 46.85\n", - "at time 12 s, speed is 47.77\n" - ] - } - ], - "source": [ - "c=0.25 \n", - "m=60\n", - "g=9.81 \n", - "\n", - "\n", - "def v_analytical(t,m,g,c):\n", - " v_terminal=np.sqrt(m*g/c)\n", - " v= v_terminal*np.tanh(g*t/v_terminal)\n", - " return v\n", - "\n", - "v_an=v_analytical(t,m,g,c)\n", - "\n", - "for i,v in enumerate(v_an):\n", - " print('at time %2.0f s, speed is %1.2f'%(t[i],v))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Define numerical method\n", - "#### Finite difference approximation\n", - "\n", - "$\\frac{v(t_{i+1})-v(t_{i})}{t_{i+1}-t_{i}}=g-\\frac{c}{m}v(t_{i})^2$\n", - "\n", - "solve for $v(t_{i+1})$\n", - "\n", - "$v(t_{i+1})=v(t_{i})+\\left(g-\\frac{c}{m}v(t_{i})^2\\right)(t_{i+1}-t_{i})$\n", - "\n", - "or\n", - "\n", - "$v(t_{i+1})=v(t_{i})+\\frac{dv_{i}}{dt}(t_{i+1}-t_{i})$\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0. , 19.62 , 36.03213 , 44.8328434 ,\n", - " 47.702978 , 48.35986042, 48.49089292])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "v_numerical=np.zeros(len(t));\n", - "for i in range(1,len(t)):\n", - " v_numerical[i]=v_numerical[i-1]+((g-c/m*v_numerical[i-1]**2))*2;\n", - "\n", - "v_numerical" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "Display time, velocity (analytical) and velocity (numerical)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "time (s)|vel analytical (m/s)|vel numerical (m/s)\n", - "\n", - "-----------------------------------------------\n", - " 0.0 | 0.00 | 0.00\n", - "\n", - " 2.0 | 18.62 | 19.62\n", - "\n", - " 4.0 | 32.46 | 36.03\n", - "\n", - " 6.0 | 40.64 | 44.83\n", - "\n", - " 8.0 | 44.85 | 47.70\n", - "\n", - " 10.0 | 46.85 | 48.36\n", - "\n", - " 12.0 | 47.77 | 48.49\n", - "\n" - ] - } - ], - "source": [ - "print('time (s)|vel analytical (m/s)|vel numerical (m/s)\\n')\n", - "print('-----------------------------------------------')\n", - "for i in range(0,len(t)):\n", - " print('%7.1f | %18.2f | %15.2f\\n'%(t[i],v_an[i],v_numerical[i]));" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Set default values for plotting" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.rcParams.update({'font.size': 22})\n", - "plt.rcParams['lines.linewidth'] = 3" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0,0.5,'velocity (m/s)')" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(t,v_an,'-',label='analytical')\n", - "plt.plot(t,v_numerical,'o-',label='numerical')\n", - "plt.legend()\n", - "plt.xlabel('time (s)')\n", - "plt.ylabel('velocity (m/s)')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Errors in Numerical Modeling\n", - "\n", - "## 1 - Truncation\n", - "## 2 - Roundoff " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# 1- Truncation error\n", - "## Freefall is example of \"truncation error\"\n", - "### Truncation error results from approximating exact mathematical procedure\n", - "\n", - "We approximated the derivative as $\\delta v/\\delta t\\approx\\Delta v/\\Delta t$\n", - "\n", - "Can reduce error in two ways\n", - "\n", - "1. Decrease step size -> $\\Delta t$=`delta_time`\n", - "\n", - "2. Increase the accuracy of the approximation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Truncation error as a Taylor series \n", - "\n", - "The freefall problem solution used a first-order Taylor series approximation\n", - "\n", - "Taylor series:\n", - "$f(x)=f(a)+f'(a)(x-a)+\\frac{f''(a)}{2!}(x-a)^{2}+\\frac{f'''(a)}{3!}(x-a)^{3}+...$\n", - "\n", - "First-order approximation:\n", - "$f(x_{i+1})=f(x_{i})+f'(x_{i})h$\n", - "\n", - "\n", - "We can increase accuracy in a function by adding Taylor series terms:\n", - "\n", - "|Approximation | formula |\n", - "|---|-----------------------------|\n", - "|$0^{th}$-order | $f(x_{i+1})=f(x_{i})+R_{1}$ |\n", - "|$1^{st}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+R_{2}$ |\n", - "|$2^{nd}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+\\frac{f''(x_{i})}{2!}h^{2}+R_{3}$|\n", - "|$n^{th}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+\\frac{f''(x_{i})}{2!}h^{2}+...\\frac{f^{(n)}}{n!}h^{n}+R_{n}$|\n", - "\n", - "Where $R_{n}=O(h^{n+1})$ is the error associated with truncating the approximation at order $n$." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "In the .gif below, the error in the function is reduced by including higher-order terms in the Taylor series approximation. \n", - "\n", - "![3](https://media.giphy.com/media/xA7G2n20MzTOw/giphy.gif)\n", - "\n", - "$n^{th}$-order approximation equivalent to \n", - "an $n^{th}$-order polynomial. " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "# 1- Roundoff\n", - "\n", - "## Just storing a number in a computer requires rounding\n", - "\n", - "1. digital representation of a number is rarely exact\n", - "\n", - "2. arithmetic (+,-,/,\\*) causes roundoff error\n", - "\n", - "[Consider the number $\\pi$](https://www.piday.org/million/). How many digits can a floating point number in a computer accurately represent?" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "double precision 64 bit pi = 3.14159265358979311599796347\n", - "\n", - "single precision 32 bit pi = 3.14159274101257324218750000\n", - "\n", - "First 26 digits of pi = 3.14159265358979323846264338\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "pi=np.pi\n", - "double=np.array([pi],dtype='float64')\n", - "single=np.array([pi],dtype='float32')\n", - "print('double precision 64 bit pi = %1.26f\\n'%double) # 64-bit\n", - "print('single precision 32 bit pi = %1.26f\\n'%single) # 32-bit\n", - "print('First 26 digits of pi = 3.14159265358979323846264338')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to store the number in a computer you can only use so many bits, shown below is the 64-bit standard for floating point numbers:\n", - "\n", - " \n", - "\n", - "Each time you use an operation, e.g. `+ - / *` you lose some precision as well. \n", - "\n", - "Consider $\\pi$ again\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "no operations 64 bit pi = 3.14159265358979311599796347\n", - "\n", - "20 operations 64 bit pi = 3.14159265358979089555191422\n", - "\n", - "First 26 digits of pi = 3.14159265358979323846264338\n" - ] - } - ], - "source": [ - "double=np.array([pi],dtype='float64')\n", - "double_operated=double\n", - "for i in range(0,10):\n", - " double_operated=double_operated*(i+1)*1.0e-16\n", - " double_operated=double_operated*1/(i+1)*1.0e16\n", - "print('no operations 64 bit pi = %1.26f\\n'%double) # 64-bit\n", - "print('20 operations 64 bit pi = %1.26f\\n'%double_operated) # 64-bit after 1000 additions and 1 subtraction\n", - "print('First 26 digits of pi = 3.14159265358979323846264338')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the previous block of code, we see $\\pi$ printed for 3 cases:\n", - "\n", - "1. the 64-bit representation of $\\pi$\n", - "\n", - "2. the value of $\\pi$ after it has gone through 20 math operations ($\\times (0..10)10^{-16}$, then $\\times (0..10)10^{16}$)\n", - "\n", - "3. the actual value of $\\pi$ for the first 26 digits\n", - "\n", - "All three (1-3) have the same first 14 digits after the decimal, then we see a divergence between the actual value of $\\pi$ (3), and $\\pi$ as represented by floating point numbers. \n", - "\n", - "We can get an idea for computational limits using some built-in functions:\n", - "\n", - "- `np.info('float64').max`: the largest floating point 64-bit number the computer can represent\n", - "\n", - "- `np.info('float64').tiny`: the smallest non-negative 64-bit number the computer can represent\n", - "\n", - "- `np.info('float64').eps`: the smallest number that can be added to 1" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "realmax = 1.79769313486231570815e+308\n", - "\n", - "realmin = 2.22507385850720138309e-308\n", - "\n", - "maximum relative error = 2.22044604925031308085e-16\n", - "\n" - ] - } - ], - "source": [ - "print('realmax = %1.20e\\n'%np.finfo('float64').max)\n", - "print('realmin = %1.20e\\n'%np.finfo('float64').tiny)\n", - "print('maximum relative error = %1.20e\\n'%np.finfo('float64').eps)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Machine epsilon\n", - "\n", - "Smallest number that can be added to 1 and change the value in a computer.\n", - "\n", - "In the following example, we will add $eps/2$ to s=1 1,000$\\times$. The result should be $s=1+500\\cdot eps$, but because $eps/2$ is smaller than floating point operations can track, we will get a different result depending upon how we do the addition.\n", - "\n", - "a. We make a `for`-loop and add $eps/2$ 1000 times in the loop\n", - "\n", - "b. We multiply $1000*eps/2$ and add it to the result" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "slideshow": { - "slide_type": "fragment" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "summation 1+eps/2 over 1000 minus 1 = 0.0\n", - "500.0 *eps= 1.11022302463e-13\n" - ] - } - ], - "source": [ - "s1=1;\n", - "N=1000\n", - "eps=np.finfo('float64').eps\n", - "for i in range(1,N):\n", - " s1+=eps/2;\n", - "\n", - "s2=1+500*eps\n", - "print('summation 1+eps/2 over ',N,' minus 1 =',(s-1))\n", - "print(N/2,'*eps=',(s2-1))" - ] - } - ], - "metadata": { - "celltoolbar": "Slideshow", - "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.6.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/02_Getting-started.ipynb b/notebooks/02_Getting-started.ipynb index 46c828f..e9f2736 100644 --- a/notebooks/02_Getting-started.ipynb +++ b/notebooks/02_Getting-started.ipynb @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 10, "metadata": { "slideshow": { "slide_type": "subslide" @@ -75,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 11, "metadata": { "slideshow": { "slide_type": "subslide" @@ -88,7 +88,7 @@ "3628800" ] }, - "execution_count": 52, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -124,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 12, "metadata": { "slideshow": { "slide_type": "subslide" @@ -146,7 +146,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 13, "metadata": { "slideshow": { "slide_type": "subslide" @@ -159,7 +159,7 @@ "24" ] }, - "execution_count": 50, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -200,9 +200,26 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mfactorial_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Good variable names and better help documentation\n", + " \n", + "factorial_function(input_number): calculates the factorial of the input_number\n", + "where the factorial is defined as N*(N-1)*(N-2)*...*3*2*1\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/UConn/ME3255/ME3255-CompMech/CompMech01-Getting-started/notebooks/\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "factorial_function?" ] @@ -226,11 +243,11 @@ "\n", "1. i=1: factorial_output = $1*1=1$\n", "\n", - "2. i=2: factorial_output = $1*2=2$\n", + "2. i=2: factorial_output = $1*1*2=2$\n", "\n", - "3. i=3: factorial_output = $2*3=6$\n", + "3. i=3: factorial_output = $1*1*2*3=6$\n", "\n", - "4. i=4: factorial_output = $6*4=24$\n", + "4. i=4: factorial_output = $1*1*2*3*4=24$\n", "\n", "\n", "\n", @@ -286,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -304,7 +321,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -313,7 +330,7 @@ "array([ 3, 5, 8, 17])" ] }, - "execution_count": 2, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -333,16 +350,16 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 1., 1., 1., 1., 1.])" + "array([1., 1., 1., 1., 1.])" ] }, - "execution_count": 38, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -353,16 +370,16 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 0., 0., 0.])" + "array([0., 0., 0.])" ] }, - "execution_count": 39, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -387,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -396,7 +413,7 @@ "array([0, 1, 2, 3])" ] }, - "execution_count": 40, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -407,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -416,7 +433,7 @@ "array([2, 3, 4, 5])" ] }, - "execution_count": 41, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -427,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -436,7 +453,7 @@ "array([2, 4])" ] }, - "execution_count": 42, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -447,16 +464,16 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5])" + "array([2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5])" ] }, - "execution_count": 43, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -480,25 +497,25 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 2. , 2.02040816, 2.04081633, 2.06122449, 2.08163265,\n", - " 2.10204082, 2.12244898, 2.14285714, 2.16326531, 2.18367347,\n", - " 2.20408163, 2.2244898 , 2.24489796, 2.26530612, 2.28571429,\n", - " 2.30612245, 2.32653061, 2.34693878, 2.36734694, 2.3877551 ,\n", - " 2.40816327, 2.42857143, 2.44897959, 2.46938776, 2.48979592,\n", - " 2.51020408, 2.53061224, 2.55102041, 2.57142857, 2.59183673,\n", - " 2.6122449 , 2.63265306, 2.65306122, 2.67346939, 2.69387755,\n", - " 2.71428571, 2.73469388, 2.75510204, 2.7755102 , 2.79591837,\n", - " 2.81632653, 2.83673469, 2.85714286, 2.87755102, 2.89795918,\n", - " 2.91836735, 2.93877551, 2.95918367, 2.97959184, 3. ])" + "array([2. , 2.02040816, 2.04081633, 2.06122449, 2.08163265,\n", + " 2.10204082, 2.12244898, 2.14285714, 2.16326531, 2.18367347,\n", + " 2.20408163, 2.2244898 , 2.24489796, 2.26530612, 2.28571429,\n", + " 2.30612245, 2.32653061, 2.34693878, 2.36734694, 2.3877551 ,\n", + " 2.40816327, 2.42857143, 2.44897959, 2.46938776, 2.48979592,\n", + " 2.51020408, 2.53061224, 2.55102041, 2.57142857, 2.59183673,\n", + " 2.6122449 , 2.63265306, 2.65306122, 2.67346939, 2.69387755,\n", + " 2.71428571, 2.73469388, 2.75510204, 2.7755102 , 2.79591837,\n", + " 2.81632653, 2.83673469, 2.85714286, 2.87755102, 2.89795918,\n", + " 2.91836735, 2.93877551, 2.95918367, 2.97959184, 3. ])" ] }, - "execution_count": 44, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -509,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -518,7 +535,7 @@ "50" ] }, - "execution_count": 10, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -529,16 +546,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 2. , 2.2, 2.4, 2.6, 2.8, 3. ])" + "array([2. , 2.2, 2.4, 2.6, 2.8, 3. ])" ] }, - "execution_count": 11, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -549,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -558,7 +575,7 @@ "array([-1. , -0.75, -0.5 , -0.25, 0. , 0.25, 0.5 , 0.75, 1. ])" ] }, - "execution_count": 12, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -578,7 +595,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -587,23 +604,21 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "Now that we've saved it with a variable name, we can do some computations with the array. E.g., take the square of every element of the array, in one go:" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 1. 0.5625 0.25 0.0625 0. 0.0625 0.25 0.5625 1. ]\n" + "[1. 0.5625 0.25 0.0625 0. 0.0625 0.25 0.5625 1. ]\n" ] } ], @@ -621,14 +636,14 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 1. 0.75 0.5 0.25 0. 0.25 0.5 0.75 1. ]\n" + "[1. 0.75 0.5 0.25 0. 0.25 0.5 0.75 1. ]\n" ] } ], @@ -646,7 +661,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -671,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -698,14 +713,14 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n", + "/opt/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n", " \"\"\"Entry point for launching an IPython kernel.\n" ] }, @@ -716,7 +731,7 @@ " 4. , 2. , 1.33333333, 1. ])" ] }, - "execution_count": 50, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -738,7 +753,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -764,7 +779,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -781,7 +796,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -791,7 +806,7 @@ " [3, 5]])" ] }, - "execution_count": 53, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -809,7 +824,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -819,7 +834,7 @@ " [ 0, 4]])" ] }, - "execution_count": 54, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -837,7 +852,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -847,7 +862,7 @@ " [3, 1]])" ] }, - "execution_count": 55, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -865,7 +880,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 38, "metadata": {}, "outputs": [ { @@ -875,7 +890,7 @@ " [3, 1]])" ] }, - "execution_count": 56, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -901,7 +916,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -910,7 +925,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -941,7 +956,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -950,7 +965,7 @@ "(2, 3, 4)" ] }, - "execution_count": 59, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -970,9 +985,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "When we have multidimensional arrays, we can access slices of their elements by slicing on each dimension. This is one of the advantages of using arrays: we cannot do this with lists. \n", "\n", @@ -981,7 +994,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -991,7 +1004,7 @@ " [3, 4]])" ] }, - "execution_count": 60, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -1002,7 +1015,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 43, "metadata": {}, "outputs": [ { @@ -1011,7 +1024,7 @@ "1" ] }, - "execution_count": 61, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -1023,7 +1036,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -1032,7 +1045,7 @@ "2" ] }, - "execution_count": 62, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -1063,7 +1076,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -1072,7 +1085,7 @@ "array([1, 3])" ] }, - "execution_count": 63, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -1091,7 +1104,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -1100,7 +1113,7 @@ "array([1, 2])" ] }, - "execution_count": 64, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } @@ -1131,7 +1144,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -1146,7 +1159,7 @@ " [20, 21, 22, 23]]])" ] }, - "execution_count": 65, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" } @@ -1164,7 +1177,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -1174,7 +1187,7 @@ " [12, 16, 20]])" ] }, - "execution_count": 66, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } @@ -1198,7 +1211,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -1208,7 +1221,7 @@ " [12, 16]])" ] }, - "execution_count": 67, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -1226,7 +1239,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -1235,7 +1248,7 @@ "array([5, 6])" ] }, - "execution_count": 68, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -1282,7 +1295,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ @@ -1292,7 +1305,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 52, "metadata": {}, "outputs": [], "source": [ @@ -1302,15 +1315,15 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[37, 62, 29, 48, 89, 21, 93, 82, 90, 65]\n", - "[46, 20, 26, 52, 76, 77, 78, 17, 80, 89]\n" + "[78, 71, 32, 12, 88, 84, 7, 49, 93, 13]\n", + "[24, 70, 98, 72, 17, 48, 82, 55, 87, 54]\n" ] } ], @@ -1331,15 +1344,15 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 43 µs, sys: 0 ns, total: 43 µs\n", - "Wall time: 49.1 µs\n" + "CPU times: user 30 µs, sys: 8 µs, total: 38 µs\n", + "Wall time: 41 µs\n" ] } ], @@ -1352,14 +1365,14 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[83, 82, 55, 100, 165, 98, 171, 99, 170, 154]\n" + "[102, 141, 130, 84, 105, 132, 89, 104, 180, 67]\n" ] } ], @@ -1378,7 +1391,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ @@ -1388,15 +1401,15 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[61 75 51 76 48 80 69 79 91 0]\n", - "[87 67 74 97 76 91 37 43 69 11]\n" + "[ 3 67 98 94 87 71 28 60 12 24]\n", + "[29 59 1 45 85 92 17 0 15 58]\n" ] } ], @@ -1415,15 +1428,15 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 58, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 37 µs, sys: 0 ns, total: 37 µs\n", - "Wall time: 42.2 µs\n" + "CPU times: user 27 µs, sys: 7 µs, total: 34 µs\n", + "Wall time: 39.6 µs\n" ] } ], @@ -1464,17 +1477,16 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0. 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5 0.55\n", - " 0.6 0.65 0.7 0.75 0.8 0.85 0.9 0.95 1. 1.05 1.1 1.15\n", - " 1.2 1.25 1.3 1.35 1.4 1.45 1.5 1.55 1.6 1.65 1.7 1.75\n", - " 1.8 1.85 1.9 1.95 2. ]\n" + "[0. 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5 0.55 0.6 0.65\n", + " 0.7 0.75 0.8 0.85 0.9 0.95 1. 1.05 1.1 1.15 1.2 1.25 1.3 1.35\n", + " 1.4 1.45 1.5 1.55 1.6 1.65 1.7 1.75 1.8 1.85 1.9 1.95 2. ]\n" ] } ], @@ -1485,7 +1497,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ @@ -1498,38 +1510,38 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To plot the resulting arrays as a function of the orginal one (`xarray`) in the x-axis, we need to import the module `pyplot` from **Matplotlib**." + "# Introduction to plotting\n", + "\n", + "To plot the resulting arrays as a function of the orginal one (`xarray`) in the x-axis, we need to import the module `pyplot` from **Matplotlib**.\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" + "import matplotlib.pyplot as plt" ] }, { - "cell_type": "code", - "execution_count": 90, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def setdefaults():\n", - " plt.rcParams.update({'font.size': 22})\n", - " plt.rcParams['lines.linewidth'] = 3\n", - "\n" + "# Set up default plotting parameters\n", + "\n", + "The default Matplotlib fonts and linewidths are a little small. Pixels are free, so the next two lines increase the fontsize and linewidth" ] }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ - "setdefaults()" + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['lines.linewidth'] = 3" ] }, { @@ -1548,22 +1560,22 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 92, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1596,12 +1608,12 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 65, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1614,13 +1626,13 @@ ], "source": [ "#Plot x^2\n", - "pyplot.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n", + "plt.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n", "#Plot x^3\n", - "pyplot.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n", + "plt.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n", "#Plot sqrt(x)\n", - "pyplot.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n", + "plt.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n", "#Plot the legends in the best location\n", - "pyplot.legend(loc='best'); " + "plt.legend(loc='best'); " ] }, { @@ -1647,6 +1659,8 @@ "source": [ "## What we've learned\n", "\n", + "* Good coding habits and file naming\n", + "* How to define a function and return outputs\n", "* How to import libraries\n", "* Multidimensional arrays using NumPy\n", "* Accessing values and slicing in NumPy arrays\n", @@ -1661,6 +1675,8 @@ "source": [ "## References\n", "\n", + "1. [Best practices for file naming](https://library.stanford.edu/research/data-management-services/data-best-practices/best-practices-file-naming). Stanford Libraries\n", + "\n", "1. _Effective Computation in Physics: Field Guide to Research with Python_ (2015). Anthony Scopatz & Kathryn D. Huff. O'Reilly Media, Inc.\n", "\n", "2. _Numerical Python: A Practical Techniques Approach for Industry_. (2015). Robert Johansson. Appress. \n", @@ -1668,10454 +1684,79 @@ "2. [\"The world of Jupyter\"—a tutorial](https://github.com/barbagroup/jupyter-tutorial). Lorena A. Barba - 2016" ] }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" - ] - }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "metadata": {}, "source": [ - "# Thanks" + "# Problems\n", + "\n", + "1. Create a function called `sincos(x)` that returns two arrays, `sinx` and `cosx` that return the sine and cosine of the input array, `x`. \n", + "\n", + " a. Document your function with a help file in `'''help'''`\n", + " \n", + " b. Use your function to plot sin(x) and cos(x) for x=$0..2\\pi$\n", + "\n" ] }, { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "# Freefall Model (revisited)\n", - "\n", - "\n", - "Define time from 0 to 12 seconds with `N` timesteps \n", - "function defined as `freefall`\n", - "\n", - "m=60 kg, c=0.25 kg/m" + "def sincos(x):\n", + " '''help'''\n", + " # your code here, replace '''help''' with your documentation\n", + " \n", + " return sinx, cosx\n", + " " ] }, { "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, + "metadata": {}, "source": [ - "## Freefall example\n", - "\n", - "Estimated the function with a $1^{st}$-order approximation, so \n", - "\n", - "$v(t_{i+1})=v(t_{i})+v'(t_{i})(t_{i+1}-t_{i})+R_{1}$\n", - "\n", - "$v'(t_{i})=\\frac{v(t_{i+1})-v(t_{i})}{t_{i+1}-t_{i}}-\\frac{R_{1}}{t_{i+1}-t_{i}}$\n", + "2. Use a for-loop to create a variable called `A_99`, where every element is the product\n", + "of the two indices from 0 to 9 e.g. A_99[3,2]=6 and A_99[4,4]=16. \n", "\n", - "$\\frac{R_{1}}{t_{i+1}-t_{i}}=\\frac{v''(\\xi)}{2!}(t_{i+1}-t_{i})$\n", + " a. time your script using `%%time` \n", + " \n", + " b. Calculate the mean of `A_99`\n", "\n", - "or the truncation error for a first-order Taylor series approximation is\n", - "\n", - "$R_{1}=O(\\Delta t^{2})$\n" + " c. Calculate the standard deviation of `A_99`\n", + " \n" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], - "source": [ - "function [v_analytical,v_terminal,t]=freefall(N)\n", - " % help file for freefall.m\n", - " % N is number of timesteps between 0 and 12 sec\n", - " % v_an...\n", - " t=linspace(0,12,N)';\n", - " c=0.25; m=60; g=9.81; v_terminal=sqrt(m*g/c);\n", - "\n", - " v_analytical = v_terminal*tanh(g*t/v_terminal);\n", - " v_numerical=zeros(length(t),1);\n", - " delta_time =diff(t);\n", - " for i=1:length(t)-1\n", - " v_numerical(i+1)=v_numerical(i)+(g-c/m*v_numerical(i)^2)*delta_time(i);\n", - " end\n", - " % Print values near 0,2,4,6,8,10,12 seconds\n", - " indices = round(linspace(1,length(t),7));\n", - " fprintf('time (s)|vel analytical (m/s)|vel numerical (m/s)\\n')\n", - " fprintf('-----------------------------------------------\\n')\n", - " M=[t(indices),v_analytical(indices),v_numerical(indices)];\n", - " fprintf('%7.1f | %18.2f | %15.2f\\n',M(:,1:3)');\n", - " plot(t,v_analytical,'-',t,v_numerical,'o-')\n", - "end\n", - " " - ] + "source": [] }, { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "time (s)|vel analytical (m/s)|vel numerical (m/s)\n", - "-----------------------------------------------\n", - " 0.0 | 0.00 | 0.00\n", - " 2.0 | 18.62 | 18.62\n", - " 4.0 | 32.46 | 32.46\n", - " 6.0 | 40.64 | 40.65\n", - " 8.0 | 44.85 | 44.85\n", - " 10.0 | 46.85 | 46.85\n", - " 12.0 | 47.77 | 47.77\n" - ] - }, - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t30\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t40\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t50\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t2\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t4\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t6\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t8\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t12\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\tgnuplot_plot_2a\n", - "\n", - "\t\t \n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "[v_analytical,v_terminal,t]=freefall(10000);" + "3. Use the two arrays, X and Y, given below to create A_99 using numpy array math rather than a for-loop. \n", + "\n", + " a. time your script using `%%time` \n", + " \n", + " b. Calculate the mean of `A_99`\n", + "\n", + " c. Calculate the standard deviation of `A_99`\n", + " \n", + " d. create a filled contour plot of X, Y, A_99 [contourf plot documentation](https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.contourf.html)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 72, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans = 1.4400e-06\r\n" - ] - } - ], + "outputs": [], "source": [ - "(12/10000)^2" + "# given X and Y arrays\n", + "X,Y=np.meshgrid(np.arange(0,10),np.arange(0,10))" ] } ], @@ -12136,9 +1777,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/notebooks/03-Numerical_error.ipynb b/notebooks/03-Numerical_error.ipynb new file mode 100644 index 0000000..c49ee15 --- /dev/null +++ b/notebooks/03-Numerical_error.ipynb @@ -0,0 +1,891 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Freefall Model\n", + "## Computational solution\n", + "\n", + " \n", + "\n", + "Here is our first computational mechanics model. \n", + "\n", + "An object falling is subject to the force of \n", + "\n", + "- gravity ($F_g$=mg) and \n", + "- drag ($F_d=cv^2$)\n", + "\n", + "Acceleration of the object:\n", + "\n", + "$\\sum F=ma=F_g-F_d=mg - cv^2 = m\\frac{dv}{dt}$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Computational models do not solve for functions e.g. v(t), but rather functions at given points in time (or space):\n", + "\n", + "\n", + "Therefore, we define time from 0 to 12 seconds\n", + "\n", + "t=[0,2,4,6,8,10,12]'" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "t=np.array([0,2,4,6,8,10,12])\n", + "# or \n", + "t=np.linspace(0,12,7)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Define constants and analytical solution (meters-kilogram-sec)\n", + "\n", + "g=9.81 m/s$^2$, c=0.25 kg/m, m=60 kg\n", + "\n", + "$v_{terminal}=\\sqrt{\\frac{mg}{c}}$\n", + "\n", + "$v(t)=v_{terminal}\\tanh{\\left(\\frac{gt}{v_{terminal}}\\right)}$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "at time 0 s, speed is 0.00\n", + "at time 2 s, speed is 18.62\n", + "at time 4 s, speed is 32.46\n", + "at time 6 s, speed is 40.64\n", + "at time 8 s, speed is 44.85\n", + "at time 10 s, speed is 46.85\n", + "at time 12 s, speed is 47.77\n" + ] + } + ], + "source": [ + "c=0.25 \n", + "m=60\n", + "g=9.81 \n", + "\n", + "\n", + "def v_analytical(t,m,g,c):\n", + " v_terminal=np.sqrt(m*g/c)\n", + " v= v_terminal*np.tanh(g*t/v_terminal)\n", + " return v\n", + "\n", + "v_an=v_analytical(t,m,g,c)\n", + "\n", + "for i,v in enumerate(v_an):\n", + " print('at time %2.0f s, speed is %1.2f'%(t[i],v))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Define numerical method\n", + "#### Finite difference approximation\n", + "\n", + "$\\frac{v(t_{i+1})-v(t_{i})}{t_{i+1}-t_{i}}=g-\\frac{c}{m}v(t_{i})^2$\n", + "\n", + "solve for $v(t_{i+1})$\n", + "\n", + "$v(t_{i+1})=v(t_{i})+\\left(g-\\frac{c}{m}v(t_{i})^2\\right)(t_{i+1}-t_{i})$\n", + "\n", + "or\n", + "\n", + "$v(t_{i+1})=v(t_{i})+\\frac{dv_{i}}{dt}(t_{i+1}-t_{i})$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 19.62 , 36.03213 , 44.8328434 ,\n", + " 47.702978 , 48.35986042, 48.49089292])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v_numerical=np.zeros(len(t));\n", + "for i in range(1,len(t)):\n", + " v_numerical[i]=v_numerical[i-1]+((g-c/m*v_numerical[i-1]**2))*2;\n", + "\n", + "v_numerical" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Display time, velocity (analytical) and velocity (numerical)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time (s)|vel analytical (m/s)|vel numerical (m/s)\n", + "\n", + "-----------------------------------------------\n", + " 0.0 | 0.00 | 0.00\n", + "\n", + " 2.0 | 18.62 | 19.62\n", + "\n", + " 4.0 | 32.46 | 36.03\n", + "\n", + " 6.0 | 40.64 | 44.83\n", + "\n", + " 8.0 | 44.85 | 47.70\n", + "\n", + " 10.0 | 46.85 | 48.36\n", + "\n", + " 12.0 | 47.77 | 48.49\n", + "\n" + ] + } + ], + "source": [ + "print('time (s)|vel analytical (m/s)|vel numerical (m/s)\\n')\n", + "print('-----------------------------------------------')\n", + "for i in range(0,len(t)):\n", + " print('%7.1f | %18.2f | %15.2f\\n'%(t[i],v_an[i],v_numerical[i]));" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Set default values for plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams.update({'font.size': 22})\n", + "plt.rcParams['lines.linewidth'] = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'velocity (m/s)')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t,v_an,'-',label='analytical')\n", + "plt.plot(t,v_numerical,'o-',label='numerical')\n", + "plt.legend()\n", + "plt.xlabel('time (s)')\n", + "plt.ylabel('velocity (m/s)')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Errors in Numerical Modeling\n", + "\n", + "## 1 - Truncation\n", + "## 2 - Roundoff " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# 1- Truncation error\n", + "## Freefall is example of \"truncation error\"\n", + "### Truncation error results from approximating exact mathematical procedure\n", + "\n", + "We approximated the derivative as $\\delta v/\\delta t\\approx\\Delta v/\\Delta t$\n", + "\n", + "Can reduce error in two ways\n", + "\n", + "1. Decrease step size -> $\\Delta t$=`delta_time`\n", + "\n", + "2. Increase the accuracy of the approximation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Truncation error as a Taylor series \n", + "\n", + "The freefall problem solution used a first-order Taylor series approximation\n", + "\n", + "Taylor series:\n", + "$f(x)=f(a)+f'(a)(x-a)+\\frac{f''(a)}{2!}(x-a)^{2}+\\frac{f'''(a)}{3!}(x-a)^{3}+...$\n", + "\n", + "First-order approximation:\n", + "$f(x_{i+1})=f(x_{i})+f'(x_{i})h$\n", + "\n", + "\n", + "We can increase accuracy in a function by adding Taylor series terms:\n", + "\n", + "|Approximation | formula |\n", + "|---|-----------------------------|\n", + "|$0^{th}$-order | $f(x_{i+1})=f(x_{i})+R_{1}$ |\n", + "|$1^{st}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+R_{2}$ |\n", + "|$2^{nd}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+\\frac{f''(x_{i})}{2!}h^{2}+R_{3}$|\n", + "|$n^{th}$-order | $f(x_{i+1})=f(x_{i})+f'(x_{i})h+\\frac{f''(x_{i})}{2!}h^{2}+...\\frac{f^{(n)}}{n!}h^{n}+R_{n}$|\n", + "\n", + "Where $R_{n}=O(h^{n+1})$ is the error associated with truncating the approximation at order $n$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "In the .gif below, the error in the function is reduced by including higher-order terms in the Taylor series approximation. \n", + "\n", + "![3](https://media.giphy.com/media/xA7G2n20MzTOw/giphy.gif)\n", + "\n", + "$n^{th}$-order approximation equivalent to \n", + "an $n^{th}$-order polynomial. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "# 1- Roundoff\n", + "\n", + "## Just storing a number in a computer requires rounding\n", + "\n", + "1. digital representation of a number is rarely exact\n", + "\n", + "2. arithmetic (+,-,/,\\*) causes roundoff error\n", + "\n", + "[Consider the number $\\pi$](https://www.piday.org/million/). How many digits can a floating point number in a computer accurately represent?" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "double precision 64 bit pi = 3.14159265358979311599796347\n", + "\n", + "single precision 32 bit pi = 3.14159274101257324218750000\n", + "\n", + "First 26 digits of pi = 3.14159265358979323846264338\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "pi=np.pi\n", + "double=np.array([pi],dtype='float64')\n", + "single=np.array([pi],dtype='float32')\n", + "print('double precision 64 bit pi = %1.26f\\n'%double) # 64-bit\n", + "print('single precision 32 bit pi = %1.26f\\n'%single) # 32-bit\n", + "print('First 26 digits of pi = 3.14159265358979323846264338')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to store the number in a computer you can only use so many bits, shown below is the 64-bit standard for floating point numbers:\n", + "\n", + " \n", + "\n", + "Each time you use an operation, e.g. `+ - / *` you lose some precision as well. \n", + "\n", + "Consider $\\pi$ again\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "no operations 64 bit pi = 3.14159265358979311599796347\n", + "\n", + "20 operations 64 bit pi = 3.14159265358979089555191422\n", + "\n", + "First 26 digits of pi = 3.14159265358979323846264338\n" + ] + } + ], + "source": [ + "double=np.array([pi],dtype='float64')\n", + "double_operated=double\n", + "for i in range(0,10):\n", + " double_operated=double_operated*(i+1)*1.0e-16\n", + " double_operated=double_operated*1/(i+1)*1.0e16\n", + "print('no operations 64 bit pi = %1.26f\\n'%double) # 64-bit\n", + "print('20 operations 64 bit pi = %1.26f\\n'%double_operated) # 64-bit after 1000 additions and 1 subtraction\n", + "print('First 26 digits of pi = 3.14159265358979323846264338')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the previous block of code, we see $\\pi$ printed for 3 cases:\n", + "\n", + "1. the 64-bit representation of $\\pi$\n", + "\n", + "2. the value of $\\pi$ after it has gone through 20 math operations ($\\times (0..10)10^{-16}$, then $\\times (0..10)10^{16}$)\n", + "\n", + "3. the actual value of $\\pi$ for the first 26 digits\n", + "\n", + "All three (1-3) have the same first 14 digits after the decimal, then we see a divergence between the actual value of $\\pi$ (3), and $\\pi$ as represented by floating point numbers. \n", + "\n", + "We can get an idea for computational limits using some built-in functions:\n", + "\n", + "- `np.info('float64').max`: the largest floating point 64-bit number the computer can represent\n", + "\n", + "- `np.info('float64').tiny`: the smallest non-negative 64-bit number the computer can represent\n", + "\n", + "- `np.info('float64').eps`: the smallest number that can be added to 1" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "realmax = 1.79769313486231570815e+308\n", + "\n", + "realmin = 2.22507385850720138309e-308\n", + "\n", + "maximum relative error = 2.22044604925031308085e-16\n", + "\n" + ] + } + ], + "source": [ + "print('realmax = %1.20e\\n'%np.finfo('float64').max)\n", + "print('realmin = %1.20e\\n'%np.finfo('float64').tiny)\n", + "print('maximum relative error = %1.20e\\n'%np.finfo('float64').eps)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Machine epsilon\n", + "\n", + "Smallest number that can be added to 1 and change the value in a computer.\n", + "\n", + "In the following example, we will add $eps/2$ to s=1 1,000$\\times$. The result should be $s=1+500\\cdot eps$, but because $eps/2$ is smaller than floating point operations can track, we will get a different result depending upon how we do the addition.\n", + "\n", + "a. We make a `for`-loop and add $eps/2$ 1000 times in the loop\n", + "\n", + "b. We multiply $1000*eps/2$ and add it to the result" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "summation 1+eps/2 over 1000 minus 1 = 0.0\n", + "500.0 *eps= 1.11022302463e-13\n" + ] + } + ], + "source": [ + "s1=1;\n", + "N=1000\n", + "eps=np.finfo('float64').eps\n", + "for i in range(1,N):\n", + " s1+=eps/2;\n", + "\n", + "s2=1+500*eps\n", + "print('summation 1+eps/2 over ',N,' minus 1 =',(s-1))\n", + "print(N/2,'*eps=',(s2-1))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Freefall Model (revisited)\n", + "\n", + "\n", + "Define time from 0 to 12 seconds with `N` timesteps \n", + "function defined as `freefall`\n", + "\n", + "m=60 kg, c=0.25 kg/m" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Freefall example\n", + "\n", + "Estimated the function with a $1^{st}$-order approximation, so \n", + "\n", + "$v(t_{i+1})=v(t_{i})+v'(t_{i})(t_{i+1}-t_{i})+R_{1}$\n", + "\n", + "$v'(t_{i})=\\frac{v(t_{i+1})-v(t_{i})}{t_{i+1}-t_{i}}-\\frac{R_{1}}{t_{i+1}-t_{i}}$\n", + "\n", + "$\\frac{R_{1}}{t_{i+1}-t_{i}}=\\frac{v''(\\xi)}{2!}(t_{i+1}-t_{i})$\n", + "\n", + "or the truncation error for a first-order Taylor series approximation is\n", + "\n", + "$R_{1}=O(\\Delta t^{2})$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Computer model error = truncation + roundoff\n", + "\n", + "In the function `freefall(N)`, the speed of a 60-kg object is predicted in two ways:\n", + "\n", + "1. The analytical 64-bit representation, \n", + "$v(t)=v_{terminal}\\tanh{\\left(\\frac{gt}{v_{terminal}}\\right)}$\n", + "\n", + "2. The numerical 32-bit$^{+}$ Euler approximation for `N`-steps from 0 to 2 seconds\n", + "\n", + "$^{+}$Here, we use a 32-bit representation to observe the transition from truncation error to floating point error in a reasonable number of steps. \n", + "\n", + "We can reduce truncation error by decreasing the timestep, $\\Delta t$. Here, we consider the speed from 0 to 2 seconds, so `N=3` means $\\Delta t$= 1 s and `N=21` means $\\Delta t$=0.1 s\n", + "\n", + "|N= | $\\Delta t$=|\n", + "|---|---|\n", + "|3 | 1 s|\n", + "|21| 0.1 s|\n", + "|201| 0.01 s|\n", + "|??| 0.05 s|\n", + "|?? | 0.001 s|\n", + "\n", + "What is N for 0.05 s and 0.001 s in the table above?\n", + "\n", + "Answer (0.05 s): 41 \n", + "\n", + "Answer (0.001 s): 2001 \n", + "\n", + "Highlight lines above for answer." + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def freefall(N):\n", + " ''' help file for freefall(N)\n", + " computes the velocity as a function of time, t, for a\n", + " 60-kg object with zero initial velocity and drag \n", + " coefficient of 0.25 kg/s\n", + " N is number of timesteps between 0 and 2 sec\n", + " v_analytical is the 64-bit floating point \"true\" solution\n", + " v_numerical is the 32-bit approximation of the velocity\n", + " t is the timesteps between 0 and 2 sec, divided into N steps'''\n", + " t=np.linspace(0,2,N)\n", + " c=0.25\n", + " m=60\n", + " g=9.81\n", + " v_terminal=np.sqrt(m*g/c)\n", + "\n", + " v_analytical = v_terminal*np.tanh(g*t/v_terminal);\n", + " v_numerical=np.empty(len(t),dtype=np.float32)\n", + " delta_time =np.diff(t)\n", + " for i in range(0,len(t)-1):\n", + " v_numerical[i+1]=v_numerical[i]+(g-c/m*v_numerical[i]**2)*delta_time[i];\n", + " \n", + " return v_analytical,v_numerical,t\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare solutions\n", + "\n", + "We can compare solutions in a figure in a number of ways:\n", + "\n", + "1. plot the values, e.g. $v_{analytical}$ and $v_{numerical}$\n", + "\n", + "2. plot the difference between the values (the absolute error) e.g. $v_{numerical}-v_{analytical}$\n", + "\n", + "3. plot the ratio of the values e.g. $\\frac{v_{numerical}}{v_{analytical}}$ (useful in finding bugs, unit analysis, etc.)\n", + "\n", + "4. plot the ratio of the error to the best estimate (the relative error) e.g. $\\frac{v_{numerical}-v_{analytical}}{v_{analytical}}$\n", + "\n", + "We will make use of methods (1) and (4) in this example. \n", + "\n", + "We can visualize how the approximation approaches the exact solution with this method. The process of approaching the \"true\" solution is called **convergence**. " + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n=2\n", + "\n", + "v_analytical,v_numerical,t=freefall(n);\n", + "\n", + "plt.plot(t,v_numerical,'o',label=str(n)+' Euler steps')\n", + "plt.plot(t,v_analytical,label='analytical')\n", + "plt.title('First 2 seconds of freefall')\n", + "plt.xlabel('time (s)')\n", + "plt.ylabel('speed (m/s)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Try adjusting `N` in the code above to watch the solution converge. You should notice the Euler approximation becomes almost indistinguishable from the analytical solution as `N` increases. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convergence of a numerical model\n", + "\n", + "You should see that the more time steps we use, the closer the Euler approximation resembles the analytical solution. This is true only to a point, due to **roundoff error**. In our `freefall` function, the numerical result is saved as a 32-bit floating point array. Our best approximation of the freefall function is the 64-bit analytical equation `v_terminal*np.tanh(g*t/v_terminal)`.$^{+}$ \n", + "\n", + "In the next plot, we consider the relative error for the velocity at t=2 s, as a function of `N`. \n", + "\n", + "$^+$ Note: In practice, there is no reason to restrict the precision of our floating point numbers. The function was written this way to highlight the effect of roundoff error without significant computational resources. You would need significantly more timesteps to observe floating point error with 64-bit floating point numbers. " + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [], + "source": [ + "N=100\n", + "error=np.zeros(N)\n", + "n=np.logspace(2,5,N) # create an array from 10^2 to 10^5 with N values\n", + "for i in range(0,N):\n", + " v_an,v_num,t=freefall(n[i])\n", + " error[i]=(v_num[-1]-v_an[-1])/v_an[-1] #calculate relative error in velocity at final time t=2 s\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2. , 2.03030303, 2.06060606, 2.09090909, 2.12121212,\n", + " 2.15151515, 2.18181818, 2.21212121, 2.24242424, 2.27272727,\n", + " 2.3030303 , 2.33333333, 2.36363636, 2.39393939, 2.42424242,\n", + " 2.45454545, 2.48484848, 2.51515152, 2.54545455, 2.57575758,\n", + " 2.60606061, 2.63636364, 2.66666667, 2.6969697 , 2.72727273,\n", + " 2.75757576, 2.78787879, 2.81818182, 2.84848485, 2.87878788,\n", + " 2.90909091, 2.93939394, 2.96969697, 3. , 3.03030303,\n", + " 3.06060606, 3.09090909, 3.12121212, 3.15151515, 3.18181818,\n", + " 3.21212121, 3.24242424, 3.27272727, 3.3030303 , 3.33333333,\n", + " 3.36363636, 3.39393939, 3.42424242, 3.45454545, 3.48484848,\n", + " 3.51515152, 3.54545455, 3.57575758, 3.60606061, 3.63636364,\n", + " 3.66666667, 3.6969697 , 3.72727273, 3.75757576, 3.78787879,\n", + " 3.81818182, 3.84848485, 3.87878788, 3.90909091, 3.93939394,\n", + " 3.96969697, 4. , 4.03030303, 4.06060606, 4.09090909,\n", + " 4.12121212, 4.15151515, 4.18181818, 4.21212121, 4.24242424,\n", + " 4.27272727, 4.3030303 , 4.33333333, 4.36363636, 4.39393939,\n", + " 4.42424242, 4.45454545, 4.48484848, 4.51515152, 4.54545455,\n", + " 4.57575758, 4.60606061, 4.63636364, 4.66666667, 4.6969697 ,\n", + " 4.72727273, 4.75757576, 4.78787879, 4.81818182, 4.84848485,\n", + " 4.87878788, 4.90909091, 4.93939394, 4.96969697, 5. ])" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.log10(n)" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Truncation and roundoff error \\naccumulation in log-log plot')" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.loglog(n,error,'o')\n", + "plt.xlabel('number of timesteps N')\n", + "plt.ylabel('relative error')\n", + "plt.title('Truncation and roundoff error \\naccumulation in log-log plot')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above plot \"Truncation and roundoff error accumulation in log-log plot\", we see that around N=20,000 steps we stop decreasing the error with more steps. This is because we are approaching the limit of how precise we can store a number using a 32-bit floating point number. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What we've learned\n", + "\n", + "* Numerical integration with the Euler approximation\n", + "* The source of truncation errors\n", + "* The source of roundoff errors\n", + "* " + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "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.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/05_consistent-coding and functions.ipynb b/notebooks/05_consistent-coding and functions.ipynb deleted file mode 100644 index f9e8b26..0000000 --- a/notebooks/05_consistent-coding and functions.ipynb +++ /dev/null @@ -1,1017 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "slideshow": { - "slide_type": "skip" - } - }, - "outputs": [], - "source": [ - "%plot --format svg" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Good coding habits\n", - "## naming folders and files" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "# [Stanford file naming best practices](https://library.stanford.edu/research/data-management-services/data-best-practices/best-practices-file-naming)\n", - "\n", - "1. Include information to distinguish file name e.g. project name, objective of function, name/initials, type of data, conditions, version of file, \n", - "2. if using dates, use YYYYMMDD, so the computer organizes by year, then month, then day\n", - "3. avoid special characters e.g. !, #, \\$, ...\n", - "4. avoid using spaces if not necessary, some programs consider a space as a break in code use dashes `-` or underscores `_` or CamelCase" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Commenting your code\n", - "\n", - "Its important to comment your code \n", - "\n", - "- what are variable's units,\n", - "\n", - "- what the is the function supposed to do, \n", - "\n", - "- etc. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [], - "source": [ - "function i=code(j)\n", - " % Example of bad variable names and bad function name\n", - " for w=1:j\n", - " i(w)=w;\n", - " end\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ans =\n", - "\n", - " 1 2\n", - "\n" - ] - } - ], - "source": [ - "code(2,3)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Choose variable names that describe the variable" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [], - "source": [ - "function count_vector=counting_function(max_value)\n", - " % Good variable names and better help documentation\n", - " % \n", - " % counting function creates a vector from 1 to max_value where each \n", - " % index, i, is stored in each vector spot\n", - " for i=1:max_value\n", - " count_vector(i)=i; % set each element in count_vector to i\n", - " end\n", - "end " - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cnt_v =\n", - "\n", - " 1 2 3 4 5 6 7 8 9\n", - "\n" - ] - } - ], - "source": [ - "cnt_v=counting_function(9)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true, - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "## Putting it all together" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "0. Use (https://github.uconn.edu/) to create an account and create your first repository \"01_ME3255_repo\"\n", - "1. Create a new file in your github repo with the default plot settings:\n", - " \n", - " ` set (0, \"defaultaxesfontsize\", 18)\n", - " set (0, \"defaulttextfontsize\", 18) \n", - " set (0, \"defaultlinelinewidth\", 4)`\n", - "1. Clone your \"01_ME3255_repo\" repository to your computer\n", - "2. open Matlab (cli, jupyter or gui)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "5\\. Change working directory to 01_ME3255_repo *e.g.* \n", - " Windows:`cd('C:\\Users\\rcc02007\\Documents\\Github\\01_ME3255_repo')`, \n", - " Mac: `cd('/Users/rcc02007/Documents/Github/01_ME3255_repo')`" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "6\\. Run `>> setdefaults.m`\n", - "\n", - "7\\. Create a new m-file called nitrogen_pressure.m\n", - "\n", - "8\\. Create a function based upon the ideal gas law for nitrogen, Pv=RT\n", - " 1. R=0.2968 kJ/(kg-K)\n", - " 2. inputs to function are v (specific volume m^3/kg), and T, temperature (K)\n", - " 3. output is P, pressure (kPa)\n", - "\n", - "9\\. Once the function works, commit the change to the repository (add a message, like 'added file nitrogen_pressure.m'\n", - "\n", - "10\\. After file is 'committed', 'push' the changes to your github account" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "for the command-line git user, this is steps 8 and 9:\n", - "1. `$ git add *`\n", - "2. `$ git commit -m 'added file nitrogen_pressure.m'`\n", - "3. `$ git push -u origin master\n", - " Username for 'https://github.uconn.edu':rcc02007 \n", - " Password for 'https://rcc02007@github.uconn.edu': `\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true, - "slideshow": { - "slide_type": "subslide" - } - }, - "source": [ - "Now, use this function to plot the range of pressures that a pressure vessel would experience if it is 1000 gallons (3.79 m^3) with 10-20 kg of Nitrogen and temperatures range from -10 to 35 degrees C. \n", - "\n", - "```matlab\n", - "v=0.379/linspace(10,20,10);\n", - "T=273.15+linspace(-10,35,10);\n", - "[v_grid,T_grid]=meshgrid(v,T);\n", - "P = nitrogen_pressure(v,T);\n", - "pcolor(v_grid,T_grid,P)\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "slideshow": { - "slide_type": "subslide" - } - }, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "Gnuplot\n", - "Produced by GNUPLOT 5.0 patchlevel 3 \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\t\n", - "\t \n", - "\t \n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\tgnuplot_plot_1a\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t0.15\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t0.2\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t0.25\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t0.3\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t0.35\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t0.4\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tspecific volume (m3/kg)\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t-10\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t-5\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t0\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t5\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t10\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t15\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t20\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t25\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t30\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\t\n", - "\t\t35\n", - "\t\n", - "\n", - "\n", - "\t\n", - "\t\tTemperature (C)\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\t\t\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\t\n", - "\t\tPressure (kPa)\n", - "\t\n", - "\n", - "\n", - "\n", - "\tgnuplot_plot_1b\n", - "\n", - "\n", - "\n", - ";\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "\t\t\n", - "\t\t150\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t200\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t250\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t300\n", - "\t\n", - "\n", - "\n", - "\t\t\n", - "\t\t350\n", - "\t\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\t\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "setdefaults;\n", - "v=3.79./linspace(10,20,10);\n", - "T=273.15+linspace(-10,35,10);\n", - "[v_grid,T_grid]=meshgrid(v,T);\n", - "P = nitrogen_pressure(v_grid,T_grid);\n", - "pcolor(v_grid,T_grid-273.15,P-100)\n", - "h=colorbar();\n", - "xlabel('specific volume (m^3/kg)')\n", - "ylabel('Temperature (C)')\n", - "ylabel(h,'Pressure (kPa)')\n", - "scale=0.1; % these lines are used to keep xlabel from being cutoff in jupyter\n", - "pos = get(gca, 'Position'); % these lines are used to keep xlabel from being cutoff in jupyter\n", - "pos(2) = pos(2)+scale*pos(4); % these lines are used to keep xlabel from being cutoff in jupyter\n", - "pos(4) = (1-scale)*pos(4); % these lines are used to keep xlabel from being cutoff in jupyter\n", - "set(gca, 'Position', pos) % these lines are used to keep xlabel from being cutoff in jupyter\n", - "%colormap winter\n", - "%colormap summer\n", - "%colormap jet\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "celltoolbar": "Slideshow", - "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.6.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/4_NumPy_Arrays_and_Plotting.ipynb b/notebooks/4_NumPy_Arrays_and_Plotting.ipynb deleted file mode 100644 index 5f86da8..0000000 --- a/notebooks/4_NumPy_Arrays_and_Plotting.ipynb +++ /dev/null @@ -1,1644 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2017 L.A. Barba, N.C. Clementi" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Play with NumPy Arrays\n", - "\n", - "Welcome to **Lesson 4** of the first course module in _\"Engineering Computations_.\" You have come a long way! \n", - "\n", - "Remember, this course assumes no coding experience, so the first three lessons were focused on creating a foundation with Python programming constructs using essentially _no mathematics_. The previous lessons are:\n", - "\n", - "* [Lesson 1](http://go.gwu.edu/engcomp1lesson1): Interacting with Python\n", - "* [Lesson 2](http://go.gwu.edu/engcomp1lesson2): Play with data in Jupyter\n", - "* [Lesson 3](http://go.gwu.edu/engcomp1lesson3): Strings and lists in action\n", - "\n", - "In engineering applications, most computing situations benefit from using *arrays*: they are sequences of data all of the _same type_. They behave a lot like lists, except for the constraint in the type of their elements. There is a huge efficiency advantage when you know that all elements of a sequence are of the same type—so equivalent methods for arrays execute a lot faster than those for lists.\n", - "\n", - "The Python language is expanded for special applications, like scientific computing, with **libraries**. The most important library in science and engineering is **NumPy**, providing the _n-dimensional array_ data structure (a.k.a, `ndarray`) and a wealth of functions, operations and algorithms for efficient linear-algebra computations.\n", - "\n", - "In this lesson, you'll start playing with NumPy arrays and discover their power. You'll also meet another widely loved library: **Matplotlib**, for creating two-dimensional plots of data." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Importing libraries\n", - "\n", - "First, a word on importing libraries to expand your running Python session. Because libraries are large collections of code and are for special purposes, they are not loaded automatically when you launch Python (or IPython, or Jupyter). You have to import a library using the `import` command. For example, to import **NumPy**, with all its linear-algebra goodness, we enter:\n", - "\n", - "```python\n", - "import numpy\n", - "```\n", - "\n", - "Once you execute that command in a code cell, you can call any NumPy function using the dot notation, prepending the library name. For example, some commonly used functions are:\n", - "\n", - "* [`numpy.linspace()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html)\n", - "* [`numpy.ones()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.ones)\n", - "* [`numpy.zeros()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html#numpy.zeros)\n", - "* [`numpy.empty()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.empty.html#numpy.empty)\n", - "* [`numpy.copy()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.copy.html#numpy.copy)\n", - "\n", - "Follow the links to explore the documentation for these very useful NumPy functions!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Warning:\n", - "\n", - "You will find _a lot_ of sample code online that uses a different syntax for importing. They will do:\n", - "```python\n", - "import numpy as np\n", - "```\n", - "All this does is create an alias for `numpy` with the shorter string `np`, so you then would call a **NumPy** function like this: `np.linspace()`. This is just an alternative way of doing it, for lazy people that find it too long to type `numpy` and want to save 3 characters each time. For the not-lazy, typing `numpy` is more readable and beautiful. \n", - "\n", - "We like it better like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import numpy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creating arrays\n", - "\n", - "To create a NumPy array from an existing list of (homogeneous) numbers, we call **`numpy.array()`**, like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 3, 5, 8, 17])" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.array([3, 5, 8, 17])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "NumPy offers many [ways to create arrays](https://docs.scipy.org/doc/numpy/reference/routines.array-creation.html#routines-array-creation) in addition to this. We already mentioned some of them above. \n", - "\n", - "Play with `numpy.ones()` and `numpy.zeros()`: they create arrays full of ones and zeros, respectively. We pass as an argument the number of array elements we want. " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 1., 1., 1., 1., 1.])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.ones(5)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0., 0., 0.])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.zeros(3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Another useful one: `numpy.arange()` gives an array of evenly spaced values in a defined interval. \n", - "\n", - "*Syntax:*\n", - "\n", - "`numpy.arange(start, stop, step)`\n", - "\n", - "where `start` by default is zero, `stop` is not inclusive, and the default\n", - "for `step` is one. Play with it!\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1, 2, 3])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.arange(4)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([2, 3, 4, 5])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.arange(2, 6)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([2, 4])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.arange(2, 6, 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.arange(2, 6, 0.5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`numpy.linspace()` is similar to `numpy.arange()`, but uses number of samples instead of a step size. It returns an array with evenly spaced numbers over the specified interval. \n", - "\n", - "*Syntax:*\n", - "\n", - "`numpy.linspace(start, stop, num)`\n", - "\n", - "`stop` is included by default (it can be removed, read the docs), and `num` by default is 50. " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 2. , 2.02040816, 2.04081633, 2.06122449, 2.08163265,\n", - " 2.10204082, 2.12244898, 2.14285714, 2.16326531, 2.18367347,\n", - " 2.20408163, 2.2244898 , 2.24489796, 2.26530612, 2.28571429,\n", - " 2.30612245, 2.32653061, 2.34693878, 2.36734694, 2.3877551 ,\n", - " 2.40816327, 2.42857143, 2.44897959, 2.46938776, 2.48979592,\n", - " 2.51020408, 2.53061224, 2.55102041, 2.57142857, 2.59183673,\n", - " 2.6122449 , 2.63265306, 2.65306122, 2.67346939, 2.69387755,\n", - " 2.71428571, 2.73469388, 2.75510204, 2.7755102 , 2.79591837,\n", - " 2.81632653, 2.83673469, 2.85714286, 2.87755102, 2.89795918,\n", - " 2.91836735, 2.93877551, 2.95918367, 2.97959184, 3. ])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.linspace(2.0, 3.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "50" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(numpy.linspace(2.0, 3.0))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 2. , 2.2, 2.4, 2.6, 2.8, 3. ])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.linspace(2.0, 3.0, 6)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([-1. , -0.75, -0.5 , -0.25, 0. , 0.25, 0.5 , 0.75, 1. ])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.linspace(-1, 1, 9)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Array operations\n", - "\n", - "Let's assign some arrays to variable names and perform some operations with them." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "x_array = numpy.linspace(-1, 1, 9)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "Now that we've saved it with a variable name, we can do some computations with the array. E.g., take the square of every element of the array, in one go:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 1. 0.5625 0.25 0.0625 0. 0.0625 0.25 0.5625 1. ]\n" - ] - } - ], - "source": [ - "y_array = x_array**2\n", - "print(y_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can also take the square root of a positive array, using the `numpy.sqrt()` function:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 1. 0.75 0.5 0.25 0. 0.25 0.5 0.75 1. ]\n" - ] - } - ], - "source": [ - "z_array = numpy.sqrt(y_array)\n", - "print(z_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that we have different arrays `x_array`, `y_array` and `z_array`, we can do more computations, like add or multiply them. For example:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. -0.1875 -0.25 -0.1875 0. 0.3125 0.75 1.3125 2. ]\n" - ] - } - ], - "source": [ - "add_array = x_array + y_array \n", - "print(add_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Array addition is defined element-wise, like when adding two vectors (or matrices). Array multiplication is also element-wise:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-1. -0.5625 -0.25 -0.0625 0. 0.0625 0.25 0.5625 1. ]\n" - ] - } - ], - "source": [ - "mult_array = x_array * z_array\n", - "print(mult_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can also divide arrays, but you have to be careful not to divide by zero. This operation will result in a **`nan`** which stands for *Not a Number*. Python will still perform the division, but will tell us about the problem. \n", - "\n", - "Let's see how this might look:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "//anaconda/envs/future/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: invalid value encountered in true_divide\n", - " if __name__ == '__main__':\n" - ] - }, - { - "data": { - "text/plain": [ - "array([-1. , -1.33333333, -2. , -4. , nan,\n", - " 4. , 2. , 1.33333333, 1. ])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "x_array / y_array" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Multidimensional arrays\n", - "\n", - "### 2D arrays \n", - "\n", - "NumPy can create arrays of N dimensions. For example, a 2D array is like a matrix, and is created from a nested list as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1 2]\n", - " [3 4]]\n" - ] - } - ], - "source": [ - "array_2d = numpy.array([[1, 2], [3, 4]])\n", - "print(array_2d)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "2D arrays can be added, subtracted, and multiplied:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "X = numpy.array([[1, 2], [3, 4]])\n", - "Y = numpy.array([[1, -1], [0, 1]])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The addition of these two matrices works exactly as you would expect:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[2, 1],\n", - " [3, 5]])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X + Y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "What if we try to multiply arrays using the `'*'`operator?" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1, -2],\n", - " [ 0, 4]])" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X * Y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The multiplication using the `'*'` operator is element-wise. If we want to do matrix multiplication we use the `'@'` operator:" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 1],\n", - " [3, 1]])" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X @ Y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Or equivalently we can use `numpy.dot()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 1],\n", - " [3, 1]])" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.dot(X, Y)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 3D arrays\n", - "\n", - "Let's create a 3D array by reshaping a 1D array. We can use [`numpy.reshape()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html), where we pass the array we want to reshape and the shape we want to give it, i.e., the number of elements in each dimension. \n", - "\n", - "*Syntax*\n", - " \n", - "`numpy.reshape(array, newshape)`\n", - "\n", - "For example:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "a = numpy.arange(24)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[[ 0 1 2 3]\n", - " [ 4 5 6 7]\n", - " [ 8 9 10 11]]\n", - "\n", - " [[12 13 14 15]\n", - " [16 17 18 19]\n", - " [20 21 22 23]]]\n" - ] - } - ], - "source": [ - "a_3D = numpy.reshape(a, (2, 3, 4))\n", - "print(a_3D)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can check for the shape of a NumPy array using the function `numpy.shape()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(2, 3, 4)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.shape(a_3D)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualizing the dimensions of the `a_3D` array can be tricky, so here is a diagram that will help you to understand how the dimensions are assigned: each dimension is shown as a coordinate axis. For a 3D array, on the \"x axis\", we have the sub-arrays that themselves are two-dimensional (matrices). We have two of these 2D sub-arrays, in this case; each one has 3 rows and 4 columns. Study this sketch carefully, while comparing with how the array `a_3D` is printed out above. \n", - "\n", - " \n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "When we have multidimensional arrays, we can access slices of their elements by slicing on each dimension. This is one of the advantages of using arrays: we cannot do this with lists. \n", - "\n", - "Let's access some elements of our 2D array called `X`." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 2],\n", - " [3, 4]])" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Grab the element in the 1st row and 1st column \n", - "X[0, 0]" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Grab the element in the 1st row and 2nd column \n", - "X[0, 1]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Exercises:\n", - "\n", - "From the X array:\n", - "\n", - "1. Grab the 2nd element in the 1st column.\n", - "2. Grab the 2nd element in the 2nd column." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Play with slicing on this array:" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 3])" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Grab the 1st column\n", - "X[:, 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "When we don't specify the start and/or end point in the slicing, the symbol `':'` means \"all\". In the example above, we are telling NumPy that we want all the elements from the 0-th index in the second dimension (the first column)." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 2])" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Grab the 1st row\n", - "X[0, :]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Exercises:\n", - "\n", - "From the X array:\n", - "\n", - "1. Grab the 2nd column.\n", - "2. Grab the 2nd row." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's practice with a 3D array. " - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[[ 0, 1, 2, 3],\n", - " [ 4, 5, 6, 7],\n", - " [ 8, 9, 10, 11]],\n", - "\n", - " [[12, 13, 14, 15],\n", - " [16, 17, 18, 19],\n", - " [20, 21, 22, 23]]])" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_3D" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we want to grab the first column of both matrices in our `a_3D` array, we do:" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0, 4, 8],\n", - " [12, 16, 20]])" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_3D[:, :, 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The line above is telling NumPy that we want:\n", - "\n", - "* first `':'` : from the first dimension, grab all the elements (2 matrices).\n", - "* second `':'`: from the second dimension, grab all the elements (all the rows).\n", - "* `'0'` : from the third dimension, grab the first element (first column).\n", - "\n", - "If we want the first 2 elements of the first column of both matrices: " - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0, 4],\n", - " [12, 16]])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_3D[:, 0:2, 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Below, from the first matrix in our `a_3D` array, we will grab the two middle elements (5,6):" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([5, 6])" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_3D[0, 1, 1:3]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Exercises:\n", - "\n", - "From the array named `a_3D`: \n", - "\n", - "1. Grab the two middle elements (17, 18) from the second matrix.\n", - "2. Grab the last row from both matrices.\n", - "3. Grab the elements of the 1st matrix that exclude the first row and the first column. \n", - "4. Grab the elements of the 2nd matrix that exclude the last row and the last column. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## NumPy == Fast and Clean! \n", - "\n", - "When we are working with numbers, arrays are a better option because the NumPy library has built-in functions that are optimized, and therefore faster than vanilla Python. Especially if we have big arrays. Besides, using NumPy arrays and exploiting their properties makes our code more readable.\n", - "\n", - "For example, if we wanted to add element-wise the elements of 2 lists, we need to do it with a `for` statement. If we want to add two NumPy arrays, we just use the addtion `'+'` symbol!\n", - "\n", - "Below, we will add two lists and two arrays (with random elements) and we'll compare the time it takes to compute each addition." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Element-wise sum of a Python list\n", - "\n", - "Using the Python library [`random`](https://docs.python.org/3/library/random.html), we will generate two lists with 100 pseudo-random elements in the range [0,100), with no numbers repeated." - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "#import random library\n", - "import random" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "lst_1 = random.sample(range(100), 100)\n", - "lst_2 = random.sample(range(100), 100)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[69, 21, 55, 9, 12, 57, 75, 81, 15, 17]\n", - "[57, 29, 94, 67, 51, 71, 78, 55, 41, 72]\n" - ] - } - ], - "source": [ - "#print first 10 elements\n", - "print(lst_1[0:10])\n", - "print(lst_2[0:10])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We need to write a `for` statement, appending the result of the element-wise sum into a new list we call `result_lst`. \n", - "\n", - "For timing, we can use the IPython \"magic\" `%%time`. Writing at the beginning of the code cell the command `%%time` will give us the time it takes to execute all the code in that cell. " - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 36 µs, sys: 1 µs, total: 37 µs\n", - "Wall time: 38.9 µs\n" - ] - } - ], - "source": [ - "%%time\n", - "res_lst = []\n", - "for i in range(100):\n", - " res_lst.append(lst_1[i] + lst_2[i])" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[126, 50, 149, 76, 63, 128, 153, 136, 56, 89]\n" - ] - } - ], - "source": [ - "print(res_lst[0:10])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Element-wise sum of NumPy arrays\n", - "\n", - "In this case, we generate arrays with random integers using the NumPy function [`numpy.random.randint()`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.random.randint.html). The arrays we generate with this function are not going to be like the lists: in this case we'll have 100 elements in the range [0, 100) but they can repeat. Our goal is to compare the time it takes to compute addition of a _list_ or an _array_ of numbers, so all that matters is that the arrays and the lists are of the same length and type (integers)." - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "arr_1 = numpy.random.randint(0, 100, size=100)\n", - "arr_2 = numpy.random.randint(0, 100, size=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[31 13 72 30 13 29 34 64 26 56]\n", - "[ 3 57 63 51 35 75 56 59 86 50]\n" - ] - } - ], - "source": [ - "#print first 10 elements\n", - "print(arr_1[0:10])\n", - "print(arr_2[0:10])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can use the `%%time` cell magic, again, to see how long it takes NumPy to compute the element-wise sum." - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 20 µs, sys: 1 µs, total: 21 µs\n", - "Wall time: 26 µs\n" - ] - } - ], - "source": [ - "%%time\n", - "arr_res = arr_1 + arr_2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Notice that in the case of arrays, the code not only is more readable (just one line of code), but it is also faster than with lists. This time advantage will be larger with bigger arrays/lists. \n", - "\n", - "(Your timing results may vary to the ones we show in this notebook, because you will be computing in a different machine.)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Exercise\n", - "\n", - "1. Try the comparison between lists and arrays, using bigger arrays; for example, of size 10,000. \n", - "2. Repeat the analysis, but now computing the operation that raises each element of an array/list to the power two. Use arrays of 10,000 elements. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Time to Plot\n", - "\n", - "You will love the Python library **Matplotlib**! You'll learn here about its module `pyplot`, which makes line plots. \n", - "\n", - "We need some data to plot. Let's define a NumPy array, compute derived data using its square, cube and square root (element-wise), and plot these values with the original array in the x-axis. " - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5 0.55\n", - " 0.6 0.65 0.7 0.75 0.8 0.85 0.9 0.95 1. 1.05 1.1 1.15\n", - " 1.2 1.25 1.3 1.35 1.4 1.45 1.5 1.55 1.6 1.65 1.7 1.75\n", - " 1.8 1.85 1.9 1.95 2. ]\n" - ] - } - ], - "source": [ - "xarray = numpy.linspace(0, 2, 41)\n", - "print(xarray)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "pow2 = xarray**2\n", - "pow3 = xarray**3\n", - "pow_half = numpy.sqrt(xarray)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To plot the resulting arrays as a function of the orginal one (`xarray`) in the x-axis, we need to import the module `pyplot` from **Matplotlib**." - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from matplotlib import pyplot\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The line `%matplotlib inline` is an instruction to get the output of plotting commands displayed \"inline\" inside the notebook. Other options for how to deal with plot output are available, but not of interest to you right now. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We'll use the `pyplot.plot()` function, specifying the line color (`'k'` for black) and line style (`'-'`, `'--'` and `':'` for continuous, dashed and dotted line), and giving each line a label. Note that the values for `color`, `linestyle` and `label` are given in quotes." - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW8AAAEACAYAAAB8nvebAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5C2EEDZIkrcQQtggSd5CCGGD/j+RWiKuPrsMFQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#Plot x^2\n", - "pyplot.plot(xarray, pow2, color='k', linestyle='-', label='square')\n", - "#Plot x^3\n", - "pyplot.plot(xarray, pow3, color='k', linestyle='--', label='cube')\n", - "#Plot sqrt(x)\n", - "pyplot.plot(xarray, pow_half, color='k', linestyle=':', label='square root')\n", - "#Plot the legends in the best location\n", - "pyplot.legend(loc='best')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To illustrate other features, we will plot the same data, but varying the colors instead of the line style. We'll also use LaTeX syntax to write formulas in the labels. If you want to know more about LaTeX syntax, there is a [quick guide to LaTeX](https://users.dickinson.edu/~richesod/latex/latexcheatsheet.pdf) available online.\n", - "\n", - "Adding a semicolon (`';'`) to the last line in the plotting code block prevents that ugly output, like ``. Try it." - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW8AAAEACAYAAAB8nvebAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#Plot x^2\n", - "pyplot.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n", - "#Plot x^3\n", - "pyplot.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n", - "#Plot sqrt(x)\n", - "pyplot.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n", - "#Plot the legends in the best location\n", - "pyplot.legend(loc='best'); " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "That's very nice! By now, you are probably imagining all the great stuff you can do with Jupyter notebooks, Python and its scientific libraries **NumPy** and **Matplotlib**. We just saw an introduction to plotting but we will keep learning about the power of **Matplotlib** in the next lesson. \n", - "\n", - "If you are curious, you can explore all the beautiful plots you can make by browsing the [Matplotlib gallery](http://matplotlib.org/gallery.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Exercise:\n", - "\n", - "Pick two different operations to apply to the `xarray` and plot them the resulting data in the same plot. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## What we've learned\n", - "\n", - "* How to import libraries\n", - "* Multidimensional arrays using NumPy\n", - "* Accessing values and slicing in NumPy arrays\n", - "* `%%time` magic to time cell execution.\n", - "* Performance comparison: lists vs NumPy arrays\n", - "* Basic plotting with `pyplot`." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## References\n", - "\n", - "1. _Effective Computation in Physics: Field Guide to Research with Python_ (2015). Anthony Scopatz & Kathryn D. Huff. O'Reilly Media, Inc.\n", - "\n", - "2. _Numerical Python: A Practical Techniques Approach for Industry_. (2015). Robert Johansson. Appress. \n", - "\n", - "2. [\"The world of Jupyter\"—a tutorial](https://github.com/barbagroup/jupyter-tutorial). Lorena A. Barba - 2016" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" - ] - } - ], - "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.6.7" - }, - "widgets": { - "state": {}, - "version": "1.1.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/5_Linear_Regression_with_Real_Data.ipynb b/notebooks/5_Linear_Regression_with_Real_Data.ipynb deleted file mode 100644 index ad94b7d..0000000 --- a/notebooks/5_Linear_Regression_with_Real_Data.ipynb +++ /dev/null @@ -1,1246 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "###### Modified under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2020 R.C. Cooper" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Linear regression with real data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Earth temperature over time\n", - "\n", - "In this lesson, we will apply all that we've learned (and more) to analyze real data of Earth temperature over time.\n", - "\n", - "Is global temperature rising? How much? This is a question of burning importance in today's world!\n", - "\n", - "Data about global temperatures are available from several sources: NASA, the National Climatic Data Center (NCDC) and the University of East Anglia in the UK. Check out the [University Corporation for Atmospheric Research](https://www2.ucar.edu/climate/faq/how-much-has-global-temperature-risen-last-100-years) (UCAR) for an in-depth discussion.\n", - "\n", - "The [NASA Goddard Space Flight Center](http://svs.gsfc.nasa.gov/goto?3901) is one of our sources of global climate data. They produced the video below showing a color map of the changing global surface **temperature anomalies** from 1880 to 2015.\n", - "\n", - "The term [global temperature anomaly](https://www.ncdc.noaa.gov/monitoring-references/faq/anomalies.php) means the difference in temperature with respect to a reference value or a long-term average. It is a very useful way of looking at the problem and in many ways better than absolute temperature. For example, a winter month may be colder than average in Washington DC, and also in Miami, but the absolute temperatures will be different in both places." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAoKCgoICgoJCQgJCAkJCAgJCgkICAkICAgJCAkICQgIChwLCQgaCQgIDSENDh0dHx8fCAsgICAeIBweHx4BBQUFCAcIDwkJDxUVEhUVFRcXGBUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFf/AABEIAWgB4AMBIgACEQEDEQH/xAAdAAABBAMBAQAAAAAAAAAAAAAAAwQFBgIHCAEJ/8QAUxAAAQQBAgMFAwYJCgMFBwUAAQACAxEEEiEFMUEGEyJRYXGBkQcIFDJCoVJUYpKUsdPU8BUYIzNDU3KCwdEWF+EkRJOi8QljpbK1wtKDlaOzxP/EABsBAAIDAQEBAAAAAAAAAAAAAAAEAgMFAQYH/8QAOBEAAgICAAQCBwYGAQUAAAAAAAECAwQRBRIhMRNBBhQVIlFhkVJTcYGhsSMywdHh8EIWM0Ni8f/aAAwDAQACEQMRAD8A4yQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQsmtJ2Av2K3cA+TfiWSA4QGGI/2uQe4bXQhr/G4erQVXbdCtbm0vxZdTj2WvUIt/ginoWy3/I3mj/vGD7pJ/3dYf8AJ/M/GML8+f8AYJb2jjfbQ77HzPu2a3Qtkf8AJ7N/v8P8+f8AYIPyP5v9/h/nzfsEe0sb7aD2Nmfds1uhbFd8kWYP7fD/AD5v2Cx/5S5n99ifnzfsUe0Mf7aD2Nmfds14hbD/AOUuZ/fYn5837FH/ACmzP77E/Pm/YrvtDH+2g9jZn3bNeIWw/wDlNmf32L+fN+xXn/KfM/vsX8+X9ij2hj/bQexsz7tmvULYP/KjM/vcb86X9isHfJZlj+1xvzpf2SPX8f7aO+xcz7tlBQry/wCTPKH9rj/nSfski/5PMgf2sH50n7NTWZS/+SO+xM37tlMQrh/wBkf3kHxk/Zo/4AyP7yD4yfs0et0/aQexM37uRT0K4f8AAGR/eQfGT9mj/gDI/vIPjJ+zR63T9pB7Ezfu5FPQrh/wBkf3kHxk/Zo/4AyP7yD4yfs0et0/aQexM37uRT0K4f8AAGR/eQfGT9mj/gDI/vIPjJ+zR63T9pB7Ezfu5FPQrh/wBkf3kHxk/Zo/4AyP7yD4yfs0et0/aQexM37uRT0K4f8AAGR/eQfGT9mvf+AMj+8g+Mn7NHrdP2kHsTN+7kU5CujPk7yD/a4/50n7JLM+TPJP9rjfnS/slx5tK/5IPYmb93IoqFsBnyVZZ/tsX86X9il4/khzTymxPz5v2Ci+IY67zRH2Nmfds1whbPj+RXPdynwvz5/3dLt+QviJ5T4P/iT/ALuq3xXFX/kj9Tj4Rlr/AMbNUoV17R/JhxTEtzsZ00Q/tcc9+2vMtZ/SNHq4BUxzSOY+KbqvrtW4STXyexK2iyp6nFr8UYoQhWlQIQhAAhCEACEIQAIQhAAhCEATXYjgTs/Nx8FpozSU5w5tiY0ySvF8yImPNeismd8m8n8rTcIjlZEQGyY0mT3mmSOd0bceN0kERaJS6Zkeo0C4Fotxa0rfNwi18ewWc9Tcwf8Aw7KU385fIlxeNO7mWWBx4fDG50T3ROdHJrLo3FhssPVpSjyH6yqf/Xf66HVTD1XxPPm1+Wig9o+yc2HjYeZI+FzM5jnsZE5z5IQI4ZWNn8Olj3RZETw0E7E3SrydZnEZpWsZLNLKyMyGNskj5GsMz+8lLA400uf4iRzO5TVNiQIQhAAhCEACFlGwkgAEkmgBuSTyFeav/Zb5O3PAmzHGKPYiBpBmcPyjyjHLzPsVN2RClbmxzDwbsqfLVHf7L8WUjh2BLO8RQxvlkdyYxpcT60OQ9VsTs38lLzUmdMIG8zBEWyTH0L/6uPpuNSumA6HGZ3WLEyJnXSPE6ur3nxPPtSc2U93MlYeRxO2fSv3V8fP/AAe3wPRGuGpZD2/gui/ySXBcLAwQPo0EbXgf17v6Sc+f9K7dvLk2k4yOOk9SoArxZUqeZ7m238z1VOJVUuWEUl8iWdxYrwcVKiliXdOq6qY/AvaiibHFkO4z5kD3qAd4uVn/AAmvutLcOwC47a3GwOQBp/mXenku+r1pbYvOzXZEzHxLULFnn0O9cwB19yzj4gCAb+tVXt/B9Fl/I2wHjBYR/aCM2/ZwDfrOGne/ytlaeF9kzs8+LYvs2A2IWR9WiR1v1dzSdttMEJWZjT0tFWbkSFpNCN2otY14c6yNubfXp6hO8XHnc3UbGxFDSHa29Ghw8R9hV84P2Rc2Nj+6k0PNNIZJI9zXAVKRHbwwuLfr77hbA7Edi8d4eGuY6aJxjydT2Ola9mxElGwLN0PM9bSzyXLpVByfyWzLu4rCH80jTHDuEvfTSHa/DqDnFhF8vACSDvVGuSl8PsfkHdxr0aCf/mcRyW9W9kOHRu1vc1shrUY3PYTp5ajG4Xy6+QUdl5+FjcQxsfX/ANjyMXKfPLNJbYsmOXFZisa+V9tL++yBo3vuRVUU0uEcTtXNGvX46MqfpNUnrezUsvY6SvrOB8w1v/3NpRWf2SIOovl5fVDg1vt8ItdOP4HBKLjIPp1VS7Q9nKsafuWRlRzcKWrotDuLxyu9nOXEeBUKt+3XU4n7yq3xfDMQ7wvpo/COxPQe1bt7T8METS5w60G20Fzt6aC8hurbqqDlcIdlPA7p8Ihdb2y1btbfCQ1p328/P2J7Cz21zS7G08yOtR7+RR2RvoFwA9ln/RZUr7k8B9E0HBPRN+vwZpQtSXcqLMdx6JB7nA6dDg4k6Q7w6q516evqr9HwmuiSyeHDqAaNixe/n7VyOdHZGdjf8rKNBrd9gt52CfEK/Jrl/usyCOYpWfJx/TdQ+fCmI3KfZFlbeurI591tRPqaHxASMve0NPdg9dWoj2Ch5JdCvT0SnDm8zGPV10+6/wDVZJtG5znHo3mCD05VQ+1YvflYS7Wgf6ldktEa57XT9TIJORzgdmgiud1R9R5V1CDLW5BHwseux39ySLnHTpIaL31g6iPyTyBXYxI2WLXRiwlrmCPvHxTiDK9b/Wmn0Ztl3i1HmdTtx5UDVf7pTQPIX7FGSiyUefz0S+NnqWxM4KnAO1WBTeRBPPfYgcgl45nD/of91RZjJnOkvI2DiZgUvi5YWssXir2/Wb7gQSpLE41yIkrqNRO/u5Devis67h7KJw32NnQ5DSoTtV2J4dxAH6RjxukI/r2Du5x/+qzd3Pk6woThXGtQ2fyIDvquBI51pFqexeKNNDUAegOx9wO5SHhXY8uaDafyEbcaFsdSSa+Zpbtp8hs8WqTBlGQwbiCbTFOBtsJP6uTrudPsWp+KcOmx5DDNG+GVv1mSNLHD1ojl6rtETagojtL2fx8xndZELJm76dQ8bb6skHiYfYt/B9JbYe7kLa+K6P8AsedzPRqufWl8r+D7f4OO14trdu/khmh1TYRdPELJx3V9IaPJlbSjn5HlsVqyRhaS0gggkEEUQRsQQeRXsMbLqyI81b2eQy8K3Gly2LX7P8zBCEJgVBCEIAEIQgAQhCANofNVj1dpeGt8/pv/ANNy1avnQ42MO0mRHlahGOCudEWvEdZbOHzy4gd4DrYclsTNIq9Y3CgPmexau1XCm+bs3/6XmFTHz44tHaadtURhYX/9F/6rOdT9dU9dOTX6jHifweT57/Q1z2y4fw+LD4c7FlEmc9uQOJNEneNa9vcd3po6a1uyWWALEba1CnuqSe8M4VNOJXRMLxBC6aY20BkTBqc7xHxHSHHSN6a49CnvEOyXEYIG5k2BnQ4b2xuZlS4uRFjObMA6JzZ3x6HNc1wIIO9iloi5CoQhAApXs7wKbMk7uJo83yO8MbB5udX3BWDsJ2Fky6yJtUWGDs6qfNXNsQP2ems7e1bHfBFEwQQMbFG3lp8x9ouu3O2G58lmZXEY1vkh1f6I9Lwf0dsyv4lnSH6v/fiRXZ3gmPg7Mb3uRsHZLxvZFlsbT/Viuo8+akcjIJ5m/ifTYDmkmNsVsehO+9bdTZ9pWYFbk+3c195WLZJzlzS6s+iYuLDHr5K0kv8AfqZV/HILwsB6D/1WAnbenUNXRt7/AA9x+CUtQ00NqUZdjHQPX13P+/NeFp/CNewX8SKr/dZoRsORCYi83OJ87rrY2ApelpA2O9Vv/vSzWUbbICOZnPDRhw3DlLmAMabJBcHO0t2uyK3HT3q9cI7O5Dg0Ax2HaurQfwQTpLgP8PmU37OQgUticEeG1pY57zWljdIPlZc86Wt62fLazssbiGdJPUUZmUuSLW2K9luycrnAyyNiLg+OOId2C41oa+NxFsvZ2kWdmet23gXZzHuPFllbJlYkLrHj72dkTO5HemD+jgYZnsdbweTwBsSpvslwl8rAyeRp1V4GsjfGDsQXF0YdI8OBNjT0281O2hlhNtIjc9vdRxtEYjcWtAj1gN7xxABdsTsx29bJ30b4XHiNjla+i8kfPuL8SnB6RB9os04IYcfJmkyItJZJO8OikfpqRksTG7scPssG2kkUarXvyh9tpJnwvZKzHyw4ONEtfJGK1xCVg8I1aPEQb0tHsje1MMokZJqeJBzc91wy2WteyTSDokN2Hfkn1VYm4dLPOBIG92xxdysvjeCGwuFkOb3jdV7f1TNvL65h8Lx8eGq4JHi7suc3tsseN2xmyBruRpstc0m6c3ZwDgdLhdix5FRfEc2fLyBi0Xw6WNyC5xpgeS+2sLNJfprcn7TNlYeDcDugBQ6ADYDyAHIJ9LwmHDyvpU5McMuI4GZxLceN2MdbxKQdOt0TwQXD/u8gscjoXcqik/zFa+ZvZsPsZxaW2gk/FX3+VMbIDo2PjnyIzofFC5kkrXGtpADUYpzTb6WpcMCd/dMcw4kZjOS9pLjM4/0gxAR4Qyu7c472Hhtbq7YvHWRANbpY0V4WgNGwobNFcqHuWDxThtedHklHaNLFvdXXZ72j7HmcDvo4Rp8WzpJGhxbTjyaHN3cPF8FUouC4YbrimikDyR3neNeXll+FtHcAEkNbtvtzWwcTtO140uotcCHA8iCKI+Ccdn+EY7Iu5gPdx63v8LI+81SPdI4awNJbbq3BNAbr53xD0Ntqi3VLp8D0eJxtpmq8ngTXN1DS5pvcbg0aP3gj3KHyOEhvTl0W3eK8KZEHNaPtOc4klznOduXEnr/sFQeKPGkOcO6ura8ttpcdIa4tdp1WQKHmF4WfPXNxfkz12Fnu1FRyYWt6Kpdq+ImMBkIY7IffdtfdU0jW4gEeENPn1bzJpWHtnxPuGsput8sndxtvSNQY+QlzgCQNEbjsCeSpWZE9ru8leHyuaBbWljGhtOLGNJJa3Vv66W3yWxgU71Of5fM1lJ2e5Hv5v4f5I7Kx6GuaQyu+s5rnOEId5MjaQ0N9HWozJLAfBbdq8FBpO29HbkAFjxfILiQS0BsjQLFmzQvfa7dt7kg6gALryHUm728za9DXBpbY7VTCLf7+YNkve/iNJ/UvC8nYeXP/AKL10YJvcH0KyaK2/wCv61ZtDSUn0Yn3Zu6b6mjd8rsL1jDRBN+7p70ohc5mSVaEpDQF2T0IaT+dpFAe1eFljSRbTR28JBBu6Bv12SyF3mOeHsAhCFAsBCEIAEIQgBSKZzeRUnhcWI2d/wBPvUQhRlWpdzjimXrhnEmnehfsFqexJNW+p1Vs3wUPUW279vktY4OSWkb7K4cFzLpZGVi8vVCltC7osbsG99biPIkfdp2+KpPb/wCTjGzgXEd1kgeDIY0WdthK0D+kb7d/VXzFn5CiSQTQrkKvmfUfFLxlshc2qq9P5QFaiARtRIHxSNGXdjy54PWjMvqqsXh2La+Zxx2u7L5PD5O6yGUDfdytt0UgHMsfW/sO+4UIuw+1HAcfIYYZmd8yQ6e71OI1aSQRRqNwAJ1bclz38pXybT8PJnjDpsIn643fDfITAD6vTXy9hpe84XxuvJShPpL9H+B4jinBJ4+51dY/qvxKAhCFunnwQhCABCEIA2/8zSQN7W8IcdgHZt//ALXmK3/O64rDB23izZWGXGxzwfImja1rzJDB3ckkYZIdDiWscKdtutefNgm0douHv/B+mn/4blD/AFVv+cXwd3Eu00cPfQwiePhuOZZHtcWuyHOhYWQsPeznVQ8A2sai0bq3w/4fP89EOf3uX5GsflC7SjJyzNjzZDwcHGw8nLkuGfiDoYI45p8hjZCSHPjGzySRGwu3un3ysdqcbNkjbj4+NTMLhEb89oy25csuHwXEw54ZGzT9yIxPE9vgYL7lhvc2w4h2Lki4TDxp8lCfMbjtxzGWkMkjyJGTd6Xb39GcdNcpIzZvaqKomehbd+S75LHSBudnsLYvrQYjgQ+Tq2SYHdsX5PXbpzsvyG/I+9oj4pn473E6X4eI7Q0AHduRkNkcDXIhleRPkt2ZPDXuBtrWnf7RePQnYemy8hxn0gUG6aH+L/ov7nqeC8JhJq2/8l/c1xxSGhpApoFAAUAANgANgK6Ko52lpp1bnYHqegpbT4hwBxJLnEjo1vgYOX4PiPLqeqhZ+zzG76Gje+Q5+ftWNi5sEurPfV3dNI18A7cta72EAX7quktBhPdu+udgN1BrfTnv/wCit02AxvMBMciVreS0Fl838qLlFP8A3oQj8JrQfCOdnYc+h9uwUHxecxyMa3w959b1GqvPbqrFlTWoDi7aLSXNBMzdNjlGG72a28e9/wCFOYr3L3hfiMWqfd6dUSgKEA3uhVM0IvoCVxh4kkFIYGOeahN6QN6LFwQ8le+zsrmkuolp08iCRQokNqyK6ehVK4RAdle+zzKpebz5LqZmXpo2p2Tzmga9QIaNR0+IgAWdm7k7HYKQYz6aBlCOaNj4g8RztLXxySb6ixw1MmMbnNLXXpDY6qyFTcVkpc1jGgskMbZXUBphDnPm1OJ3toDdIHN7egNbP4VnN0hh+r0HQexaHo1xSGDb7z6S/Q+d8XxnOTNTdr+yxe5pBLSxxds0OuxpIN/klw9/sVPwuAGLPhgLXn6TjSuMrxs+bHkYWxh/Iy6JpT3YHJhrYbdHZuBE4aiWgeZIH61Vu0vB8V4cybXKxsZcYIBqc1102QyM8TH3yFi9LjRo19dp4vXZDmi19TycsNp9SP4B2YDaJH3J9xXBaxp26VX+itHBcSRmPCJd5hBH33If0mga+QA+tfRV/teaaVKrJd0zs6VCJr3Onjgb3cTGRRjUQyNrY2DUS40xooGyT7yq1l8YdfNZ9pJnFx9qrzY3EreqrSRlWTbZa+EcUdY3W0+w2cXVa1V2e4W5xGy2/wBieEloBKz+IShGD2N4ik5D/tlsxz9r0XuaGw6u6D1Wh8PikuT/AEmQAHMnyIXQsa7uGyY8oDZdTh4iQyN7QTt3p8rW3PlNjdM+Fmgy4zRL37NTRE4juzCHsLwS4SNDw8XXdu2sgjUvE2sbLK0nTTdOxDre8teSZL1veHVVgVuvgma63fY49dv6dz6NwiMtLZDdqYWShodzjlZLGd/DJHu12x3G5FepVC4plt7028WW0Rfm46SByZ9Vwr8oKycd4g8gBuoOvxu0htAO01TrokkbiwKdZVW4jgxglxHitxMl6XW9xLjba6k/FPYEOWOpfkevri29wS8t7ITLjDnOc4ahRrUOQHKmkbc3c0jFEAACL36iifcNj7B5JzIGuq9zQu7u/Ufx0WDRROx25b9D6E87BW2pdNDqqW1IUBQsLN3W1ctrJ8/gswbVbQ0mCELEP9DXn/G9I0G9GSCf+iTc6yKJq9+Yvy9efVZ6R5e1d0cUt9j1CxDPV3puf9efvXpdXP8AUVzR3fxPUIC8BB6hB3Z6hYtd7lkCjRxMEIWLL8/P2bGuiNBs9caF+SmOBSDZri7lWznD28iohovb4hP+G4dfVJbY2/BaT5BV2pOOmV2LZsXgjW2HW7bkNbqF1Yq+XLblsFZ4sTvNV/VcxoH+Uk+/xEfcqT2WmNBruY2vzrb47X7wth8GbdD/ANQvKZu4TMjIS1tCUOAK0V4mDnXO78VgbE0fvTLM4UHAgtDmuBBBALXNIogjkRSteNj3Np2sQaiPTWA13PYHxCvyCpD+R2kbNAvyFfq9p+KS8WUXszlmJdH2OQflh+R90OvP4ewuh+tPiNBc+LqZIQBbofyeY36ctKlfRufgjrsVp67HVe+93RHLb2rnP5wfyJvHecV4dCdrkzMSMAgitT8iBg387YB0JC9zwL0j8RqjIfXyl8fk/wC55nivDoP+LR+a/qjm9CEL2h5wEIQgC/fN9k08bw3eTMz/AOn5KkfnLy6+Kh3nhQfc6Uf6Kt/JLxKPH4pizSnTHc0RdYbRyMeXHYS5woDXK3c+qtPa/tPg/wAtfSJY3Tw40ccTXFmNnQuc2KV0rJsKYBmQ3vZhH4Xtru3OBJqmlJeBrz5v6CzT8ffly/1NWEron5rHyLnNLOO58f8A2GN5ODjPbYypWGu/kBG+M110PtOb5Ahx8iXYTB7SPGJDhyY+FicSObxDMdFAyV+LJ9KdFw9mWx/ed4deNEImBrQ3Elk+s4NHa+BwZkUbIIY2RQxRtjiijaGRxxxtDWRsY3ZrA0AUPJeP9IOJTrh4FP8AM+7+C/uzVxIR5uaRVn8M9E0yOF+ivn8mHyTHPwaB2XzqzDtgtyTN+viHXWzWnE8EC9lS+OU21s3tDDVrWnaKI7oxX73U9Pg2c62yh8YyDuq7K8kqycTxSSUwZg9SvV0TjGJvwaSIruUy4jj2NIHipwB6C2kb/k7/AKlYZYQFGZI6+f8AFJuq3rs7OKsXKxjjwBrQ2yaA3JJsgc+eyVZHe2/xKVihJUvw/h91su2W66s6oxgtIaYPDr8/iVYuHcK5fW+JT7hvDuWyseBgeixsnN+ArbaiKxsGRu0YJGhztb9DmtcOTd3h3Xr5Ke7NZbGmnSlw0tcXP07PeQNDXRtAO5FCr3FJ79CBbo0gh3hcCARVH6wOxbYGycNxfE5jIvCBydTIi5xEmsFos+OnE8yQPK1lyuVi1IxsmyW+hbOGy0AQdqsG+YPVSX8sBgO4Ja0uI1UA0C7J6KmueyBuqaS2UGNYRUVgbBkLebqbyA6FINmEocS2SOMPc0QkGBkgDdJe9oAe9h1uGl23hG3VJKtLr5GdOjxH8y0cR7WwiZ0eQ9hjjjEjKDtLJHeH+llYSY5QORFf1hUrxPiUk8YLIop45mRtGPkPfjCON4a6Rz9LNQl2G/MaW1W6oOC1kdfacAPGQ27aKaQ0DS0+oCm8Tim/NNLNnVrw2/qKz4Qn1ZsTsFkSsxIYskgzDWX07Vp1yOe1mr7QDXNbf5ISnazhxe0kb2FW+GcWG26tnD+KNc3S7cea9V6P+lDqs5b30/Y8/n8MaXRGouM9n3Fx2PPySHDey7i4eH7lumXhsL9wWrKLh0LN7avpX/UmNyb519Tzvs6W+xWuzXZgNAJH3Kz5UrYmaG863KTy+JNaNLNh5qu8R4jzXzz0i9K/HTqpfTzZuYPDdNNoZ9oMmwVqrtO0h+ou/oS8U1tM0ONNbq0tt4Mh52K1D2q3dp+IvAbosguIfp0d4GhjnW3vDp5trfzVS4wHO5vtux0uYOjtQstOx2r3LxFG0+Z+Z7bBp5VrRT+ORgggtBaOTa8vL1VSzi4girFWXknbfatYBd7R6K55rHvJrSG1z3eHXd8625cvNQj8bdzObWBoO51crDgKraqr0XoMWxRXU3lL4FTkh1GwSRtRO9k+Wn2j4rKLDeeR2J2sEny8/RTR4XRJZo7uidJH2gdTjE+/CdneAjmU8ZjNBJcSwHoPF4gXaumx2WlLJXkShel/MVqOA73fhNOIFgbHc+lghKPwSSGgG73OwoDc7c62r3q2cPx2OuvE47lopx08m7jbp19U5PDWj7JYfwq3P+YH7il5ZqTJK9tdymTYBr+DuEz9xoHTe2m7ra+Y9it+TjloN06uul7QdruwKv2eRUXJiDamkFoOnUCCWkXp9dqHuV1WRtdS3xuZ9CDldp3P/r7AvQU7yMe/s89JHSqOq9QH3JMYx6WPQj+CQmOZaLVZt/IQQlJIiK2NnaqP8H3Lx0Lqvwm/ab/3QiXiR7CBbZ9PMHny2KzHka9PL4FZRwuA+rXp+r31Sy7gn7P3LrkgivMwAXhCWGK/oPivHQPH2fh/1XNr4ktrzEi0fxv+tYsPQDbzGw/6pU47j0rrvz+FUnOPim+SHJJEfwMsDE1FWTC4aQAbFWBy3NmvZaacOgogbWeQ6n3Kz4jXOADGsc4PA1vB0NJIbtX1neLkPI8ll5N730Fsi3lW0GFw8gmtjTTtYvc+W45D4K7dmZLa0+L/ADc/iOaj8HDINmtRobXQA9vtJ96eYmM5xkgbcT3DVHI0uA0nbUADRIIurB3NLCus8TozJybemy+cBp7nEbtDWM1D6pcNTiB57ObuPM+SsePiKD7LwhjGRCgGNDRQDRTRX1RsPYFbcRo2S1UFOWjyeXY4swHCdQ5JvNwYjorPDVbL2166n0brtrUoy6mV67OLODvnafIgcFz+O8Pj/wCwSPBzsVjaGJM8138YA2xXOIsfZc7yIDebF9euJcNhyI5IJo2SwzRvimikaHxyRSNLXxvY7ZzC0kUfNfOH50HyRP7O8R0xB7uE5mqXh0zjqLQK7zEkcd+9YXDc8w5h53XqeGSthHwbntrs/iv7iVum+ZGo0IQtUpPU+7P8JmzMiDCx4zLk5M0cEEbeb5JXBjRfQWeZ5bpgutv/AGf/AMnIfLP2lyGeGEvw+Gahzmez/teU0Eb1E8QhwP8AazjmFTkXKqDk/wDWditvR0z8i/yeQcC4Zj8Lh0uewd5mThuk5OZIG99OetbNYAeTY4x0V1oBejkkpFm4mLGb5592WzlpaRkJUz4wwabTiKNM+NTCtPkkvSPwoYzXTZZjbciidoo+a11xzGu1snjjwbVI4sBuvmdctSPecNk0ig5+H6KKyog1WfiVbqrcVl5rdxpuR6KptkLxJ9B3sP6lHE2VnxCa7CaYTiDRs1W/ofP4LdrhqOxn+Xqyc4di3WytHC+H8tlHcDjBrz8gDf5vNXrhGICARyIse9YubkOPQVvuSE8HBqtlLQY9J1BjUlXR0sOVjkzNnbsSZslRIkXGk0d/SgggiNwI03TntIINkbtbVHbf2clFL4lb6jfs9LK6ITyv1ySF7mhrrYyN7yWNaGnT9TSNr+rz5krZMyX7sBoa0BrQKa0CmgDYADyTOdqslLmk2SpgooamcpXHyT5pCSNYtCs5UxnSZYcDPI6qx8N4qfNUWAlSuFIUtOGhK/HjI2HjcV25rOfOcdOl+kAkubQOvybqP1W8+XoqthyFSDXlRVkl5mNZhxTHs+aSBexoWLujW4ut1EZ+Tz3Sk7lEZrzvYoDkbuxXOum+3uUe4zRSkyG49M8kFup2zmuaNO+rT4rc4b00jb8IqEz80ObbeRH1nW1gHUl1fqUlxCUkkDysnyHIV67Hf0UHlBuoAN3BBNAbA2Nz8TXon6UtLZr1w12G0rReqnuNUDRoCyQGjl1qx5BNWt8Rprrcat2nSHBgIBo3WmjYtShSIiOoVu4P1Udg4OBaNx9WgK3/AAfVORmMPoug1xcDW4l4aQCAG0K1ULJN79Ezy+FysfHTO9ZH3pDQwl5icWhrA8g6pQ1zhvVgOu7Vtw28g4BrugsEH/Cev/VOZYGuB1sDowSfMgtsatNeh3G6hHMlGXyFrkpLuVvs82o+7ex7ZI3aHHu3APA3Y9pA38BaaO43T2dzRQ3JOwprjZAsiwOdfqKlg6NjfCWta3oBRrl9WrUVkuZbXRFrm6nPkLCCfqGr39Dt6KHP4km9MITcYpbIjirdQLRG9xrUCC1nI8gS4OB2I+Kh5cMDS5pL2tFAO3IPmNtnAWKVikfvvYcdqIoUCaq+fO90wkFEjzLnA+02QfWz+pO1WNLQ5DvtldOMRYA2snxX1NkAdB/uvG498xpIBN9K6m+Vbjmp3uwV4MUW0kAi63A5mqP3V7016wM82kQ44WX1ceoEUCTQ6USNVj3eQTiHhu/9W7QPC55rS0tsbEnVp5hWnHxwBZ9gFbk+QA3J9ikY+GkMBNkjxPDTpLtV6gD7T/5Qlp57XQUss5XtFQPBfRZs4J6K8w8KDXBgbTS0kcq1A70LsuIN/wCVPmcIHklJcQkjvrhr5vBPRJy8F9Fsr+SvRN8jhnooLiMtnFmbNZv4T6LFvD66K9ZPD/RM34PomY5zZesjZVzgGrOqtQOoHS4cwGChZsurbzU7w+B8boqb/RPlYLc63QPe0inNcacwvptg7GQUFI42EDsfbfUEbg/FO48VszHwO7xhBaHObqjcCCHMljd5amg2L5KueVzdH28xHIfwJ3EhsXVb6T1o2BX3j4hPMeJznPDRTWMIDxRt/geNIB5jfn/qqxm400ETIopCIiypMiVxnk+klrtEknfXqjL2sHXd8W1CjYOCcIAYI5pJJQWPa9hedLjLo169ADZd49rA+u/ajQRlXCK5ub8DIttnL3dFz4ZsQRyO/wAVZMWXZVvC2AFVQAAHkNh91KWx5dlRVPlZj5UeYnYMyvYnjMtpVaMyybkLZxuM209EzOliplnEzfNUz5aewuPx7heRwubS17x3mHkEajjZsYd3M4614nMIHNskg6qRbklLMyStBekNjaZS8XR8qOP8Jmw8ibCyGGLJxpnwzxnm2SJxY4XyIscx6Jgurfn4/J+GyQdpIGbTFmJxPSP7ZrKxclwA2uNhiLjt/RQDmVykveYWVHJpjZHz/fzEJw5Xoc8NwpJ5YseJpfNNKyKKMfWfLK4MYwX1LnAe9fU35NezkXCeHYfCoa7vEx2Rlwod5Nu+eY19p07pH/51wZ8zvs+MvtFjSOAMeBFNnvBFguhAigI8iMmeB9/kLvx2T6rzHpLxHwrI1L4bf9P9+Y1i0uS2T7ckLGTOYFW5M6uqj8vioaCSdvifgNyvP/8AUN0VqI7DBcizZfFfLZV7iPEOe6hcniwIsOBFkWCCLBIIsdbBHuUNncT9Vj5ObbkPc2a2Lw3XkOuK5vNVLimTzWfEM/1Vf4hlWoU1bZ6TGx+UY8WyOaqPFpeam+ISWoDOZa9BiQUTYqjogJjZSuKw3z0ivrVY62K/wlyVfiEnkpbhuASNPKyOl8jdexak7VFFl3WDLb2XjsCxRuiPIj/Tr7wrrh4+lpcCfDb9O1VdvGw32vn5qrdmsfRo1fWcAHC9tTRWoC/8INfkq8YWy8nmT9/p2MXJk2jCHVKXaXBkLSGhzSO8kc0nXR5Ni5Cxuady2tnxPg7XvY58kz2MLiIC4d0dTNBDw1uqVvWnk72pLAAaxoHUaifNz/E4/nErDJmbemwD0BIB3HQcylVY0/dEIx3/ADERNA1hYGgtbI5zC0E6ADE93hZ9VviYNx5lZ4mQ17iwOGtrWue3ewHjY+zY/BIcTzWOJgDZHOHiIH9GHBhJ2efqt1MPi2Hh5rLAYXPM7C8gOp0JY5jmM7tg0hp2eNYLw4beI0Sr/DbjuRZ4qT0iTc1N5Ik+YWvFtIcAaNdDQNHyNEbHzWQgSu9FqsId+OsRjKeZh2lo8D0XfE0deQkQcOIpPDxFKQcP9FI42D6KDnsVty0M8XH5J82FPosako6JR0Zs79shsmNVjib5Rdhn1m1R8ThvbdJ2DtgOfmVcc1iqnFZBbjbfD4QLq3k0b61yH5ynX3G8eWysZbyXb+AuG5Gk1pIpt3+Udz5poYq5f7kk9SSpTMgDWkAAEMIsDyamwx9Owst95cPfzcE7GS10Nit6GgiSsMPjbtvpd7di3/dPY4R7R6clk6Lcafrjp0o/h7bN2+5c59k52dBxBF0PLqnDohpLeQojbbnz96Tje4GtB2AJIcDzJHhHN1VvdelpR0gqwb/0PkfIpd7F3LbGzn2AfQH4hQudq7yjfd07xggECQtGnldBzDuOWtnuePywGt5/Vb0d5exR+fM17a0l92HNrnG7aQEOI20/fSapi0yfL02Nc9oquigOJRk6TbiGO1aQS0nY7eE7n2qclJotJvTVO/CaRbXe3/YqJy1oUPQ9BKSE8LIFAk+GrD+hA338nV5qZwWCRgc0mnUWkgjcG92uF8xyKgMHHcHHQSGudqc0Bt2frUS4UD578yrRwbDaAwUKcAAW3Gfq3vpO4oH7lLJcYraZVOcl0ZLcGx9QD7JNEdK50aoCxtzU5iwajVeFrhfq4U4CudXR38gmePgjTTXPa6vC7U52kgeFwa86T7CnmBOWue6Xw6SxhcG6Y3F76j076j9Zos7eI+SxpvmbaM66x9iVOEHsc3lYIvy9dt79iWjxyyvD4eRBNxg19mQDU0bfaFcuSWxndE/gcl1LXQzrZMiG5TXaw1gcWODS1rg4+IgB1MFaNwefK004ix7Hf3jdJdJQDdFAm2mt7oinH7KO1fFxA/TG1080hjaYou9M8YkBZ3oEO3dgsjJ1eu+wBcSO72JzrrvbDTR2aPCLs24GibFfXTEq+WKlroymm2TlrZEZcITB8Kc5meB4Xf1llpY3nYNBwBOzDbSL/CCafTWihIWxE1pD3MAde9NN0TtyUYwkbVdnQVggSUGK12YHt5xYrxKATu7Iki7sltUTpxX7+vqlGcSZ3ghY18z9JJ7oB0bPSSW9EZ60T0KdYeE9jtbiS+Z7TK5rnFrS13giDaoQiIvGrqdzuVZHcdt9NroU3WqXYdZDW02M6SZHta1jjQeB43jlZAja416Kax4d7TfDhI5ku3J5AUL2AA9NlKYzP4+7/RKyfkK2zHeMKF+Q/Un7CkMZqdsauIyrZdTAlFpQMXojUtFe0DCnEZSbGJZjFZFMqk0Q/b7s1FxTh+ZwuatGXjujDiAe7l+vBML+02Zsb/8AIvmJxLCkglkx5Wlk0Mr4pWHmySJxY9hrqHNI9y+qwXAfzxOzow+0WTI0AR58UOewAVTpgYpyfMnJgndf5a9t6J5b5p0P8V+z/wB+Rl5kOnMbN+YpwwR4/EuInnLPDhsPkIGGeUX6nIg/NC6Mmz/Vab+bZj/RuA4bSAHTmfJfXUyzvDCfXumRK9ZGcvNcdud2dY/g9fTp/Q9Hw/B/gx38N/UmsniPqorK4j6qKyMxMMjKWXGts2qsVIXkn0ve8EAPrU0CreNtZPnpoe5M8rN9U0nyEymlTcK99x+ulIzyslReTJaUlem0idrgkNRQ0nFpq/HtSBasmRplT0Wp6I6LBtS/DcOq2SuPCFJ4sYVF17K52dB9hQbAirabF8jz2P8AHkp7EnHLk78E7GvPyI9QonHcnRlBFEX/ABzHkVlT6vqZ1sWx1JO9jTTQ4NDi0lxaNIsgGmkgjYbJjHPqlEYb4Wt72R52tzj4BQ2Isk7+Q8knKB9kAE1qu7kA+y93M+0ppjC3lpjAc6nB+o91pZ4GtDWnd4bXQX6KyEVpi8oNFliFjn7dr2TNmFTX6I3ghx0R95GI3B2xAcWktj+0WHbms+HSU2i7Vu4A/k6iACb3Pr7E6fOAFSpOL0iEq+Yb4TpmtaHN1HxB4JjBto8GgsAFbAbjqE+wskmtcZj1ODW7h9k8r0bAb/ceSi/5RYeT2mxY3HLz9ieNlDmFuxJLNNixr1tLCR1GrSfciXV9UQlU4x2mWTHgtP4cNJcMcDX8fqU7DHsqYx2ZN9zi9DGPF9E5ZAAnBYsHGlZy6FHY5GJam+VK1o1OIaLAJJoeIgDf2kD3rKWZNJ5bBF1YIvbr1o7fFRbROEGxtnuvl/H8bqq5MLQ6TZtmTWBTbFsYXV1+tbr/AC1YJzQq75myALJNknSKVSyMtrnvjc3S9srgJvCTrAJY4hviaO7bVO6A9N1KuLe9GnR7utiWRFdpLHitrT+SD91rOANdVPcXaQSNe49oaed/6LOJpPhZ4WN8JefETQ5Ms+6z5FT1roanidBL6OWkaSAHHcEWAac620duXJOI4gP9T1J8ysIXbhpJdKAbY4gVXN+zfq7jcfhrMynloff+WvztWn3LktnFIHDxD/C/9bEx4oNnOBLXBpOptXsORBFO96dwSWXA7PGklpokMN6OW3R3vtMuLC6bvTnU6rGwa51WOW4A95XYL3iUOpE5j6FeQAs/Dek1inSnEuqjBLV30+PuHmtCuG0aMYrRlLIA3XYaI9nnkx0IsB2+23P/ACuTedrXCwbFX7b5VfNDsQu0SEjVGxzdLbaHMc2nNcboivPqnmDGHMYAx1taANQLQKBZ9YjfkeSZbUVtFcJuL0xniREEaqY09bujzG52Bq/grRwSEHS7fSG0zcjbq4tujtXPyTPHxg3xOO4HKthfkALPL9asGHHSSyLtroQtlsfwhZZMYe1wppcWOaNQsWQQL95WAcvdaz1tCUo7JHEnsA+YB+O/xT1uTVAfWPIegq3H8ncfcoLEfRLfI23/AAu3r87UPgnWJILceuqifMUCB6DeqHquOItOvZORP0tqydySTzJJsnbbmTyVek/oHSgv/wCzkGaMOJPc1/XMB59zbmODemp4G1ASPf8AqoXiBillpzA5+Ppexzq8JkDuVH8kbHyClW97T7eZVGnT6EZObqXeUvaA76pAoXTSdmtuxsmeNCC4hwBl0OZG9wbegkGRjL+qdx8G86XkOewGaNvi7qZ7XaBsyo2yBprkAx8TbHmEsyEuLXOdEWOLCKBDi4mg5hLq+o7n+SE7px7/AJDq04k1wPH7uKOP8Boa0GiQ0fVbYFGm0L9FJTkhh0gFxGkAkhtuIaLI3rfomnDH6mNd5gX8N/vS3FCBE91tGgd40v0hjXxnWxzi7YDU0c0l1lPr8SifRdCRwTbQSKNbjycNiPiCpfEYqN2W4+XSDFkaxliQwvDt3hk3dhjmhta9zvfRX7CCLqZVy0xCyzceg8gjToM2/j4LyJqXOwNCzRpu2/pvsuwiZk5bZgG9fgvdCyYKAB5gAXtzrnsK+CC9T0kQ2etC9tJmRJSzI5tHOVsVfIuXfn78ID8fhnERzinmw5D5ieMTxD3HHn/OK6QyMlaj+dPh/Sez+aAAXwGDJZ6d1Oxrz7e5klWjwTJ8LOrfxevr0JX4zlVL8Br2J/oeH4MHWPAxWH/EIGatum9p7NlqKgk0sYz8FjW7cvC0Db02SUkyosj4ljm/Nt/U9vTQoRS+A/kyk2kmTKSSxXT4fqWBkU41DChocvkTd7lgXrAuVsY6JpA8pFxWbikXK1ImjwlZMekHuSJkVnLslolYpgnkWUFXDkI+mV1UXj7OOvZbGZo80oM31VQGf6rNvEPVVPDIugthy15JKXCg7Q4EFrtzVdCAQaqx71WWZ/qneNneqg8Zx7Fc6emiZh4zI1pZ3XjYdo9VuMQ8ifA40K2P4NpxLnd4wyEHTVsa6xsCdT/UkXR/w8rUV9OAFk0ALJJ2AG5PsSeNkHQzp4G7e5RdS7paFlj9dNkjiloDarUBRc0g3tVF1bigPgE/xg4DvGySGjrewuGl7QADGOjBTefqVXAac0jbxUQCQD4XdBt5fBTGDI51t0gUbLnG2jTTmnQN3ez2qNkGupG2qPLo2XwHL1AHceh2IPUEdCrbiu2C1hw7Ka0Oe53dksa4DUWAuc0m7Dqc/Vt/kCuHCeKblhdqDa0P2t45OBDRVg0LHms/l5Xs85mUtvoWV6Z5BWDc9vmkpsgFclJNCMKpJ9RtPImUsqWndaZPVJo1wEp39FX+J4TI3vy42NbM/Q2Z9E6meGMPeAdy1tG/Jrh1U88JF7VOubi+g2kivvcXPY3xB4c9veN0eKItcS9u58OtkbfbXRKxYpBDC8uZodVamOHibWpzHU47nfbkn0uGbBYQADyN02/raaPI7eH0Xhx33esDajTPeCCXbHnz81c5ryLE35kdwyLYcvCy3Hq90rrLief2OZ806kAG52Hn7rSv0JrR4BTtqNk8jYB3+rzFepSBYS+pGNLdALT9ZjXAm93AEurSbA+yVxtSeyUZ8qGzGlrtTrGtpIaG2eYoHTvYBA28ym+dA5wJqqBLG2bLgbaX7bch4fUqVeadfPWA1tVu5upxAs19Wz/kKScx7gCAynAOskgtsXWn7XtsLvM+5OE0uhV8uLULHsI6gjmCPNQuTB4mto7nVfTw7gX53Rr8kq35WDICXAscSN2kFgscjdnoK9/oonLxi4CmltuFOdoIa4cjQdv4hXvTlVuh+F3TTI+GO9jyOx9hTzCxwwBpDtAutJNCze4b4id/1rN0Tm/YJPoRR6CievIUU6jjIouq/stH4XSz15XyROeyU5JjnDx2gnSKAptAVvzJ9eY+CkGbJpAKH6/adz96V1JOb2yjQuXrEvSBesC9cUQ5RxrqiN9NiuZ0noPeG/Be4GQ+3NdX1nFteVMJB8zbufomGA6mny7yU+8yOJ+8lOGkXq6+0106XV7Df0U2tbRW699SU75NJZAHnbd41X56Kb8aLVgJEllbtO+k0adQtu3PcKuKDkSIrGgDMud17zlr9JBAAEUcYc131XbxkHqNUfmnuHglr9nP7sAafF9RpLi+NnUCwzc7jkPRtOGyBr3UQHNLJGkfVcAXttv5ID9uYAUlDMG+Cy52ssFAuIJYZG63AeHwD6zvTqU1ZKWvy19CtJLoSMBAAaNgBQ9AkeJMEunHJphLZJd6c5kbw5rAOZBe1t9KBHVIx5Apv4TgTo5m20Ht222cavlyTOGOYvY7TGJXSSN78OcQ2NhvudJbbxXS+bHnZU1we9ld2tHvEOEh2S10UgZJDGJBqFsY+MW0vc93Lu9XI34nbjmtocNcHNa4cnNa4exwvp7VVeFcJjjgc1xc/wALpJpSSZJH93pc91ne2DTp5VsrZgCgG0Glv2AQdLLIYaHIFrf1rt9viJL4GNcuVv5kjG4bgEagBY8rur+CWuuf8BJMPxKHOUdpCGtg96R767roaO4O9A9D6okem8j1XKRbCBlLICCDRFURz59CPYmOZL9qgSPM1+ob7F3xRI4CztZ3PqareuewA9wTHJlVfMOVU7Y3kzd6JBsammx4gTv4efOvzgqr8pA7/hvEIOsvD8pg6+I479O3+KlLZr633Jv1PPatvs8tlCcWfqZIzbxxvab5U5pG/pur6JclkZryaf0NOGMpQa+RWDdD2JJ4Kk8XH1sY8faY11jl4mg7fFBwjv8A7J7xEmbasWiHc1Y6f+iln4Z8lj9E9FNWonzojNKO7UkMX0WQxfRHioOdEX3SxdCphuIfJZ/Qj5LnjJB4iK5LAmk0RVsfw/0TWfhvorYZKJRtRUZmFNZAVap+GHyTKXhh8k3XkRLo2orptehxUw/hp8kk7h58kwrolimiLlmeB4RZsbE1t196dwZBSj8MpP6OQuuUWjnQdifUQ0nnvz50RQ/19yfY+QQfEQW7DVypx6O3ry3/ACgobuLe3pQNGvwtnURydX+qmcbYAADcgNHTf/SrPuKWtSSF5Lux7jQNe4uvV9UtI0nTXVprnYU7w2PT52dyTzJ9f9lGcOg02SdRc7UTQb0AoAdNuqlYjSzL5b6IWaJLDLGfZF1VnxHSfsgu3Da6JPinFpY5IpGGPumBzXM0PfNI+QhoYxzNo2cjZ2sC+Sjp8qlE5fFa6quqpt77lEsRTLpB2oGvun6o5CLaHUWyC6PdvBp25G2x3Gym8bid9Vp/+VWucCQ0kAtBIBoOrUBfnQ+CtHA8sbFlA9RyaR7uR9Vy/E5VtELcHS6mycebUlZI1GcAl1gH2gjnuDR39oKn+7We1oxrfclojSxYmNSToVg6BcOK0jHRJJ0aknxJvKxBdGzYyc1MZse3s1Hwtje52w0ucXsOrxfVA0//AMiknBN8uIPaWnqDXvFfCjXvKshLTLO6GUEUfjLA12px7tzSHU6RhLgHE+HfUaHQqREW1KOwp3nS+QUDpLaa1rWueNPiPeFx5kf5lKQzNJLQQSOYBFj2jmFK3eziekM86Gmud5A1/i5NH51D3qMkxgWsIa7RYcXHSbG5BOl1nxUb9qseZEHMcKB2sWNQtviHh+1uOSxMLQ0Bv1Q0Addq25LkZaR2Nz2VXPiDW6ugLCKrxeNtBt7FxOwHqFgyCtyPERv1r8keikcqMiZrAPAWSSHnQeCxnhNVye7b1tYSMVm9JDtc+YaUsHFKyiv489v9UgQd7N7mtqodBz39vqhFyZg5yRdIs5U3kKsiixIzidV8uZO23M/rSzHpo0paNdkjuh2wpZoSMSdxNVLKpEeIA2RzXBro5WjYtsE6twSdqDnNNf8AvHeSQ4NiOx55onTve2YRux2SOD3M0NeH1TKa3SIx4uZaTzO82cdrq1C6Nj0NFtivyXOH+YptnRNc6OCaLvWu1PDqa9vhaRRBOrvBr6DzPsvhbtOPxXX8hKxJPZjgYjXukcRI13ePafE6PUNVteKOoCtIv8jyUiYhs0A/0Le96fW8QjBLtzZEl15HfdIiOAbu0sDWsGsu7qmbtDS8uBFeR9FIY0DS1zmObI5+kAmQE6oxqjaHN5nVR381Btt76lNk1rR7w2YiQQzuyAytZfp1xukiMLnxudGzVGdUgOkGqaeSefSsiF+ROyMyCXLx2MB1ASY3csPeQu0+Kbu9exuy0C72WXZeGZspf4for4Iw0B39I2Ul8kmttVsXEWPwgpI8MhY502oskDQ50kkr3aI2B1Gnv0tj875hptXKcIvTXkYlqbexQ9pYQQ29XjYyQwnvWwmVpfH3tDXGTy0uF2QpBuW1wsG6qxR1NJ28TK1N3vmq1wyHTLN3MT4pmRRSd1OG9zcrZI2QxzwfV0shDdtQAkFDc3Ixzxz6ZBRHdk213iaXGnN1xnZwLXAgHoVVdCK7HK4t9x4/NZYaTTy0uEZ/rC1vMiP6x5dFi6SwCNwRYPoVGzZUsZMel0xNmN3h1Bm39YAbdTtrA5aeZtMcWAwmXI0NijeWudAwABoDrkyCQB4vE55Fb15lVeGmv2+ZfFaJadyjctyemQOAc0hzTfiBsbGq/X8E0yWqjWmPU6ILiA1At8//AFtQ2USQfPe1YsiFRfEotLJHn7Eb3b8qa0u39NldW/I1K5pIT+T/AB+/4bw/IreXh+I93+J2Owu3rfxWph3CfRQ/zUsn6X2dwXEguxzkYslcwYch7o22f/cPi+IW0Dwokkg7VWktFAjfUHDc7ED3dE3xCiVeTZD4Sf7mHRxT3I7fkigS8L9Eg/hnp/H8fqWxJeFeibS8K9EjuSHIcSTKCeHeiBw/0V0l4cBd0ABZJ5AeaaZWIWiw2xV6uYAsXsNz4b5Lqk2XevoqruHHYjmOm1EVyPlvW/onTOH+inseFrvqkHZpOnetXK65cjsU7Zhei5KT7M48wrjeGei8fwj0VviwgnDeHjyXE2UPiGjX8vBvRNJOCei2WeGDyST+FDyUlOSJx4oawk4J6JtLwX0W0ZOEjyTSfhA8lNXyQxDiaZqvI4P6KPyOGV0W0cvhPoobM4X6K+GY0PVZil5mupcDy59Pb0+9LQQWARsbtpI5EdD9495VnyeHUmJxNBN/VO9gbNPXV6db9qaWTzIZdqY3xnnkW+K+QvTXnrI5J02S2313seoNH7wvRD4m/wCB9fFiMjH6jwu8x12rxDk4e1VNple+pHZ8irPE3ndWfIbqFj3+hq69u6g+IYtp7GaT6jdTRWWSu1e9Xbs7OQBzPKh5k7AfEqtxYXi5K2cCxQHs9Gu9nNm9cr/3KYzJxcSeRJcpsvsmaAv2n2k2fdZVvjCqXZ1tUrRBIvLyfU8hmr3+g60LF0ayY5ZErpnbaY0kjTOeNSciavF/D2c/Q7hRaL65sipY01kClpI1G8Q8ILjyAJPuFoQ9XPZFNqnNP4br6c3F4quWzh8F61zWFrgNm6gSAXOAcHE78yNX602fbQAedeI+bvtE++00knBLWkmiTdOc29jtbTfnt6K5LqOeFuJYIc5rw0Ndu4jbdrwOvhPiaduq8yZ+7LWlw7oj7X1m7gNGq/EN+u+x3UdJIxzQHC9wG0AXX5NtevyyS2S28w0M3D2up5DTqF2dWmq/BXYxQrKtxZ7lTNL43N8V64w5v1AXN13q5H+prbzSUhvdpB3IPtFtIvodQ+4pzmG3RjmdZd7Ghjml3xc0f5kyzjRcyMHvn7aw0lsZP9o9xGiwDqo7mghLehiEuUHNSL41ngQta0saCGNe5oJ+0RWt3qe817+dpZ7Vx9HoYhLZGysTWRik5Y01kYpxkXxkMgz+P9EvEF6Y1mwKbeybYvCnkaZRlOI3qplMh7EUuADsQCPUAj4FMmPSrZVWUThsejFjIojw/ggnRYNg6L03YBSEvB3GnMyspr2f1fjjoCgCyzFu00NzvsN14ydLxZKlGyUewrZjqQvFgPLgO8yG7AySGZwZz+o2KEhryQHW94vdvXk9zTiwxtEx8HQO7yTV3REu0bBvRYHUAoTJ4w4ytxccsM9h073jUzHgG5c5rXAvkJLWhgPUk7BSOPrkNzsYWx33e4cHOJe0ymMimHu9Nbn+skCtbl0cn+XmZ8qVvoSTuKwyBgbI13fMcWNDiHuaB4yGjxNIuj5H1UPxDFaNGOwvEUx0yM1ybMja5xIk16mgktaRv9YeqR4qQMmKZ3hDIpWh2lha50mm9cn1o3AMAA5HvJElkT6i57C0uaxmhzt2WD3h3abojR9y4vdacX/9Jwo2upJ5bXs3gYw6W+CO9FUP6toJ092Rp8NiiwHdK8FneWhsoc2XQ1zmOb9UuFuAkaS17dRI9K5nmkcPJ1Bp5agDXOrF1fvUnE7ZVOzppr8zs6uVkHPwowEHGc6zI6R0DnanSs1tL2NL3AFovYvsjWa8lKTN3Da2de97WK28y7TqP+Up6E2zJdL4GeKpXltjTpvbwODjZ21O2/uyu8zs0mV8ygInFvooD5R29xwviORW8XDst7enibjyFu9beKlfYcRaw+djxSPE7PZrNbGz5XcY0TC4B7xJkRul0tvUf6BkqZ4bju3JrjrvJfuVZGbywf4FN/8AZ2cTa+HinDzQdFPBljay+OeN0D632p+PDv8A+8XWGO1pdKCBTHtaOXWNjze/5XIr55fMq7SjB7S4rHENi4hFNw95JoB0zRNAB5uOVBAyvy19D5XL61PhlFs3OUVtnk1a4rR6cVhHr6cr/wBAkJ+GitiPehkydRSJLJ9Hcaa6LROGTIhpuHnqK/j0TF2CASaO/Pc1ttsCab7lbXNBHJRWbDXL77PReL4lwf1fquw/VktlakwAKoaa6CwNj6fxuUMiA25bnbzN3tYslSU4TKR3T+B/1XnpLRowk2KxMCdRtCj2zpePJRCSRGcJEi2MIMITePJSrchNKUBZxkD4Am8uOE575YueoyUWdUpIicrEChs3BCtMrVH5UKUnDQ/Re0UrMwVGTYSueVjqMycVRUmjaqyehTJcTQ8EXpO1dBrPi26eIR/FGRFQ5eQ8uZA/1U1xLGona/AduX2m73Vg7j4JjJw9o/xCvF+UN9VctV/FMqaaTY3C3fYhJMcl5sAeAEUSQfEfTmNvzgmeThX0U9kQWdJFOo6Hj0q9rsb1t7EgwBw6WCWmgRu01yPx94V0bWuqGa7ddCuR8P3U1wnH8d/ggN9LPiP3aViMcyUWudGy+bWjW+j07xpDWc+l8qIUxgY4aOp3uzzPqf46KV1u11Z2y1yJ3hLqU3DOoDENJ9HKs1mTdDmZOR5CVE6h2TJUTLgnKkkjKvNVpi2VLRvQQdehfSo3isQLXNPIgg+w7f6qTYUz4kNvchHan7xSMyBlfVaCNiAKAI2NAexQ8zLcW6ngANIpx527ezv0CnuIt8Tx/hNe0V/9v3KuvkAc49dZbsCSabfTeqv709Vtm7Uk49ST4a/SdJLidywucXHTsSLcbu6/8qkBOdVAXqcyMEjwtcGvk1HqeYHtIULit1kOcPCPqDkb5a9t/YFI8PkD2hrfEGybu5gFj9VEk2XVXxXJLrsrtiS8MQF1zO7nH6zj5uPVJREAOPQOcR6gc/8AzAj3BLNKbsOzWUdqDjRAAZuKJ2O4by8yl11KTOKKgB7z/iJt33krDUDyst0tcHfZOq9h1vb7wldSxe5c2WJMbvamsrE7eUhKpIuixo4LAlKSlNZXq1LZchXvFk2RMHSr1sqlyEuUk2ypQTKPjelwVBxIOKHEuWGguJoAWT6LGDOLvqtd/ie0sF7j6rvEfh1CjnTMfKY7BfC1ry38EyWGurldA/Ep1G5ScEl1RDl2THDy1vIC3VqdQBcR1dXM8/ipFuQoTHcnJk2VElti8qkK584ILSAQQQQeRBFEV1CYxTgbDl7bPxO5SOVImzX7qcY9C6FS0SfBMs39HcD3kTI7dsGSMNtD2Vy3Ybb09easuPLt7OSpVBkjMirIb3LgLJc2R40AC62kI5/hlWfElXLl5oStr8iYfPpa59F2lpdpbWpwaLIbZrV/0TvFlbLXduDi10Um+oDQ4/W/KGjvK9W+YTHFepjhGM1gpjQ0Ek0Lq3GzQ6CyTQ8yoQa/MyclaRMYkNrln5/07ceHh2C0kuysrJzpBZpjYWNhiGm63flZRv8AJA6LrThsXJfP3563aUZvaXKjaQ6Lh0UPD4yDduhaZpwR0cMnInZX5C9v6MYe7PEfkefy7PI05w3NkgliyIXGOaCVk0Mja1MlieHseL6hzQfcvqV8n/aqLivDsPikNd3l47JS0G+7l3ZPCa21NmZIz/IvlYurvmGfKLofP2byH+GYvzOGajyma3/teM23dY2NmDQP7Kc8yvf1vqZsux1+nmKmAen2I5W29iEe48JoWonOnT/PdTVXcyVfMvSHMfiOBr4texDLlUTk5KyzplBZuQvHyltnoMbHJB2Z6r1ud6qszZaTGb6o5WaXqey4x5/ql2Z/qqWzNPmnEed6o00VTwS5x5n8fcnMeTap0GcpLGzF3mYpZh6LKJLWEoTDGyE8DrUubYk6+VjSZiY5UalXhM8ph/j/ANPJQaGKplY4tGNQBBpw07XydLGHDb0r702yGbqQ4w0ij1aHu/NAd8LAHvKZ5A3Un2RqUSIbizWgazqsbN0l4PiI2pm5bsD/AJVHySMiZq1W3w+IeLUXENbWnpdDb0UrxWwA4Au0uBIFXW4NWauioXKiDnB2k6Wu10QQO8AIa4DkdiTf+FMVdV1Hod+gvit0gN62T5/WcXUPyRde4KSxyodkm6ksR6jYi6cdIlYSnUaaY6fRNS7EZ9BRiVavYo0qAoi7Z41OYQk2BO4GWgonI9akczknehN8lmyCmDWyn8bidYc2rJDXagaLd63G4Nn/AMygji0bIbrJNkepurqyOQ9wVt4vAS12n61bDYXW9Wdhyq1DTRuPJhA/KLWn4Nv70zXN6NmixEbGSHadNtDbcaPry6c9q57qV4fDpHKiSXEXe59Tz5c1hj4xsF1bcmiyAaqySNzzUhHGuTn5InOW+pkOSTc5KlqReFUiuOjEuWLnLErwrvcsSPHFN5Sl3BIytUkTQznKj53p/O1R87UxAZiN3OWcZWOlLwRFXNpIsbHEATprV7jQp4yBKyl1F5TI4R+NxoWWs3rfYvG56paONLtZ4j4XaiaAo6dLSaOs+HqT57paLHeTRDWj8JrtZI9jmUESZV4qMYWLKQpU4Q6jV/iJd9x2UVkTGN5g8dvkZ3bn+INjcGh2lzj4gCHc+Woc1yEefsVuxLuZypJjU9kiSUjCOQt5+oDYBNcyQNm+q6mMc6SBrLLW77ODzRrZvIGumrp6FTeIeSj8TGrmdRPM8rPoOjfRS2FCq5yFbZIlcAclZeGs5KI4Zj8lYODU9z2C9UbgHAgjmLDmnk5vMWOrXKWPU5y6I89m2pCfbftPFwjhmZxaau7w8Z8oaSB3kxpkEIv7Tp3xM/zhfLDiebJPLLkyuMk08sk00h+s+WV5e95rqXOJ966s+f58ooc/H7MY7/DAWZnFNJ2Mz2XiYriHb1G90xaRX9LjnmFyUvrHBsV0Y633Z5i6XNIE+4DxWbEyIczHeYsjGmZNDI3m2SNwe01yIscj6pihaxUfS75Je38PGuHQcSi0tc8aMqAO1HHy2Ad9CetWWuBPNsjD1V6wcpfOX5vHynv4FnXIXO4ZlaY86IDUW1fd5UbefeNLjsOYc8c6rvHhHGGyhskZEkEkccsOQxzXwzRyN1NdG5p3FEG/yhS0atWx+YtPcGX941sr0Vb4jERafcK4hyFp9n4okGpvOl4L0o4JKX8WC/E1cLJSKFntKgM9pV24jheir+dg+i+byi4vTPWYl8SnZVppan8zBPko2TDKsjJG1Xamho1xS8bys2YqcR4h8l1yRKUkELypHFlKbx4hTyDHKrbFbJRZK4cql8Z9qFxY1MYYUUZOQkOw1EsFhOYI7UjDhWE3Vjys6JGZK7lKDx3GqyboxytroTp7y69kZHvTPJxSpb5WR9GwZ8oukibjhsr5Imue9kbXASODWm3DQ51+lrLh0bZYmyNJLdLfE5rmFw0Nc15DwCLY5rv8y5ZjThBNrzaHsfNWyq5Ebi5zAy9LWu1lwDSH6ug8XNh6KKysMtAHkK/gdFfOC8I/ozuHBz36CGNZUbXFrG+H61AfW62kOI8F57KttxNLHzo76muTCbT7DaVM5PCCDyXkGBXRErNmk8iLRlhsUrBEscPE9FKwYypb2Zl1yEYYkoYN0+igShh3RoRd3UZQ4/v/AF+0p9i46XhhT/FgVtdXMxW2/oRz4E0yIlPTQphkRLtlTiQqu2VnLhUbNjqyZEKZSQKnsa1VxCtx0uyFSH0f0Sjcdc2WyvIp8SbSxKdfjJtLjLuzsLiEdEsO6Us7GXgxvRd5i9XEV3STkhU19FWD8X0RzEleV2WBM5cdWaTD9E3fheisVmi+N6K63FT3Gw/RS8XD/RSeJw30RK0jZlJIicbD9E8ZieinYeH+iXGF6KttiE8xEA3D9Eq3E9FOtwvRZHE9FzqUvLK+/F9EwzcKwaoHbci9g4O0nrp2r3q0y4yZy4vohNplkMhMp8jn6mmo+7c8xF1uLmzatLRprxCwdvfdJ7Dgm7O5O3KgAOgF+/4KQ4dwdwdrkEWsDbuxZLiKfI+QtBc6y7YAUHHmpWLC9FbZJdok1k9NsisfEUzw/B9E6gwwAXOIa1oJc5xAa1oFkknYChd+im+G4hNFrTR3BIokDqGEg16urmFPHxrL5KMUIZWckjDBxQ0E1ZDdWkburlYbzIVa+VDtPi9m8PN447T3sojayIu2zeIBj2Y+PDbthoDS54H1cZx3PK45sWLDH9NyhDF9GidM+aZzaxmNYXyvfNyoNBs8tjWy+enzm/lbf2h4hqiL28Kw9UXDoXDTqBI7zLkb0leWjY8mtYOd39J4PwCONHns7s8xkZLsZrTtBxefMyJ83JkMuTkzSTzyO5vllcXuNcgLPIeiYIQvSCgIQhAAuhPmtfK/9Eezgee+sKV5GFkvNDFmeb7iQk7YzncnfZc7yJLefF4rK7HCW0RlFSWmfULFnLSrLwriHQrjz5svy4B3dcE4rLTvDHgZ8jtj0Zi5Lz15Bsh9AehXU8JLStJ8l0BVbrZbp8dsgsbFQmdwyuiXwM4jZS8U7XiivD8Y9F4Wtzr6M1cbOcSjZfDPRRU/DPRbIyOHtdyUVlcNrovAZfCb8d6kjdo4l8yjt4b6fcnMXDfRWQ4PolosL0SCpkxmXECus4b6fclRgeitDMA+Sxkwq6K54ViW9C7ztldjxqT7HjpO5MelixiqVbTOSu5kP8CK1MtAaFD4D6KmH7he09GoVuXXuZGS2Q3bDCGTiZMHdNmkdA8xQvOmOWVjdcUUhqu6MjWNIO1E2qv8j2bHxLhkGVpZHqjbDPjs1aYJ4I2wT4p1tDw9rmaDYG4KuMtgrVfaDgmdwnOm4twwSZHD817peKcMjY2R8GQ5sbZM/EhbH3kttia4wtJNh1A6tvWZXBMe7q0JwyJRNpcMx2BpeXB7S492bBuPkCSBR3BPsI3WUuNDJsKB+5a+7KfKDjZUDR38fftAa+BwdDksOm9EuJIO9ieNLxRH2LtN8UPZluyxlZRZIL+iOkBxLLGtDmxllt+qXVfN5Ktr9GMSdfLykJZ04y3sumfwDqACPMKLfweuimeE8ZJq1Nt0PG4XlOJehjre6n+TNKji0mupT4uHV0TuPDU7mxsjbrLXltgHu2OlLQftFjBqLfUJY4YWC+AXQ7oYlm8xAtx16ca1KyQUV42NKvBafKznjsZwYaf42NpTmGFLaFtYnCdLm0Lzu2RmWxReQ1T2TDfwUZkY6y+IYsoy7FtM0Qk7E1dEps4trEcPJ6FZHgTfZGhHISRDCFKNg+7p03/1/wB1MfyY7yKVZwt/krI4Vz7Rf0OPKj8SEMCQlxQd/wDUjzG/nzVnbwl38UvHcIcrvZeTrfI/oRWZFeZVDio+iKzHhTvJZx8Id5V9yrjw69vSg/oWevRS7lN4O/v4mTd1NDrv+iyGGKZulxaQ5h5bg79diE6diK1t4Qb3LQKFb73vdiuXL717/JHq1NPguU+qrZBcRivMp7sJYjh/p9yuP8jerVkzhA6uauR4HmN/9t/Ql7TivMq2Nw30UnjcP9FYIsBg5utOmRsHJaWP6MZMusloUt4lvsV8YPovfoforFoajuWpiXo1Yhf1wr30X0WD8ZWPuWrF2K0qqfo9al0R1ZRV5cVIHCVpdghYnh4SU+B3r/iXRzNeZWW4ScQYXop1mAP4+CX+isAIIDgQQQRYIOxBB5jmrsb0fuslprRyeb0IiXgDJo9EtiMujedJpxMbxI2nVbTqa06hvttSkJHNjFNHoSSXONcrc46jzSk0xquvoK+AvZce/Ov+cF/XcC4RNZ8UXEeIxO/yvxMV7T7Q6UeoHUr6BwvhFWHDb7mVdfKxlf8Anf8Ay4HOkk4Bw+S8CJ4GflMdYzJmEHuI3A0cRrxu77Tm/ggF3M6ELTlLbKkgQhCidBCEIAEIQgAXTPzb/nCfR+64RxmQuxfqYvE3kufj2QGQ5ZO78bmBLzbsDbd28zIU4TcXtHHFPufVeFgIa9pDmOAc17SHNcxwtrmuGxaQQbCfY0hC4I+bv8vuTwNzcHL7zM4K539TeqfCJPikxC813fUwHY7kUSb7n7J8fxOI40efgzx5OLKLZLGTseZjkYRqilF0WOAI6ptWqaKeTlLJjzJ1seajIn0ncUwSGVixtWmi6E2jybEHREEAThsoXuoLzFnA+WfNFDau2jIABeFoOyxfKPNNJs4N6rXq4epw5XEplbrzDLxBzCjZISCn0fFmcjSV/o38jS89xL0Zt3zVoYqy0RsMZtTOIDW68ja1u9gptmcRa3qruDcBtrlzy6Eb8iLFshoTUpuOIg9U4ikBXtlW4LqIcyZGZ2AxzhIWMMg+rIWt1jYjZ9WNiR71DZnDN7AVy7kFR/HZY8eF88nJjSQANb3uALgyNgNyPoHwjfYq2vJUCEquYhuHYpBVkwjQ32A5k7AKtcFOVJJGDjudGXl00uQ5kRxy0OaI2Y8Td3fWF26jz9LmyAVRAIqiDVV7FTkZUWiddTRkCvda9DABQAAGwA2AA6AeSa5UlJCtRtL22hYEEkHltv6nmB6cviV7paFCvzwDzSUnEh5rr4NVKXM4kPWdE5JkALGPIBVZm4j6rPF4gPNPxwVGOkirx+pamvBWMkIKioMxORlrNyeEwt6NF8L9DpsLW81hLlNb5KI4hxOlWOJ8bPmr8LgVUO0Su3LLrJxVo6pnPx5o6rW+b2grqoHO7SHzW3XwqHwEpZrNq5Xado6pBnaxvmtJ5vaQ39b76TU9oXeadXDIa7C7zXs307tg0DmozO7ctGwd960dkdo3fhfeoybjrj1KlDhdS66IyzZM3i/tuPwvvXje235X3rRP8snzSkfFz5/er/Ua/gV+tTN7N7aflfelou1t9fvWjYeLmwC6ieQJolTGDxEmjex6qLwofA6sqRuaHtJfVPIu0I81qTG4kfO/enA4ufNUSw4stWSzbcXaAeaew8cb5rTkfGSNyeXM+Xv6LN3aA1YdsRt7FVLh8WWLLZuKXtDGOoTGXtU3kCtPS8cc40CnOBkPceZQuG1x7g8yT7G3cbtAHdVK43EgVrrg0TjXNW7huOa3Sd+NWhiq2TLE3JBSWTkta1z3Oa1jWlz3OIa1rWi3Oc47NbQuyoPtT2hxOG40mfnTx42LCLfLIeZrZkbGjXLKa2YwEnouFfnGfOByuOudg4ne4XBWu/qdWmfNLT4ZMwsNd31EA2GxNkAjNcIw7DSbZdfnO/OSOT3vB+CSOZibx5fFGEskyaJD4cQjdmLyBl5u3Apu7uWUIUG9ktAhCFwAQhCABCEIAEIQgAQhCABXH5K/lJ4jwLI+lYE2kOoT4suqTEyWjkJoQ4WR0e0hws0RZVPQu7A+jvyJfLdwztAxsUbvonFA25eGzOGskC3OxZaAyotidvEOoHM7TYvklBM5jmyMc5j2Oa9j2Etex7Tqa5rhu1wIBseS6X+Rb51uViaMPjbH5+KKa3PjoZ8Qsi5gToy21W+ztjZcVbGz4kHE7baUPVd7D9tOH8Wh+k8Py4cuKhr7t1SxE7hs0DwJYXejwFPkqejg1yXFQnEJ3bqenIAJcQB1JNAe0lVrtNxjFxw0ySDxkNaGeOySBvp2aN+vkUzVJLuUzi32IXN4g5vmkcbtK5polP58YytD42sdE5mpkmvUHWBpruwQW7ne+igeIcBncbaWt23G7m3fMAssfHoFpQlXJdRSSmuxZMftTYolNc3jd9VV28Iym8yw+uh3kR0f50fcUscSaiHBvSiNTem5og17N1JVVrqjjnPzJaHjJBq//VWLhPFrrdazxuyo7wvIIsjTpcWuiLeRaWt3PPn5q3cF4O4EHvJjXK3mveK3681CyMWiUJPZsXEzPCSAXkCw1unU70GsgX7Sofikjcp7HxvI7h12x4fEInFrXyyxiMlszTuBsQWNPK0rh4j9Nd69o6uAYHVpI2dp287PklMbAhc6zkue4gttphY42HA6pImBxJDj186WDk1rfQ0a5dCQ4Y1mPphMcUbZHeCWFumOWQgDxg7tlNDmTe26lbURxKJpjOP3T5AQPDboxd6g5sxI0uDvFbNxQS7HuDWhx1ODWhzqrU4AW6um+/vSSw1J72W+JoeSyKE4nk80vPOVD8QcStTGx1AXts2QPE80glRjuKHknnE2i6J8XPSPE+rAvSN63G6jXYLz0LB6gF366HTna2YKOjPlvYu3PurcBfKzV/H3fFOsTiEYIHeNtxpovqBfu2I5+YTSDh9EEgkjkT6iia5XRPxKk8WGhVbcq6V5V5Ino7ElsXMA/CPq1rnD4tFJ4c0eT/8Aw5P/AMaTLGaU9bGUlNIYiyM4jkA9H/8Ahyf/AIqrcVBN0159wb9zyCrxNikqLz+Gk9FfTYkV2Q2as4prG2nfzBGke3e/Pl5KtcQDt/ER/hA/+61tHivBSb2VY4hwA+S06rExCyDNdSM08rPmXEuJoVuXbpkWuGwLq6C7r3uFq9zdnHHok29lnn7KY54lXLIoNvJI3I5D8InqdhQHt9VkMZ59PvP+wWxYeyDz9lSGN2Kcfs/co+JFeZ3w5PyNXs4c419bb1I/+XmPan2Pwdx6E+2yttYPYUn7Kn8DsMBzb9yqllVxLI482acweAnamddvD5qWxuCOG+j7tj6kciVuSLso1vRE3Z4DkFQ86D7FqxZI1FJw5w3og+Ytt8hvpO/IJBuBW1Hc3zdd3zsm9Xqtqz9nSeib/wDCpPRSWTA54EjWhg/JB9SASfaTzWH8nPds0Ob/AISWj20NltaDskOoUhD2ajZRdQ6DbcmiaAG5NAmh5FQlmQR1Y0mas4VwGWgPrHzddnfqb8lb+BcODb7xroy00S5rtFXs4SadJb6q58O4VdlrY2sBpryRKTXO2xnS3f1Tbtl2i4bwmE5HEsyLHhI8LJS3VKWiy2HHib3uQ78kApK7P+AzXi67kjwnhbWbjezq8xyA29wVG+Wr5beGdnmGKRwy+KFtxcNhcA8Ei2vypQCMWLcHxW49Aea57+Wb51eVlB+HwRjsDFNsdnyAfT5W7C4Wg6MRtXuLduKLeS5pnmc9zpHuc973F73vJc973G3Oc47ucSSbPmsq29yHoVpFu+VX5SuJceyfpWfNqDLGPixao8TGaebYYS40fN7iXGhZNBU1CEsWAhCEACEIQAIQhAAhCEACEIQAIQhAAhCEACEIQBI9nuN5OFMzKxMibFyYz4JoJHRSDcEjUw7t23adiujvkx+d3mwaIOMYzc+IUDmYwZj5rRv4nw7Y+Qfqiho67lcwrxdUmjmj6c9g/lV4JxlrRh8QhM7t/okj/omaDVFv0eUh0o3+xqHJXODHjYK1eE8mksDR6BoFV1XyVa4gggkEGwRsQRuCD5raXYT5wXaLhgayPPflQNFDHzx9NjroGySHv2NFcmOAU/EOcp9G5ICTTTGRX1nN1uv1awgV7FmcOIC3Fg8yaYL9jjYXDJ+eFx7rh8EPtxs0/wD+9Dfnh8eH/cuB/ouZ+/rjsl5M7yo7l+gQHkWH2Fp39x5pOTg8B8lxF/PH4/8AifBP0bN/f1i/54vHjzw+Cfo+b+/pK63NX/bkvzJKFfmjtn+QoehanEHCWt5ELho/O+47+J8G/R839/QPnf8AHfxTg/8A4Gb+/KpZXEuzUPqzvh0+R3nFjAJOfhzXHUDodYNhsbgSDqvTI0gG+oXCbfnh8fH/AHXg/wD4Gb+/LIfPH4/+KcG/R839/XHLLl3S+pJKCO58rh7XeINYXi/q64rs8nFjvFy5FN54cg7U1t14mgEgeVOfRK4h/nk8f/FOC/o+b+/r3+eV2g/FOC/o+b+/q2h5Ef5tEZcrO0ZsBzrtpdYILn02gQAQwsfbBt0TPG4VIzULBaTbWl73BnoC9uoj3rjo/PK7QfinBf0fO/f1gfnjcf8AxPgn6Pnfv60o5El5FTrTOxXcFPRxb4tRDQdJ3sinO9vxXruF+i44PzxeP/inBf0fO/f15/PD49+KcF/R839/Vyy2iDpR2OOGeiWj4f6LjH+eFx78U4L+j5v7+vR88Pj34nwX9Hzv39Dy2c8FHbEOGnkWIuHR88bj/wCKcF/R839/WX88jtB+KcF/R879/VMr2yxVpHcww147h4K4bHzyu0H4pwX9Hzv39e/zy+0H4pwX9Hzv39UO63yJckTtmbggd0TSTsu0+S4w/nldoPxTgv6Pnfv6P55PaD8U4L+j537+uet5S7JfU46a2dmN7JM9EvH2WiHQLiz+eV2g/FOC/o+d+/r3+eX2g/FOC/o+b+/rvrmW/gHg1/A7bj7PxjoE4j4RGOgXDf8APL7QfinBf0fO/f0fzy+0H4pwX9Hzv39Rd2Q+7JckF5HdrMNg6BZmJoXBx+eT2g/FOC/o+b+/rE/PH7QfivBv0fN/f1xKf/KR3p5I7vewJB8QXCp+eJx/8V4N+j5v7+vP54XH/wAV4N+j5v7+r4y15kWjuZ0DViYguGv54PH/AMV4N+j5v7+j+eDx78U4N+j5v7+rPFI8p2w2Z2tzXMkYzbQWt16x1JdHeg3Y0+gN9BTflE+UvgPChfEMyD6RGPDiNJys2yCK+itJfHe+8lDnuuIu3XzgO0XEg5kme/FgcKOPgD6FHXVrpIz372+j3ELVziSSSbJNkncknqfVRdoKJ058pnzucyfXBwbGbgQmwMzJDMjNI28TId8fHdzFHX03C5y7Q8byc2Z+VlzzZWTJ9eaeR0sh3JDdTzs3fZo2HRRyFU5Nk9AhCFwAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCABCEIAEIQgAQhCAP/2Q==\n", - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from IPython.display import YouTubeVideo\n", - "YouTubeVideo('gGOzHVUQCw0')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "How would we go about understanding the _trends_ from the data on global temperature?\n", - "\n", - "The first step in analyzing unknown data is to generate some simple plots using **Matplotlib**. We are going to look at the temperature-anomaly history, contained in a file, and make our first plot to explore this data. \n", - "\n", - "We are going to smooth the data and then we'll fit a line to it to find a trend, plotting along the way to see how it all looks.\n", - "\n", - "Let's get started!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Step 1: Read a data file\n", - "\n", - "We took the data from the [NOAA](https://www.ncdc.noaa.gov/cag/) (National Oceanic and Atmospheric Administration) webpage. Feel free to play around with the webpage and analyze data on your own, but for now, let's make sure we're working with the same dataset.\n", - "\n", - "\n", - "We have a file named `land_global_temperature_anomaly-1880-2016.csv` in our `data` folder. This file contains the year on the first column, and averages of land temperature anomaly listed sequentially on the second column, from the year 1880 to 2016. We will load the file, then make an initial plot to see what it looks like.\n", - "\n", - "\n", - "##### Note:\n", - "\n", - "If you downloaded this notebook alone, rather than the full collection for this course, you may not have the data file on the location we assume below. In that case, you can download the data if you add a code cell, and execute the following code in it:\n", - "\n", - "```Python\n", - "from urllib.request import urlretrieve\n", - "URL = 'http://go.gwu.edu/engcomp1data5?accessType=DOWNLOAD'\n", - "urlretrieve(URL, 'land_global_temperature_anomaly-1880-2016.csv')\n", - "```\n", - "The data file will be downloaded to your working directory, and you will then need to remove the path information, i.e., the string `'../../data/'`, from the definition of the variable `fname` below.\n", - "\n", - "Let's start by importing NumPy." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To load our data from the file, we'll use the function [`numpy.loadtxt()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html), which lets us immediately save the data into NumPy arrays. (We encourage you to read the documentation for details on how the function works.) Here, we'll save the data into the arrays `year` and `temp_anomaly`. " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "fname = '../data/land_global_temperature_anomaly-1880-2016.csv'\n", - "\n", - "year, temp_anomaly = np.loadtxt(fname, delimiter=',', skiprows=5, unpack=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Exercise\n", - "\n", - "Inspect the data by printing `year` and `temp_anomaly`." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(137,)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "temp_anomaly.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Step 2: Plot the data\n", - "\n", - "Let's first load the **Matplotlib** module called `pyplot`, for making 2D plots. Remember that to get the plots inside the notebook, we use a special \"magic\" command, `%matplotlib inline`:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `plot()` function of the `pyplot` module makes simple line plots. We avoid that stuff that appeared on top of the figure, that `Out[x]: [< ...>]` ugliness, by adding a semicolon at the end of the plotting command." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(year, temp_anomaly);" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "Now we have a line plot, but if you see this plot without any information you would not be able to figure out what kind of data it is! We need labels on the axes, a title and why not a better color, font and size of the ticks. \n", - "**Publication quality** plots should always be your standard for plotting. \n", - "How you present your data will allow others (and probably you in the future) to better understand your work. \n", - "\n", - "We can customize the style of our plots using parameters for the lines, text, font and other plot options. We set some style options that apply for all the plots in the current session with [`plt.rc()`](https://matplotlib.org/api/_as_gen/matplotlib.plt.rc.html)\n", - "Here, we'll make the font of a specific type and size (serif and 16 points). You can also customize other parameters like line width, color, and so on (check out the documentation)." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "plt.rc('font', family='sans', size='18')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We'll redo the same plot, but now we'll add a few things to make it prettier and **publication quality**. We'll add a title, label the axes and, show a background grid. Study the commands below and look at the result!" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#You can set the size of the figure by doing:\n", - "plt.figure(figsize=(10,5))\n", - "\n", - "#Plotting\n", - "plt.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1) \n", - "plt.title('Land global temperature anomalies. \\n')\n", - "plt.xlabel('Year')\n", - "plt.ylabel('Land temperature anomaly [°C]')\n", - "plt.grid();" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "Better, no? Feel free to play around with the parameters and see how the plot changes. There's nothing like trial and error to get the hang of it. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Step 3: Least-squares linear regression \n", - "\n", - "In order to have an idea of the general behavior of our data, we can find a smooth curve that (approximately) fits the points. We generally look for a curve that's simple (e.g., a polynomial), and does not reproduce the noise that's always present in experimental data. \n", - "\n", - "Let $f(x)$ be the function that we'll fit to the $n+1$ data points: $(x_i, y_i)$, $i = 0, 1, ... ,n$:\n", - "\n", - "$$ \n", - " f(x) = f(x; a_0, a_1, ... , a_m) \n", - "$$\n", - "\n", - "The notation above means that $f$ is a function of $x$, with $m+1$ variable parameters $a_0, a_1, ... , a_m$, where $m < n$. We need to choose the form of $f(x)$ a priori, by inspecting the experimental data and knowing something about the phenomenon we've measured. Thus, curve fitting consists of two steps: \n", - "\n", - "1. Choosing the form of $f(x)$.\n", - "2. Computing the parameters that will give us the \"best fit\" to the data. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### What is the \"best\" fit?\n", - "\n", - "When the noise in the data is limited to the $y$-coordinate, it's common to use a **least-squares fit**, which minimizes the function\n", - "\n", - "$$\n", - "\\begin{equation} \n", - " S(a_0, a_1, ... , a_m) = \\sum_{i=0}^{n} [y_i - f(x_i)]^2\n", - "\\end{equation} \n", - "$$\n", - "\n", - "with respect to each $a_j$. We find the values of the parameters for the best fit by solving the following equations:\n", - "\n", - "$$\n", - "\\begin{equation}\n", - " \\frac{\\partial{S}}{\\partial{a_k}} = 0, \\quad k = 0, 1, ... , m.\n", - "\\end{equation}\n", - "$$\n", - "\n", - "Here, the terms $r_i = y_i - f(x_i)$ are called residuals: they tell us the discrepancy between the data and the fitting function at $x_i$. \n", - "\n", - "Take a look at the function $S$: what we want to minimize is the sum of the squares of the residuals. The equations (2) are generally nonlinear in $a_j$ and might be difficult to solve. Therefore, the fitting function is commonly chosen as a linear combination of specified functions $f_j(x)$, \n", - "\n", - "$$\n", - "\\begin{equation*}\n", - " f(x) = a_0f_0(x) + a_1f_1(x) + ... + a_mf_m(x)\n", - "\\end{equation*}\n", - "$$\n", - "\n", - "which results in equations (2) being linear. In the case that the fitting function is polynomial, we have have $f_0(x) = 1, \\; f_1(x) = x, \\; f_2(x) = x^2$, and so on. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Linear regression \n", - "\n", - "When we talk about linear regression we mean \"fitting a function to the data.\" In this case,\n", - "\n", - "$$\n", - "\\begin{equation}\n", - " f(x) = a_0 + a_1x\n", - "\\end{equation}\n", - "$$\n", - "\n", - "The function that we'll minimize is:\n", - "\n", - "$$\n", - "\\begin{equation}\n", - " S(a_0, a_1) = \\sum_{i=0}^{n} [y_i - f(x_i)]^2 = \\sum_{i=0}^{n} (y_i - a_0 - a_1x_i)^2 \n", - "\\end{equation} \n", - "$$\n", - "\n", - "Equations (2) become:\n", - "\n", - "$$\n", - "\\begin{equation}\n", - " \\frac{\\partial{S}}{\\partial{a_0}} = \\sum_{i=0}^{n} -2(y_i - a_0 - a_1x_i) = 2 \\left[ a_0(n+1) + a_1\\sum_{i=0}^{n} x_i - \\sum_{i=0}^{n} y_i \\right] = 0\n", - "\\end{equation} \n", - "$$\n", - "\n", - "$$\n", - "\\begin{equation}\n", - " \\frac{\\partial{S}}{\\partial{a_1}} = \\sum_{i=0}^{n} -2(y_i - a_0 - a_1x_i)x_i = 2 \\left[ a_0\\sum_{i=0}^{n} x_i + a_1\\sum_{i=0}^{n} x_{i}^2 - \\sum_{i=0}^{n} x_iy_i \\right] = 0\n", - "\\end{equation} \n", - "$$\n", - "\n", - "Let's divide both equations by $2(n+1)$ and rearrange terms.\n", - "\n", - "Rearranging (6) and (7):\n", - "\n", - "$$\n", - "\\begin{align}\n", - " 2 \\left[ a_0(n+1) + a_1\\sum_{i=0}^{n} x_i - \\sum_{i=0}^{n} y_i \\right] &= 0 \\nonumber \\\\ \n", - " \\frac{a_0(n+1)}{n+1} + a_1 \\frac{\\sum_{i=0}^{n} x_i}{n+1} - \\frac{\\sum_{i=0}^{n} y_i}{n+1} &= 0 \\\\\n", - "\\end{align}\n", - "$$\n", - "\n", - "$$\n", - "\\begin{align}\n", - " a_0 = \\bar{y} - a_1\\bar{x}\n", - "\\end{align}\n", - "$$\n", - "\n", - "where $\\bar{x} = \\frac{\\sum_{i=0}^{n} x_i}{n+1}$ and $\\bar{y} = \\frac{\\sum_{i=0}^{n} y_i}{n+1}$.\n", - "\n", - "Rearranging (7):\n", - "\n", - "$$\n", - "\\begin{align}\n", - " 2 \\left[ a_0\\sum_{i=0}^{n} x_i + a_1\\sum_{i=0}^{n} x_{i}^2 - \\sum_{i=0}^{n} x_iy_i \\right] &= 0 \\\\\n", - " a_0\\sum_{i=0}^{n} x_i + a_1\\sum_{i=0}^{n} x_{i}^2 - \\sum_{i=0}^{n} x_iy_i &=0 \\\\\n", - "\\end{align}\n", - "$$\n", - "\n", - "Now, if we replace $a_0$ from equation (8) into (9) and rearrange terms:\n", - "\n", - "$$\n", - "\\begin{align*}\n", - " (\\bar{y} - a_1\\bar{x})\\sum_{i=0}^{n} x_i + a_1\\sum_{i=0}^{n} x_{i}^2 - \\sum_{i=0}^{n} x_iy_i &= 0 \\\\ \n", - "\\end{align*}\n", - "$$\n", - "\n", - "Replacing the definitions of the mean values into the equation, \n", - "\n", - "$$\n", - "\\begin{align*}\n", - " \\left[\\frac{1}{n+1}\\sum_{i=0}^{n} y_i - \\frac{a_1}{n+1}\\sum_{i=0}^{n} x_i \\right]\\sum_{i=0}^{n} x_i + a_1\\sum_{i=0}^{n} x_{i}^2 - \\sum_{i=0}^{n} x_iy_i &= 0 \\\\ \n", - " \\frac{1}{n+1}\\sum_{i=0}^{n} y_i \\sum_{i=0}^{n} x_i - \\frac{a_1}{n+1}\\sum_{i=0}^{n} x_i \\sum_{i=0}^{n} x_i + a_1\\sum_{i=0}^{n} x_{i}^2 - \\sum_{i=0}^{n} x_iy_i &= 0 \\\\ \n", - "\\end{align*}\n", - "$$\n", - "\n", - "Leaving everything in terms of $\\bar{x}$, \n", - "\n", - "$$\n", - "\\begin{align*}\n", - " \\sum_{i=0}^{n} y_i \\bar{x} - a_1\\sum_{i=0}^{n} x_i \\bar{x} + a_1\\sum_{i=0}^{n} x_{i}^2 - \\sum_{i=0}^{n} x_iy_i = 0 \n", - "\\end{align*}\n", - "$$\n", - "\n", - "Grouping the terms that have $a_1$ on the left-hand side and the rest on the right-hand side:\n", - "\n", - "$$\n", - "\\begin{align*}\n", - " a_1\\left[ \\sum_{i=0}^{n} x_{i}^2 - \\sum_{i=0}^{n} x_i \\bar{x}\\right] &= \\sum_{i=0}^{n} x_iy_i - \\sum_{i=0}^{n} y_i \\bar{x} \\\\\n", - " a_1 \\sum_{i=0}^{n} (x_{i}^2 - x_i \\bar{x}) &= \\sum_{i=0}^{n} (x_iy_i - y_i \\bar{x}) \\\\\n", - " a_1 \\sum_{i=0}^{n} x_{i}(x_{i} -\\bar{x}) &= \\sum_{i=0}^{n} y_i(x_i - \\bar{x}) \n", - "\\end{align*}\n", - "$$\n", - "\n", - "Finally, we get that:\n", - "\n", - "$$\n", - "\\begin{align}\n", - " a_1 = \\frac{ \\sum_{i=0}^{n} y_{i} (x_i - \\bar{x})}{\\sum_{i=0}^{n} x_i (x_i - \\bar{x})}\n", - "\\end{align}\n", - "$$\n", - "\n", - "Then our coefficients are:\n", - "\n", - "$$\n", - "\\begin{align}\n", - " a_1 = \\frac{ \\sum_{i=0}^{n} y_{i} (x_i - \\bar{x})}{\\sum_{i=0}^{n} x_i (x_i - \\bar{x})} \\quad , \\quad a_0 = \\bar{y} - a_1\\bar{x}\n", - "\\end{align}\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Let's fit!\n", - "\n", - "Let's now fit a straight line through the temperature-anomaly data, to see the trend over time. We'll use least-squares linear regression to find the slope and intercept of a line \n", - "\n", - "$$y = a_1x+a_0$$\n", - "\n", - "that fits our data.\n", - "\n", - "In our case, the `x`-data corresponds to `year`, and the `y`-data is `temp_anomaly`. To calculate our coefficients with the formula above, we need the mean values of our data. Sine we'll need to compute the mean for both `x` and `y`, it could be useful to write a custom Python _function_ that computes the mean for any array, and we can then reuse it.\n", - "\n", - "It is good coding practice to *avoid repeating* ourselves: we want to write code that is reusable, not only because it leads to less typing but also because it reduces errors. If you find yourself doing the same calculation multiple times, it's better to encapsulate it into a *function*. \n", - "\n", - "Remember the _key concept_ from [Lesson 1](http://go.gwu.edu/engcomp1lesson1): A function is a compact collection of code that executes some action on its arguments. \n", - "\n", - "Once *defined*, you can *call* a function as many times as you want. When we *call* a function, we execute all the code inside the function. The result of the execution depends on the *definition* of the function and on the values that are *passed* into it as *arguments*. Functions might or might not *return* values in their last operation. \n", - "\n", - "The syntax for defining custom Python functions is:\n", - "\n", - "```python\n", - "def function_name(arg_1, arg_2, ...):\n", - " '''\n", - " docstring: description of the function\n", - " '''\n", - " \n", - "```\n", - "\n", - "The **docstring** of a function is a message from the programmer documenting what he or she built. Docstrings should be descriptive and concise. They are important because they explain (or remind) the intended use of the function to the users. You can later access the docstring of a function using the function `help()` and passing the name of the function. If you are in a notebook, you can also prepend a question mark `'?'` before the name of the function and run the cell to display the information of a function. \n", - "\n", - "Try it!" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "?print" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Using the `help` function instead:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on built-in function print in module builtins:\n", - "\n", - "print(...)\n", - " print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n", - " \n", - " Prints the values to a stream, or to sys.stdout by default.\n", - " Optional keyword arguments:\n", - " file: a file-like object (stream); defaults to the current sys.stdout.\n", - " sep: string inserted between values, default a space.\n", - " end: string appended after the last value, default a newline.\n", - " flush: whether to forcibly flush the stream.\n", - "\n" - ] - } - ], - "source": [ - "help(print)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's define a custom function that calculates the mean value of any array. Study the code below carefully. " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "def mean_value(array):\n", - " \"\"\" Calculate the mean value of an array \n", - " \n", - " Arguments\n", - " ---------\n", - " array: Numpy array \n", - " \n", - " Returns\n", - " ------- \n", - " mean: mean value of the array\n", - " \"\"\"\n", - " sum_elem = 0\n", - " for element in array:\n", - " sum_elem += element # this is the same as sum_elem = sum_elem + element\n", - " \n", - " mean = sum_elem / len(array)\n", - " \n", - " return mean\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Once you execute the cell above, the function`mean_value()` becomes available to use on any argument of the correct type. This function works on arrays of any length. We can try it now with our data." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1948.0\n" - ] - } - ], - "source": [ - "year_mean = mean_value(year)\n", - "print(year_mean)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0526277372263\n" - ] - } - ], - "source": [ - "temp_anomaly_mean = mean_value(temp_anomaly)\n", - "print(temp_anomaly_mean)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Neat! You learned how to write a Python function, and we wrote one for computing the mean value of an array of numbers. We didn't have to, though, because NumPy has a built-in function to do just what we needed: [`numpy.mean()`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.mean.html).\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Exercise \n", - "\n", - "Calculate the mean of the `year` and `temp_anomaly` arrays using the NumPy built-in function, and compare the results with the ones obtained using our custom `mean_value` function." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that we have mean values, we can compute our coefficients by following equations (12). We first calculate $a_1$ and then use that value to calculate $a_0$.\n", - "\n", - "Our coefficients are:\n", - "\n", - "$$\n", - " a_1 = \\frac{ \\sum_{i=0}^{n} y_{i} (x_i - \\bar{x})}{\\sum_{i=0}^{n} x_i (x_i - \\bar{x})} \\quad , \\quad a_0 = \\bar{y} - a_1\\bar{x}\n", - "$$ \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We already calculated the mean values of the data arrays, but the formula requires two sums over new derived arrays. Guess what, NumPy has a built-in function for that: [`numpy.sum()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html). Study the code below." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "a_1 = numpy.sum(temp_anomaly*(year - year_mean)) / numpy.sum(year*(year - year_mean)) " - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0103702839435\n" - ] - } - ], - "source": [ - "print(a_1)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "a_0 = temp_anomaly_mean - a_1*year_mean" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-20.1486853847\n" - ] - } - ], - "source": [ - "print(a_0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Exercise\n", - "\n", - "Write a function that computes the coefficients, call the function to compute them and compare the result with the values we obtained before. As a hint, we give you the structure that you should follow:\n", - "\n", - "```python\n", - "def coefficients(x, y, x_mean, y_mean):\n", - " \"\"\"\n", - " Write docstrings here\n", - " \"\"\"\n", - "\n", - " a_1 = \n", - " a_0 = \n", - " \n", - " return a_1, a_0\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now have the coefficients of a linear function that best fits our data. With them, we can compute the predicted values of temperature anomaly, according to our fit. Check again the equations above: the values we are going to compute are $f(x_i)$. \n", - "\n", - "Let's call `reg` the array obtined from evaluating $f(x_i)$ for all years." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "reg = a_0 + a_1 * year" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With the values of our linear regression, we can plot it on top of the original data to see how they look together. Study the code below. " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAogAAAFOCAYAAAAFEOyOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzMzMzEr+D3e5KbvwEdppAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 5))\n", - "\n", - "plt.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1, alpha=0.5) \n", - "plt.plot(year, reg, 'k--', linewidth=2, label='Linear regression')\n", - "plt.xlabel('Year')\n", - "plt.ylabel('Land temperature anomaly [°C]')\n", - "plt.legend(loc='best', fontsize=15)\n", - "plt.grid();" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Step 4: Apply regression using NumPy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Above, we coded linear regression from scratch. But, guess what: we didn't have to because NumPy has built-in functions that do what we need!\n", - "\n", - "Yes! Python and NumPy are here to help! With [`polyfit()`](https://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.polyfit.html), we get the slope and $y$-intercept of the line that best fits the data. With [`poly1d()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.poly1d.html), we can build the linear function from its slope and $y$-intercept.\n", - "\n", - "Check it out:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# First fit with NumPy, then name the coefficients obtained a_1n, a_0n:\n", - "a_1n, a_0n = numpy.polyfit(year, temp_anomaly, 1)\n", - "\n", - "f_linear = numpy.poly1d((a_1n, a_0n)) " - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0103702839435\n" - ] - } - ], - "source": [ - "print(a_1n)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-20.1486853847\n" - ] - } - ], - "source": [ - "print(a_0n)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "0.01037 x - 20.15\n" - ] - } - ], - "source": [ - "print(f_linear)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAogAAAFOCAYAAAAFEOyOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzMzMzEr+D3e5KbvwEdppAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 5))\n", - "\n", - "plt.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1, alpha=0.5) \n", - "plt.plot(year, f_linear(year), 'k--', linewidth=2, label='Linear regression')\n", - "plt.xlabel('Year')\n", - "plt.ylabel('Land temperature anomaly [°C]')\n", - "plt.legend(loc='best', fontsize=15)\n", - "plt.grid();" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## \"Split regression\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you look at the plot above, you might notice that around 1970 the temperature starts increasing faster that the previous trend. So maybe one single straight line does not give us a good-enough fit.\n", - "\n", - "What if we break the data in two (before and after 1970) and do a linear regression in each segment? \n", - "\n", - "To do that, we first need to find the position in our `year` array where the year 1970 is located. Thankfully, NumPy has a function called [`numpy.where()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html) that can help us. We pass a condition and `numpy.where()` tells us where in the array the condition is `True`. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([90]),)" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.where(year==1970)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To split the data, we use the powerful instrument of _slicing_ with the colon notation. Remember that a colon between two indices indicates a range of values from a `start` to an `end`. The rule is that `[start:end]` includes the element at index `start` but excludes the one at index `end`. For example, to grab the first 3 years in our `year` array, we do:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 1880., 1881., 1882.])" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "year[0:3]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we know how to split our data in two sets, to get two regression lines. We need two slices of the arrays `year` and `temp_anomaly`, which we'll save in new variable names below. After that, we complete two linear fits using the helpful NumPy functions we learned above." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "year_1 , temp_anomaly_1 = year[0:90], temp_anomaly[0:90]\n", - "year_2 , temp_anomaly_2 = year[90:], temp_anomaly[90:]\n", - "\n", - "m1, b1 = numpy.polyfit(year_1, temp_anomaly_1, 1)\n", - "m2, b2 = numpy.polyfit(year_2, temp_anomaly_2, 1)\n", - "\n", - "f_linear_1 = numpy.poly1d((m1, b1))\n", - "f_linear_2 = numpy.poly1d((m2, b2))" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAogAAAFOCAYAAAAFEOyOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 5))\n", - "\n", - "plt.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1, alpha=0.5) \n", - "plt.plot(year_1, f_linear_1(year_1), 'g--', linewidth=2, label='1880-1969')\n", - "plt.plot(year_2, f_linear_2(year_2), 'r--', linewidth=2, label='1970-2016')\n", - "\n", - "plt.xlabel('Year')\n", - "plt.ylabel('Land temperature anomaly [°C]')\n", - "plt.legend(loc='best', fontsize=15)\n", - "plt.grid();" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We have two different curves for two different parts of our data set. A little problem with this and is that the end point of our first regression doesn't match the starting point of the second regression. We did this for the purpose of learning, but it is not rigorously correct. We'll fix in in the next course module when we learn more about different types of regression. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## We learned:\n", - "\n", - "* Making our plots more beautiful\n", - "* Defining and calling custom Python functions\n", - "* Applying linear regression to data\n", - "* NumPy built-ins for linear regression\n", - "* The Earth is warming up!!!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## References\n", - "\n", - "1. [_Essential skills for reproducible research computing_](https://barbagroup.github.io/essential_skills_RRC/) (2017). Lorena A. Barba, Natalia C. Clementi, Gilbert Forsyth. \n", - "2. _Numerical Methods in Engineering with Python 3_ (2013). Jaan Kiusalaas. Cambridge University Press.\n", - "3. _Effective Computation in Physics: Field Guide to Research with Python_ (2015). Anthony Scopatz & Kathryn D. Huff. O'Reilly Media, Inc.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "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.6.7" - }, - "widgets": { - "state": {}, - "version": "1.1.2" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -}