{"cells":[{"cell_type":"markdown","source":[" Python en ciencias e ingeniería: tutoriales basados en ejemplos por Sergio Gutiérrez Rodrigo y Adrián Navas Montilla se distribuye bajo una Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional."],"metadata":{"id":"ZyYxarWXICGB"}},{"cell_type":"markdown","source":["---\n","Programa de Recursos en Abierto en la UZ (2022)\n","\n","**Python en ciencias e ingeniería: tutoriales basados en ejemplos**\n","---\n","Universidad de Zaragoza\n","---\n","*PRAUZ-739*\n"],"metadata":{"id":"cU67irCkAoSz"}},{"cell_type":"markdown","metadata":{"id":"N6JfZSJ8QwIZ"},"source":["##
Ejemplos de introducción al lenguaje de programación Python mediante Jupyter
\n","\n","\n","-----------------------------------------\n"]},{"cell_type":"markdown","metadata":{"id":"vWfL1ihgiicb"},"source":["\n"," ---\n","0. [Trucos y recomendaciones](#trucos)\n","1. [Variables](#variables)\n","2. [Operadores](#operadores) \n","3. [Cadenas de caracteres](#cadenacaracteres)\n","4. [Control del flujo](#flujo)\n","5. [Tipos de datos Phyton](#tipos)\n","6. [Funciones](#funciones)\n","7. [Bibliotecas](#bibliotecas)\n"," 1. [Trabajar con vectores y matrices: numpy](#numpy)\n"," 2. [Representación gráfica: matplotlib](#matplotlib) "]},{"cell_type":"markdown","metadata":{"id":"nghZYUY3iicg"},"source":["# Variables "]},{"cell_type":"code","execution_count":null,"metadata":{"id":"7pN3XxAJiicg","outputId":"4171eb8c-83bb-4418-d569-166d18ab01d6"},"outputs":[{"name":"stdout","output_type":"stream","text":["42 3.1416 3.14 (3+7j) Ejemplo de cadena de caracteres \n","\n","\n","\n","\n"]}],"source":["a = 42 #entero\n","b = 3.1416 #real\n","bexp = 3.14e0 #exponencial\n","c = 3+7j #complejo\n","d = \"Ejemplo de cadena de caracteres \" #Cadena de caracteres\n","\n","#Imprimir por pantalla\n","print (a,b,bexp,c,d)\n","\n","#Tipos de variables\n","print (type(a))\n","print (type(b))\n","print (type(c))\n","print (type(d))"]},{"cell_type":"markdown","metadata":{"id":"YEpVA1qDiici"},"source":["# Operadores "]},{"cell_type":"code","execution_count":null,"metadata":{"id":"wOaRV9Smiici","outputId":"aa338757-e4b1-4be6-95ad-9e684eb50fa4"},"outputs":[{"name":"stdout","output_type":"stream","text":["a= 3.0 b= 2.0\n","a+b= 5.0\n","a-b= 1.0\n","a*b= 6.0\n","a/b= 1.5\n","División entera a/b= 1.0\n","a^b= 9.0\n"]}],"source":["a,b=3.0,2.0\n","\n","suma=a+b\n","resta=a-b\n","multip=a*b\n","div=a/b\n","div_entera=a//b\n","exp=a**b\n","\n","print('a=',a,'b=',b)\n","print(\"a+b=\",suma)\n","print(\"a-b=\",resta)\n","print(\"a*b=\",multip)\n","print(\"a/b=\",div)\n","print(\"División entera a/b=\",div_entera)\n","print(\"a^b=\",exp)\n"]},{"cell_type":"markdown","metadata":{"id":"6P502BX0iicj"},"source":["# Cadena de caracteres \n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"9i6QCrUOiicj","outputId":"c7cf0866-a43e-4e0b-f922-166ca5d919df"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hola\n"," \t Este es un ejemplo de cadena de caracteres \n"," Es posible escribir saltos de linea sin necesidad de utilizar los códigos \n","de escape\n","Hola\n","\t Este es un ejemplo de cadena de caracteres \n"," repite repite repite repite repite repite \n"]}],"source":["a= \"Hola\\n\"\n","b = \"\\t Este es un ejemplo de cadena de caracteres \\n\"\n","c = \"\"\" Es posible escribir saltos de linea sin necesidad de utilizar los códigos \n","de escape\"\"\"\n","\n","print(a,b,c)\n","\n","d= a + b #concatenación\n","e = \" repite \"\n","f = 3*e #repetición\n","g = e*3 #equivale a lo anterior\n","\n","print(d,f,g)"]},{"cell_type":"markdown","metadata":{"id":"RFqe-hyCiick"},"source":["# Control de flujo \n","\n","* Sentencias condicionales: if-elif-else\n","* Secuencias iterativas: bucles\n"," - Bucles for...in\n"," - Bucles while\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"qyH_2nkHiick","outputId":"a57d34a0-66cb-4ca8-afd7-5c099352ace4"},"outputs":[{"name":"stdout","output_type":"stream","text":["Ejemplo 1: usos del if\n","-27.0 es un número negativo.\n","\n"," Ejemplo 2: usos del if\n","Tipo de variable= \n","37.0 es un número real\n"]}],"source":["# Usos del if\n","'''\n","Ejemplo: ¿contiene la variable un número negativo?\n","'''\n","print(\"Ejemplo 1: usos del if\")\n","a=-27.0\n","if(a<0.0): #Los paréntesis no son necesarios\n"," print(a,\" es un número negativo.\")\n","elif (a==0):\n"," print(a,\" es cero.\")\n","else:\n"," print(a,\" es un número positivo.\")\n","\n","'''\n","Ejemplo: utilizando la función isintance() nos preguntamos si la variable\n","a contiene un número real\n","'''\n","print(\"\\n Ejemplo 2: usos del if\")\n","a=37.0\n","print(\"Tipo de variable=\",type(a))\n","if(isinstance(a,float)):\n"," print(a,\" es un número real\")\n","else:\n"," print(a,\" no es un número real\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"kHbBmhp7iicl","outputId":"1b764818-2feb-42d2-9659-f155533435ba"},"outputs":[{"name":"stdout","output_type":"stream","text":["Ejemplo 1: bucle for\n","De los siguientes números [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] comprobamos cuáles son negativos\n","-5 es un número negativo.\n","-4 es un número negativo.\n","-3 es un número negativo.\n","-2 es un número negativo.\n","-1 es un número negativo.\n","\n"," Ejemplo 2: bucle for\n","-5 es un número negativo.\n","-4 es un número negativo.\n","-3 es un número negativo.\n","-2 es un número negativo.\n","-1 es un número negativo.\n","\n"," Ejemplo 3: bucle for\n","manzana\n","pera\n","gato\n"]}],"source":["#Bucle for\n","'''\n","Ejemplo: utilizando el método range proporciona una lista de números,\n","comprobamos si un número es postivo o negativo\n","'''\n","print(\"Ejemplo 1: bucle for\")\n","\n","rango=list(range(-5,5)) # Más adelante entenderemos qué hace el método list\n","\n","print(\"De los siguientes números \",rango,\"comprobamos cuáles son negativos\")\n","for a in range(-5,5):\n"," if(a<0.0): #Los paréntesis no son necesarios\n"," print(a,\" es un número negativo.\") \n","\n","'''\n","Ejemplo: una forma compacta de escribir el mismo loop..\n","''' \n","print(\"\\n Ejemplo 2: bucle for\")\n"," \n","[print(a,\" es un número negativo.\") for a in range(-5,5) if(a < 0.0)]\n","\n","'''\n","Ejemplo: Python permite bucles en cualquier objeto que sea iterable\n","''' \n","print(\"\\n Ejemplo 3: bucle for\")\n","\n","lista = [\"manzana\",\"pera\",\"gato\"] #Más adelante veremos qué tipo de dato representa lista\n","\n","for palabra in lista:\n"," print(palabra)\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"BiYwiDKEiicl","outputId":"78a411bf-9ec7-49f0-92f4-7243a322a430"},"outputs":[{"name":"stdout","output_type":"stream","text":["Ejemplo 1: bucle for\n","2\n","4\n","6\n","8\n","10\n","12\n","14\n","16\n","18\n","20\n"]}],"source":["# Bucle while\n","'''\n","Ejemplo: Se representan los números pares empezando por 2 hasta llegar al número 20 (incluido).\n","OJO: los bucles while producen fácilmente bucles infinitos. En el ejemplo ocuure si se elimina \n","la condición de parar cuando el número llega a 20.\n","'''\n","print(\"Ejemplo 1: bucle for\")\n","\n","nopar= 2\n","\n","while (nopar > 0):\n"," print (nopar)\n"," nopar = nopar + 2\n"," if (nopar > 20):\n"," break"]},{"cell_type":"markdown","metadata":{"id":"g37Li_NYiicl"},"source":["# Algunos tipos de datos en Python \n","* Tuplas\n","* Listas\n","\n","Información adicional sobre otros tipos de datos: \n","https://docs.python.org/3/tutorial/datastructures.html"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"YIUA8W32iicl","outputId":"9acf066b-5cd4-41f7-f605-1ffb7b57cc95"},"outputs":[{"name":"stdout","output_type":"stream","text":["Tuplas\n","(1, 2, 3, 4, 6)\n","(1, 2)\n","(1, 2, 3, 4, 6)\n","('hola', 2, 3)\n","(('hola', 2, 3), 90)\n","('e', 'j', 'e', 'm', 'p', 'l', 'o')\n"]}],"source":["# Tuplas\n","'''\n","Un tupla es una secuencia inmutable y ordenada de elementos. Pueden ser de \n","de cualquier tipo (básico o no). Se pueden indexar.\n","Sintaxis para declarar una tupla: especificar los elementos separados por una coma (,)\n","'''\n","tupla_vacia = ( )\n","tupla1 = 1 ,2 ,3 ,4 ,6 ,\n","tupla1b = (1 , 2 , 3 , 4 , 6)\n","tupla2 = \"hola\" , 2 ,3\n","tupla3 = tupla2 , 90\n","tupla4 = tuple (\"ejemplo\")\n","\n","print(\"Tuplas\")\n","print(tupla1)\n","print(tupla1[0:2])\n","print(tupla1b)\n","print(tupla2)\n","print(tupla3)\n","print(tupla4)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"HNA-LBMuiicm","outputId":"af58aa28-a3d2-4918-d47c-0db7775e6a14"},"outputs":[{"name":"stdout","output_type":"stream","text":["Listas\n","[1, 2, 3, 4, 6]\n","[1, 2]\n","lista2= ['hola', 2, 3]\n","['hola', 2, 3, 90]\n","['e', 'j', 'e', 'm', 'p', 'l', 'o']\n"]}],"source":["# Listas\n","'''\n","Una lista es una secuencia mutable y ordenada de elementos. Sus elementos \n","se pueden modificar a diferencia de las tuplas. Se pueden indexar.\n","Sintaxis para declarar una lisat: los elementos de la lista se seprar usando comas.\n","Se especifica que es una lista cerrando el conjunto entre corchetes [,].\n","'''\n","lista_vacia = []\n","lista1 = [1 ,2 ,3 ,4 ,6]\n","lista2 = [\"hola\" , 2 ,3]\n","lista3 = lista2+[90]\n","lista4 = list(\"ejemplo\")\n","print(\"Listas\")\n","print(lista1)\n","print(lista1[0:2])\n","print(\"lista2=\",lista2)\n","print(lista3)\n","print(lista4)"]},{"cell_type":"markdown","metadata":{"id":"IFrjugMDiicm"},"source":["# Funciones "]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vlrH4VYSiicm","outputId":"dd8e3be4-102b-46da-a8a9-007e4b03b53b"},"outputs":[{"name":"stdout","output_type":"stream","text":["Ejemplo 1: funciones\n","De los siguientes números [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] comprobamos cuáles son negativos\n","-5 es un número negativo.\n","-4 es un número negativo.\n","-3 es un número negativo.\n","-2 es un número negativo.\n","-1 es un número negativo.\n","\n"," Ejemplo 2: funciones\n","Polinomio de grado n=2\n"," y coeficientes [$a_0,a_{1},..,a_{n-1},a_n$]=[1.0, 1.0, 1.0], en x=2.0 tiene un valor igual a =7.0\n","\n"," Ejemplo 3: funciones\n","Para la condición inicial (y0,v0)=( 100.0 m, 50.0 m/s)\n","La velocidad para un cuerpo en caída libre en t= 5 (s), será de 227.375 m/s\n"]}],"source":["# Funciones\n","'''\n","Ejemplo: encapsulamos parte del código de los ejemplos previos en una función\n","'''\n","print(\"Ejemplo 1: funciones\")\n","\n","def isnegative(x):\n"," if(a<0.0): #Los paréntesis no son necesarios\n"," print(a,\" es un número negativo.\") \n","\n","rango=list(range(-5,5)) # Más adelante entenderemos qué hace el método list\n","\n","print(\"De los siguientes números \",rango,\"comprobamos cuáles son negativos\")\n","for a in range(-5,5):\n"," isnegative(a)\n","\n","\n","'''\n","Ejemplo: cálculo de un polinomio de grado n\n","'''\n","print(\"\\n Ejemplo 2: funciones\")\n","\n","def polynomial(x,a): \n"," result=0\n"," n=len(a)-1 \n"," i=0\n"," for factor in a:\n"," result=result+factor*x**i\n"," i=i+1\n"," return result\n","\n","a=[1.0,1.0,1.0] # a_0*x**(0)+a_1*x**(1)+...a_n*x**n, donde n=len(a)\n","x=2.0\n","pol_x=polynomial(x,a)\n","txt=\"Polinomio de grado n=\"+str(len(a)-1)+\"\\n y coeficientes [$a_0,a_{1},..,a_{n-1},a_n$]=\"+str(a)\n","txt=txt+\", en x=\"+str(x)+\" tiene un valor igual a =\"+str(pol_x)\n","print(txt)\n","\n","'''\n","Ejemplo: cuerpo caída libre\n","'''\n","print(\"\\n Ejemplo 3: funciones\")\n","def y_t(t,y0,v0):\n"," g=9.81 \n"," return y0+v0*t-0.5*g*t**2 \n","y0=100.0 #m\n","v0= 50.0 #m/s\n","t = 5 #s\n","print(\"Para la condición inicial (y0,v0)=(\",y0,\"m,\",v0,\"m/s)\")\n","print(\"La velocidad para un cuerpo en caída libre en t=\",t,'(s), será de',y_t(t,y0,v0),\n"," 'm/s')"]},{"cell_type":"markdown","metadata":{"id":"6q6ekeK7iicn"},"source":["# Bibliotecas \n"]},{"cell_type":"markdown","metadata":{"id":"Vj_cKu_Viicn"},"source":["\n","## Numpy \n","\n","https://numpy.org/doc/stable/user/whatisnumpy.html"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"R58tU50Siicn","outputId":"be5792e9-32f3-4c71-d0be-953b2fd249d5"},"outputs":[{"name":"stdout","output_type":"stream","text":["\n"," Ejemplo 1: Ejemplos básicos\n","Dimensión= 2 Shape= (3, 4) Tipo= int32\n","[[1 2 3 4]\n"," [1 2 3 4]\n"," [1 2 3 4]]\n","[[0. 0. 0. 0.]\n"," [0. 0. 0. 0.]\n"," [0. 0. 0. 0.]]\n","[[1. 0. 0.]\n"," [0. 1. 0.]\n"," [0. 0. 1.]]\n","\n"," Ejemplo 2: operaciones con vectores de tipo element-wise \n","[ 0. 1.05263158 2.10526316 3.15789474 4.21052632 5.26315789\n"," 6.31578947 7.36842105 8.42105263 9.47368421 10.52631579 11.57894737\n"," 12.63157895 13.68421053 14.73684211 15.78947368 16.84210526 17.89473684\n"," 18.94736842 20. ]\n","[ 100. 99.82825485 88.7867036 66.87534626\n"," 34.09418283 -9.5567867 -64.07756233 -129.46814404\n"," -205.72853186 -292.85872576 -390.85872576 -499.72853186\n"," -619.46814404 -750.07756233 -891.5567867 -1043.90581717\n"," -1207.12465374 -1381.2132964 -1566.17174515 -1762. ]\n"]}],"source":["import numpy as np # numpy es la biblioteca con la que crear y operar con vectores/matrices y en general \"tensores\"\n","\n","'''\n","Ejemplos básicos\n","'''\n","print(\"\\n Ejemplo 1: Ejemplos básicos\")\n","x=np.array([[1,2,3,4],[1,2,3,4],[1,2,3,4]])\n","print(\"Dimensión=\",x.ndim,\"Shape=\",x.shape,\"Tipo=\",x.dtype)\n","print(x)\n","y=np.zeros(x.shape) # Crear una matriz con las mismas características que otra y rellenarla de ceros\n","print(y)\n","z=np.identity(3) # Crea una matriz identidad nxn. En el ejemplo n=3\n","print(z)\n","\n","'''\n","Ejemplos : operaciones con vectores de tipo element-wise \n","'''\n","print(\"\\n Ejemplo 2: operaciones con vectores de tipo element-wise \")\n","tmin,tmax= 0.0,20.0 #s\n","nopto=20\n","t=np.linspace(tmin,tmax,nopto) #Se define un vector de dimensión (nopto,), con valores en el intervalo [tmin,tmax]\n","y=np.array(t) # copia el vector, matriz, en general tensor t.\n","\n","def y_t(t,y0,v0):\n"," g=9.81 \n"," return y0+v0*t-0.5*g*t**2 \n","\n","y0=100.0 #m\n","v0= 5.0 #m/s\n","\n","'''\n","Python permite cálculos \"element-wise\": un cálculo elemento a elemento de un vector. \n","No hay problema en sustituir en un función lo que \n","en principio son escalares (el tiempo t), por un vector/matriz/.... De la misma forma,\n","el resultado de la función que en principio es un escalar, puede devolver un vector/matriz/...\n","'''\n","y=y_t(t,y0,v0) \n","print(t)\n","print(y)"]},{"cell_type":"markdown","metadata":{"id":"vLHzFpHpiicn"},"source":["## Matplotlib \n","\n","https://matplotlib.org/stable/index.html"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"qkd95L2eiico","outputId":"028826c7-e918-4be1-d222-ab602e4b4570"},"outputs":[{"name":"stdout","output_type":"stream","text":["\n"," Ejemplo 1: cuerpo en caída libre\n","Para la condición inicial (y0,v0)=( 100.0 m, 5.0 m/s)\n"]},{"name":"stderr","output_type":"stream","text":["No handles with labels found to put in legend.\n"]},{"data":{"image/png":"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\n","text/plain":[""]},"metadata":{"needs_background":"light"},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["\n"," Ejemplo 2: representación de un polinomio\n","Polinomio de grado n=2 \n"," y coeficientes [$a_0,a_{1},..,a_{n-1},a_n$]=[0.0, 1.0, -1.0]\n"]},{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAf0AAAH0CAYAAAA3w/RAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3gV1drG4d9KIRB6lSMkwQZWREFBRT1WEBRQBJEoKEizcOwKsaDnRFRERf1URECUDSggvSgW7IKgFCugmBBBBKSnJ+v7Y7JnBwUMIcns8tzXlctZszfJm4g+mTVrvWOstYiIiEj4i/K6ABEREakYCn0REZEIodAXERGJEAp9ERGRCKHQFxERiRAKfRERkQih0BcREYkQCn0RiXjGmJrGmKXGmD3GmJO9rkekvCj0RUQgE+gITPO6EJHypNAXkbBQdKX+tDFmhTFm8KH8WWttnrV2S3nVVlYO53sUAYW+iIQBY0w9oC7wMHABzlV7WImE71HKX4zXBYiEMmPMMABr7TBvKwmuWjzQHJhird1tjGkK/OJ/wRjTkP1P219trf29NF/Mo5/1Ab9HkZLSlb5EJGNMA2PMbGPMZmPMLmPMHGNMjWD5WsaYJ40xM4qNRxhj3jfGxJZHjaVRkT/Doq93sJ9Jc+DropdOA1b532et/d1a23Y/H6UK/EOot6z/vR/wexQpKYW+RKoawPNAItAEqAcMCKKv9QRwgTGmhTFmINAeuMpam1dONZZGRf4M4eA/k1OAFUXvK1UgGmPmA5cCY4wxN5RBvWX97/2wv0cRTe9LRLLWrgPWFQ1zjDGLgNoAxphU4DxgM9DLWptZjl+rJrAIOBFoY639tujPbDPGPAu8DtQE2lprdx5OHWXtYN/X4SjNz8Ra27dYXfeX5utaazscbu1/+XyH/PMp7+9RRFf6EpGMMd2MMZ8ZY/4wxuwA7gfWFO3RPsZaey7wHtBnP392rjFmR7E/d79/bIyZW9KvVfTywbaKfYNzdTfEWrvhAN/HIdVSlv7h+zoch/UzKS9l/O/9YDz7HiUCWGv1oY+I+gAuxFkEdQbObFcMkAG0AAYBvYvel4SzcOpgn2sYMKw0X+sv73sNOLnY+BRgY9H590r4fR20lor6GRa9vhR4Gmc6enApv8Zh/0zK8fs/rH/vB/r5BNP3qI/w/NCVvkSiU4ENwI84063jgAbA90Vj/zT6TqBOOX6t/TLGNALmAAOBm4FTjDH/Psw6ytoBv6/y2FoWIj+T4g755xOC36OEIIW+RCIfEAv8DswF1gLfW2tzge0491Ip+uef5fi1/qZodfd84Glr7WzrrCcYAaQeZh3+z7/AGDP0cM9z8O/L3VoG1Ocv2+eMMZ/u56PhQWou159JOTmkn0+Ifo8Sgoy11usaRIKGMcZ/L7WnMaY/EGetfb4Cvu5rwFO2aNFaKDPG3A5ssNZON8ZcA9Sx1r5Uis/zGmHyMymurH4+IqWhK32RYqy1q4E0Y8wnQDucadlyVQ5bxbwWjNvngom23olndKUvIiISIXSlLyIiEiEU+iIiIhFCoS8iIhIhFPoiIiIRIux779erV882adLE6zJEREQqxPLly7daa+vv77WwD/0mTZqwbNkyr8sQERGpEMaYtAO9pul9ERGRCKHQFxERiRAKfRERkQih0BcREYkQCn0REZEIodAXERGJEAp9ERGRCKHQFxERiRAKfRERkQih0BcREYkQCn0REZEIodAXERGJEAp9ERGRCKHQFxERiRAKfRERkQgRcqFvjGlvjPnJGLPOGHO/1/WIyP75fNCkCURFOf+8+eZDG/t83tUuEq6MtdbrGkrMGBMNrAEuATKAr4BrrbXfH+jPtGrVyi5btqyCKhSJHD4fpKRAejokJkKHDjB/nmVv+jZOr7GOhnt/pknBOo5gM7XZTm22U4sdVCabQqKwGAqJIpvKbKUeW6nHFurzOw1Zy3H8EtOM7TWS2Lo9msRESE2F5GSvv2uR4GeMWW6tbbW/12IqupjDdCawzlr7C4AxZgrQGThg6ItI2fP5oH9/qJr5Bx1YyplpSznzpaX8l6+oy5+wqwy+SD5k/xnHGpqyNO1MFvc+m+dvPZuvdjQlISlKvwSIlEKohX4jYEOxcQbQ2qNaRCKKzwcPD83jyPQv6WAW8KldwGmsKNevWZkcmrOa5qzmpoKxsAO2UYdFaZfwbp8rWPF+e6Z+UNedbdAvAiIHF2rT+92Adtbam4rG1wNnWmtv+8v7+gP9ARITE1umpaVVeK0ioc4/fZ+RVsAVNRbTeY+PLoVvU4udB/1ze6jKOo51PzJozHZqs4NabKc2WVTBYImikCgKiSezaHJ/K/XZQgIbaMZPNOMnGrL5oF+rgCg+4xzeojuTuZbdsXWpUQP+/FO/BEjkOtj0fqiF/lnAMGttu6LxEABr7fAD/Rnd0xc5dD4fPHXTj/TMHktPJtGIjft9Xy6xLKMVS2jNUs5kCa1Zz1GAKZM6arKDU1nJWXzB2XzO2XxOPbYdsJa5XM4EejOfDuQTS3w8vPKKgl8iSziFfgzOQr6LgN9wFvL1tNZ+d6A/o9AX+Wf+q/oNaYVc32Ah129/jovy3tnve9NJYAGXsYDLeJ+L2EP1/b4vNpZ9rro7dID58/+y8O8A4zp1YPduyM3962e1NGcVHZnHFcyhNUuI4u//D8ugES9wK6/Qn13RdSgs1JW/RI6DhT7W2pD6ADrgBP/PQMo/vb9ly5ZWRA5s4kRra1bJsf152f7EcdbC3z42U98+y2DbiqUWCt2XoqOtNcbapCRrBw1y/ukfT5x4+HX5P1/dutZWqrRvWcZYW5/NdiAv2i9ovd+69xBvn+cWezTrLFgbH3/4dYkEO2CZPVCGHuiFcPlQ6Iv8nT9QK5FjB5jR9lcS/xaYBRg7g872MubZGHL/lqkVHaDFfwnw/5IRHx+opxk/2FSG2I00/Nv3kke0HUNfm0DaPr+o6BcACUcKfRFxTZxobdUqBbY34+16kv4WkNupaZ/iTnsUP+/zUmysc8UdTIG5v9mASmTbXrxmV9D8b99bNpXsc9xqj2CTrvwlbB0s9EOuI5+IHLri3fFG9/qMxVln8ho30oTAzpYt1OMenqQxGdzNSHbVPZqkJDAGkpJg/HjYuhUKC+HXX4Pj3nhyslNLYaFT27hx8K+kON4wvWkZtYKLeI/3udB9fxy53MYLrONY7uNx8jNzSEnxrn6RiqbQFwlz/kY6BWkbmGh78nFhW1qx3H19C/W4lyc4ivU8xT3spRrx8TBqVCBQgyXk/0nxXwImvG74Mv4iLuZ9LuR9vqCN+75q7OVxhrCaUzghbYFa/0rEUOiLhLkHhhZyY+YL/MAJ9GSyez6LyjzKgxzFekZwL9nR1dyr+nDY5pac7HwfSUmw2FzIuVGf05G5rOZk9z1NWcsCOjDDdiY/LYP+/RX8Et4U+iJhyD+df7z5iTfSz+MFbqMae93X36Q7x/MjD/Ooe2U/YUJoXdWXxF+v/BfHd+Q0vmEwo9hBTfd9nZnNd5zENZnj6N3L6spfwpZCXyTM+HwwsF8BPdIeZwWn0pbP3Ne+40TOZzE9eJPfopPC6sr+n/iv/BsnxfCCGUxT1vAqfd3Xa7KLcfRlbuFlNLIbSEtDV/4SdkKqOU9pqDmPRJqzGm9g+G/X828+cs/lEcNwhpBKCrnEqVMdzpV8Whq05RPG0YfjWOe+tovqDORlJtOTpCRntkAkVBysOY+u9EXCgH86/yozg3m/nbpP4C+jJS1ZzsM8Sp6Ji5gr+3+Smgrx8fAp53IqK3mG2yksah9cg91MIplX6cuWtL2a7pewodAXCXE+H9zWL5v70wbyNldRh+2A8zCahxlGG75kNc1JSgq/e/aHo/hCv2wTzz3Rz3Aun7COY9z39GUcX3EGJ9pvNd0vYUGhLxLiXrhvA+9knctARrvn0kjkfD7iUR6mgBji450rW9nXPgv9JsCK+HM4na/x0dN9z4n8wFecwfW8TmYm2tcvIU2hLxKC/NP5F5jFzPqtJWcQWLcylatpwQo+o21ELdQ7XP4r/zpJNbieifRhLJlUAaAK2bxOb57mDn5Ly/e4UpHSU+iLhBifD/r3s3ROG8UiLqYBWwBnsd6tPE933mIHtTWdXwrulb81fJDUh5Ys51tOcl+/g2dZSHvqmW26xy8hSaEvEmIeHprHM1kDGMXtxFAAwGYacCEf8H/cChhN55eB1FRIjz+Bs/iCt7nSPX8R77OUM6ia9p3u8UvIUeiLhJLdu3kh/Qr6M8Y9tYQzaclyPuVcTeeXIf90f92k6nRjGo+YYe5rR7OezziHMzIX6x6/hBSFvkgI8PmgTeMMVtQ4l/a8455/g+s4j4/5jcaazi8H/un+AhvFIzxMF2awm2oA1GIn79COs9Ima0ufhAyFvkiQ8/ng2Zu+ZdpvbWjBSvf8IzxEL153m+1oOr98JSbCLLpwLp+wkX8BzlP7JtOTu+wI0tKspvsl6Cn0RYLcW3cv5Z3s82jMb4CzYO9GxvHf6Ecwxmg6v4L4m/mspAVn8QXfc4L72gju5WnuJDPTarpfglqM1wWIyEEsXszE36+gOnsApz3sVbzN+1yMKXSm86Vi+H+pSkmB9PQkzrGfMZMunM/HgLOyvyp7uTntJSDau0JFDkJX+iJByOeDPg3mkn1Bezfwt1KXC/iQ97kYcKabpWIVb+ZTM6k27XiHaXR1X+/PGCaY3sSafN3jl6Ck0BcJMj4fLOgzldFbrqQyOQD8xpGcx8d8TUsA3cMPAqmpEB1fmR5MYQK93PPJ1sebdGdTWo7u8UvQUeiLBJlPbp/Oa7nXEovT+e1njqYtn7Im+kRtyQsixR/V24fxvGwGuq9dxQym05W8zFzd45egokfrigSTmTPJu7KbG/g/cDwX8T6bOBJjdA8/mEUZywju5i6eds/NoAvX8Ba5NtbDyiTS6NG6IkHO54O+DeaQe2V3N/B/pBkX8CGbOBLQPfxgl5hkuJunSGWoe+5KZvJ2/HWQr379EhwU+iIe8/lgWt8FvLjlaiqRB8AajuNCPmAzDQHdww8FzpY+wwP8jxHc7Z6/PPMt3q51IzGmQIv7xHMKfRGPvX3XZ/hyuhJHLuDcw7+QD/gj+kjdww8h/nv8SUmG+3iS8dUHu69dtXciLzFQDXzEc7qnL+Kl1avZ3vw8arMDgPU04Xw+YgOJuocf6qzFV2MQyXtGu6ceYwgpPEZSkrP1T6Q86J6+SJDx+eDcRr+wsXk7N/A304BLWMQGnJv3uocf4oyh154XeY3e7qmhDGcwo0hP97AuiWgKfZEK5vPBg/1+Z/zGSzmSTQDspAbtWcjPHAvoHn64SEiK4iZeZQ6Xu+dGcTvXoof0iDcU+iIVLHXIHqZldeBYfgYgmzg6MZvV0afpHn6YSU2FuPgYruFNPuNs9/x425uL7bukpaF7/FKhFPoiFamggCc2XMvpfOMMieIa3uRjzqewUI/GDTf+xX0NkuLpxBy+40QAKpHHdLrSnJVkZqIGPlJhFPoiFemOO7iCue5wIC8zm86A7uGHK3+//m22Du15h3QSAKjOHuZyOQ3ZpHv8UmEU+iLlzOdz7t3+xzwHzz/vnn+c+3iVfoDu4UeK6KTGXMYCdlIDgAQymE0nmjbO9LgyiRQKfZFy5PM592ybp83mGW53zy8/phujEx/TPfwIk5oKv8afRHfeIr/o8btnsIwRm68n2hRqYZ+UO4W+SDlKSYGjM1cziZ5E4fTE+Jyz6Jk7gfVpUbqHH2H89/h/SmrHYAKzPlfkvk0qQ7WwT8qdmvOIlKN6ZhtLOYOjWQ843fba8CXbTH013hHG1riDvrufdcfX8QY+rlPzHjksas4j4oX8fGZWvsYN/N1UoxOz2Up9LdoTAAbsforZXOGOx9CP0/haC/uk3Cj0RcqYf+Hes7H30Db7fff89bzB95ykRXviapwUzXVM5AeOB6AK2czgSlo02uJxZRKuFPoiZci/cO/8tAncTmDa9okqw5htumjRnuwjNRUK4mvQhZnuiv4k0hn1+zXEmnwt7JMyp9AXKUMpKdAs82tGM8A9N4MuvFz/QS3ak7/xL+zLSWrGdfgoxABwbv6HPMk9WtgnZU4L+UTKUB2znWW0dO/jf8eJtOFL9prqWrgn/2hkrf9y186H3HEPJvMmPbSwTw6JFvKJVARrmVLlRjfwd1GdK5nBHqpr4Z6UyL07U3ibK93xGPrRlJ+0sE/KjEJf5DD5F+7dEzWSS7Nmuef7Mpa1NNXCPSmxhKQobmQ8a4uetlidPUylmzr2SZlR6IscBv/CvYS0TxjO/e75lyv/h+mmmxbuySFJTYX8+Jp0YyrZxAHQnNU88MdtehSvlAmFvshhSEmB+MwtvMk1xFAAwBe0YWSDJ7VwTw6Zf2HfjqQW+3Tsuy5nHL3sa1rYJ4dNC/lEDkOUsczhcjoyH4Ct1OU0vuE3k6CFe3J4rOXt6r24au9EADKpwhl8xfecpIV9clBayCdSTh6u/Zwb+OA04MkgQQv35PAZQ++9L/E9JwAQTxaT6Ekc2VrYJ6Wm0BcprRUreGD3ve7wae5gIZdp4Z6UmbpJ1ejGVLKoDMCprOJx7tcvlVJqCn2RQ+TzwQmJe/nxtB5E5+cC8G2l0xjKcC3ckzLlfxTvXYx0z93OKMZ3X+BhVRLKFPoih8C/Wv/ODbdzPD8BsIeq/JI6hWwbp4V7Uqb8C/vmJw7a58E8J4+8gYZms1bzyyHTQj6RQ9CkCZyWNoMZXOWeu5FxfJh0oxZWSfnaupXM45oTv2MTAPO5jI7MIz7eaHZJ9qGFfCJlJDttM6/Q3x1P4Rpe4wYtrJLyV68e/StNcIcdWMAt/B+Zmc7WUZGSUOiLlJS1vFGlH/XZCkAGjRjIy4DRwiqpEJO2XMII7nbHT3Ivx7FGv3RKiSn0RUpq/HguyZrjDm9kPDuppdX6UmESE+EB/scqTgGcbXwT6E2ThAKPK5NQodAX+Qc+H7RttJ7dff/jnnut+q28by7Ran2pUKmpEBMfRy9eJ5dYAM7iS6a3GeFxZRIqFPoiB+HzwYB+haRuvIHq7AFgjWlK5WefUJtdqXDF2/Q+ysPu+ZPeeojmZrVW88s/0up9kYNo0gQ6p41iFLcDUEAUZ/M5m5Naa7W+eCs/n63Hn0O9n5cC8A0taM0SYuMrafYpwmn1vkgpRaf9wmMMdcfDGcJSWmvhlHgvJoZrsia43fpOYwUppGo1vxyUQl/kQKzljbibqIrzLPPVnMyjPASg1foSFD7cdDxDGO6Oh/IYp7BKv5TKAQVd6BtjRhhjfjTGrDLGzDDG1Cr22hBjzDpjzE/GmHZe1ikRYMwYzs75EHCm9fswjjwqabW+BI3ERHiOwXzKOQDEks9Y+nJUQr7HlUmwCrrQBxYBJ1trmwNrgCEAxpgTgR7ASUB74EVjTLRnVUrY8vngrMYb2DUgsB96TI27WW7O0Gp9CSqpqVAlPoq+jCWbOADOYBlTz3nW48okWAVd6Ftr37XW+n9N/RJoXHTcGZhirc2x1q4H1gFnelGjhC+fD/r3szzw20BqsBtwVuvXenaYVutL0PGv5s9JarbPav4TpzzIcWadVvPL3wRd6P9FH8D/OKlGwIZir2UUnRMpMykpcGWWj47MB6AQQx87lvsfqeJxZSL7l5zs/DL6WO7d/JnUAoDKNpsx3ER6WiH9+yv4JcCT0DfGvGeM+XY/H52LvScFyAf8f13Nfj7VfvcbGmP6G2OWGWOWbdmypey/AQlbe9K28Qx3uOMXuJXPaKuFURL8YmO5Pmcs+Th3Pf/NR/RjjFbzyz48CX1r7cXW2pP38zELwBjTG7gcSLaBRgIZQEKxT9MY2HiAz/+KtbaVtbZV/fr1y/NbkTDzQrX73N766SSQgrNiT6v1JRQs2Hw6I7jHHT/BfRzB7/qlVVxBN71vjGkP3Ad0stZmFntpNtDDGBNnjDkKOA5Y6kWNEqY+/pgee8a6w1t5gT1U12p9CRmJifAID7OWYwGoxU6e5k790iquoAt94AWgOrDIGLPCGPMygLX2O+At4HtgIXCLtVZPmZCykZMDAwa4wwXxVzHXdNJqfQkpqakQHV+ZQbzknuvJZMb2WORhVRJM1IZXIp7PB7/f8l/u2uk03smrXJ3YdT9AI60TldDj8zn38FPTkklmknPy2GNh9WqoXNnb4qRCqA2vyAH4fPDkTWu4ZWdg/v7+glR8ixX4Epr8q/mTN42EmjWdk+vW8d8qj2kLnyj0JbKlDLWMyL6VyuQA8BWteDbvZq12ltDXsCFLr3rcHd7H41RO+1Fb+CKcQl8iWqv0t7kU535nAVEMYDSFRGu1s4SFa97vzxe0AaASebzIzWRmWv1SG8EU+hK59u5lVHRgT/5LDOIbTge0RU/CQ9qGKAbysrt3/0I+pBtT9UttBFPoS+R67DEaFThNHv+gPg/yXwBt0ZOwkZgIqziVF7jVPTeSu2jWeK+HVYmXFPoSmdauhaeecocj6j7OTlNbW/QkrKSmOr/EDmMYm2kAQAIZTD3tMY8rE68o9CXi+CZaFjcfDLm5AGw9pjUj/rhBD9SRsON/IE+tpFoMIbCo7+SFTzm/+ErEUehLRPH5YHbfWfw7eyHgPFCn82//h2+y/lOQ8OTfwjeuoDe0bu2czM1lftP/0CTJaiV/hNH/6SSiPDo0m+G5d7rj0Qzg8+yWWs0s4S8qigUdX6Cw6NllHVjAKelztYUvwij0JaJclf4sR7MegG3UcR+oo9XMEgkGjW3FGPq542e5nfzMHP3SG0EU+hI5Nm0ixQSW5T/Eo2ynDqAtehIZ0tMhhVT+pDYAx/ALt/G8fumNIAp9iRwpKVSzewD4jhMZjfOAHW3Rk0iRmAjbqMcwhrnnHuS/nNboD++Kkgql0JfIsHw5vPaaO3y8wTMUmhht0ZOI4t/C9xKD+JFmANRkF5ObPexxZVJRFPoS9nwTLUvPuR2KniiZcdrlvLH5Um3Rk4jj38LXKCmWuxnpnm/64SvOU/gk7Cn0Jaz5fLCw71TOzPkUgDxi6PjDSK1Wlojl38I3t7ADXHKJc7KwkE/OvJMoY/UkvjCn0Jew9sjQHB7Nvc8dP89trMpuqtXKIsbA009TaJwYODf7PTowj7Q0tI0vjCn0Jaxdkf5/HMWvAGylLo/yEKAteiIAnHwyk6r2d4cjuYsY8sjMRL8YhymFvoSv7dt5MOp/7vBRHmIntQBt0RPxu3PPo+ygJgDNWMNNvAroF+NwpdCX8JWaSq3C7QCs4xheZiCgLXoixcUn1Wc4Q9zxMIZRjd36xThMKfQlPK1fD88/7w6frjecfFNJW/RE/iI1FV6tMpgNNAbgCP7g/piR+sU4TBlbtI0pXLVq1couW7bM6zKkAvl8ULV/Ml0yJwGw5dg21F/zubNwSUT+xueDr/8zgZHbbgAgL64qsevXwr/+5W1hUirGmOXW2lb7e01X+hJWfD54qe8yN/ABemx4Ct8kBb7IgSQnw8jN18EppwAQm7MXHnnE46qkPCj0JaykDLU8mnOvO36bK/kg5xytRBb5J9HR8OST7jB/9KucYH7Uvv0wo9CXsNIsfREX8iEA+URzP48DWoksUiLt2rHppIsAiKGA4dyvffthRqEv4aOwkBGVhrrDV7mJtTQFtEVPpESMod+2J9xhF2bRhi+0bz+MKPQlfEyfTvPc5QBkUdltxKMteiIlN39zSyZxrTt+jKGA1WxZmFDoS3jIz4cHHnCHE2oM5ndzpLboiRyixER4iEfJJxqAC1jMxbyn2bIwodCX8PDaa7BmjXNcsyYD19+np+iJlEJqKmyKP5ax9HXPPR41lNT/hff27kih0JeQ5vNBs6RsNvQrtr3o3nuhTh3vihIJYf7H745r9BDZxAHQsnAZyVVnelyZlAWFvoQsn89ZVdwx/UUSyABgM0cw5Yj/eFyZSGhLToYlGY2ofNetgZMPPAAFBd4VJWVCoS8hKyUFojJ3M5TH3HOP8iD3/7eqh1WJhJH774fq1Z3j77+nd4xP+/ZDnEJfQlZ6OgzmOeqxDYD1NGEM/bTKWKSs1KvHqkvucofDeJiNabnatx/CFPoSsk5qvJO7ecodP8LD5FFJq4xFylDPr+5gK3UBOIpfuZHx2rcfwhT6ErJ8rZ6hNjsAWMNxTOQ67ckXKWPfZ9Tgce53xw/wPyqRoxm1EKXQl9D05580f/8Zd/goD9M4KUZ78kXKWGIivMQgNtMAgAQy6MtYzaiFKIW+hKann4Zdu5zj449nYn4P7ckXKQepqUB81X2v9k0qwx/O9q4oKTWFvoQUnw9OS9jK7tRRgZPDhjlPCBORMufftz8/YSCbaAjAkXYj1+4Z43FlUhoKfQkZ/n35PTJGUJ09AHxnTsaX283jykTCW3Iy/JRehX+NGhI4OXw4ZGV5V5SUikJfQkZKClTN/INbecE996B9hJQH9ddYpEL07w9HHukcb9rEHfGjtW8/xOj/lhIy0tPhTp6mKpkAfEMLZtJFq4hFKkrlynx1ceBq/z4e54+0TO3bDyEKfQkZpzbaus9V/qM8hCVKq4hFKtB1i29iA40BaMhm+vOK9u2HEIW+hIw3Wj5LNfYCsIpTmEVn7csXqWBrN1RmOIGr/Xt5kjiyNeMWIhT6Ehq2b+fkD593h6k8QGJSlPbli1SwxEQYRx828i8AjmQTfRinGbcQodCX0PDcc4F9+SecwJv5XbUvX8QDqakQHV+ZEdzjnhtiHmf4I7keViUlpdCXoObzwcmJu9g+7NnAyQce0L58EY/49+0vSBjAH9QHIMFu4Nq81z2uTEpCoS9By78vv9OGF9we+2vNcUwquMbjykQiW3Iy/JgeT4PHA0/gY/hwyM/3rigpEYW+BK2UFDCZe7iTp91z/7MpDH1QV/kiQeHmm6FOHef4l1/oFTtZ+/aDnEJfglZ6OgxgNPXYBsDPHM0kemqVsEiwqF6dlRfc7g6HksqGtALt2w9iCn0JWscm5Oxzlf8E95FPrFYJiwSR65fexk5qAHA8P9GV6dq3H8QU+hK0Xr/kdRqxEYCN/IsJ9Na+fJEg821GLZ7nNnc8hOGA1YxckFLoS3DKz6fN4ifc4WdunR0AACAASURBVNPcxb+S4rQvXyTIJCbCKP5DJlUAOI0VXMq7mpELUgp9CU7TpsHPPzvHtWvz1K7+2pcvEoRSUyEzvj6vcpN7LiVquGbkgpRCX4KPtc72H7/bboPq1b2rR0QOyL9v/81Gd5FHDADnFX5E8tFfeFyZ7I9CX4KKzwc3HjEfVq0CID8uHgYP9rgqETmY5GT4LCOJ2F49Aycff9y7guSAFPoSNHw+6N/PctOWx9xzLxUMwLewrodViUiJ3Xdf4Hj2bPj2W+9qkf1S6EvQSEmB07M+5Rw+ByCXWJ7Iv1Nbf0RCxYknQpcu7vD1U55Us54go9CXoJGeDvcwwh2/Ti9+o7G2/oiEkIUt7nePezIJ0n5Vs54gotCXoHFhw+/pxBx3/BR3A2jrj0gIGTi+NR9wAQAxFHAnT6tZTxBR6EvQeLnpSPd4Fp34iePVjEckxKSnw+MErvb7Mpba/KkZuyARtKFvjLnbGGONMfWKnRtijFlnjPnJGNPOy/qkjG3axLFfTHSHI7iXpCTUjEckxCQmwiIuYSXNAahKJoN4STN2QSIoQ98YkwBcAqQXO3ci0AM4CWgPvGiM0ePWwsVzz0FurnN81ll8as9RMx6REJSaCvHxxr09BzCY5xn+cLaHVYlfUIY+8AxwL2CLnesMTLHW5lhr1wPrgDO9KE7K2O7d8NJLgfE993hXi4gcFn+zni8TryGDRgAcwWauLdRKvmAQdKFvjOkE/GatXfmXlxoBG4qNM4rOSQjz+eC/SWNg504AdjU8Djp18rgqETkcycmwNq0SjUcEHrvLU09BYaF3RQngUegbY94zxny7n4/OQArw0P7+2H7O2f2cwxjT3xizzBizbMuWLWVZupQhnw9u7pdH7+3PuueG/nk3vim6ayMSFvr1C7TQ/vFHmD/f23rEm9C31l5srT35rx/AL8BRwEpjzK9AY+BrY0xDnCv7hGKfpjEUPXf175//FWttK2ttq/r165fvNyOllpICl2e9RWLRBM5mGvBqbi9t7REJFzVrwoAB7vCjK0aoWY/Hgmp631q72lrbwFrbxFrbBCfoT7fW/g7MBnoYY+KMMUcBxwFLPSxXDlN6muVOnnbHz3MbOVTW1h6RMDIjYbD7IJ7z+ZgGaUvVrMdDQRX6B2Ot/Q54C/geWAjcYq0t8LYqORxXH/EJLfkagCwq8zIDATXjEQkndzydwGSudcd3MVLNejwU1KFfdMW/tdg41Vp7jLW2mbV2gZe1yeEb2ThwlT+B3myjnprxiISZ9HQYyV3uuCvTSSBdM3oeCerQlzC2bh0JX892h6O4Xc14RMJQYiKs4tR9WvPeygua0fOIQl+8MWoU2KLNFx068IM9Xs14RMKQ06wHnuEO91x/XuGJB/d4WFXkUuhLxdu+HcaNC4zvuOPA7xWRkOZv1vNtYkfWcBwAtdjJNVmveVtYhFLoS4Xy+WD40WMgMxOA7QmnwEUXeVyViJSn5GRYnxZF0xf+Ezg5apSa9XhAoS8Vxt+M5/odz7nnhmy+A9+k/fVdEpGw07s31KrlHK9bB/PmeVtPBFLoS4VJSYEOWdNozG8A/M4RjM/tqa07IpGiWjWnS1+RDzo9o2Y9FUyhLxUmPR3+wyh3/CI3k0uctu6IRJAZjW8jH6fV9oV8SK20FWrWU4EU+lJhOh2xhDYsASCHSmrGIxKB7ng6gWlc7Y5v51k166lACn2pMM8c/bx7PIUebKGBmvGIRJj09H237/VgCvXYohm/CqLQl4rx++8c9dVb7vB5BqsZj0gESkyEpbRmKWcAUJkc+jFGM34VRKEvFWP0aMjLc47PPptltqWa8YhEIH+znucY7J672bzEY4/me1hV5FDoS/nLzYWXXgqMBw8+8HtFJKz5m/UsTezGZhoA0Nhm0DN+pseVRQaFvpS/qVNh82bn+Mgj4aqrvK1HRDyVnAxr0uI44sEBgZPPP3/gPyBlRqEv5crngxV9As14Vp49CGJjPaxIRILGwIEQE+Mcf/wxrFzpbT0RQKEv5cbng1f6LqFF7lLA2abXeV5/7ccVEceRR0LXroGxrvbLnUJfyk1KCvTLCfxHPJlrSctqoP24IhJw223uYdZYHy0StunCoBwp9KXcZKX9QTemuuPncf7j1n5cEfHzrT+bb8zpAFQhm0szxqpDXzlS6Eu5uavWWOLIBeBLWvM1LQF14BORgJQHDKNs4Gr/Zl4kO7NAM4LlRKEv5aOggFuiX3aHL3IzgDrwicg+0tOdDp1bqQtAE9K4jAWaESwnCn0pH/PmUXWb81/ttqh6TKW7OvCJyN8kJkIOlRlHH/fczbyoGcFyotCX8vF//+ce1r2nL1m2sjrwicjf+Dv0jWYAhRgA2rOQUYN/9riy8KTQl7K3di28+65zbAwMGHDw94tIxPJ36CtIOoaFtAcgCkvn30d7XFl4UuhL2SvecrdjRzjqKO9qEZGgl5wMv/4KHebcHDg5dixkZXlWU7hS6EuZmjIuk52jxrvjD064xcNqRCSkXHYZJCU5x3/+6bTwljKl0Jcy4/PBR4MmU7NwBwDrOIZOL1yq/bYiUjLR0U5rXr8XX/SuljCl0Jcyk5ICfXMDU/svMYi9WVHabysiJdenDwUxlZzjJUu4/F/LdeFQhhT6Umbqpy2jFcsByCaO17gBUAc+ESk536IGTLXd3PGVv7+oDn1lSKEvZebOaoHVtm/RnT+Lmm1ov62IlFRKCjxXEFjQdy2TicncqRnDMqLQl7KxcydX5012h6NxtumpA5+IHIr0dPiCs1hJcwDiyeI6JmrGsIwo9KVs+HzE5uwF4MfYk/mCs9WBT0QOmTMzaNwLB4ABjCYxwXpWUzhR6MvhsxZGB6b2j396AIXWqAOfiBwyf4c+H8nsJR6A5qxm9I1felxZeFDoy+FbsgRWrXKO4+Ph+uu9rUdEQpa/Q1/tpJq8SQ/3fLtf1aGvLCj05fC9HHiaHj16QM2a3tUiIiHP36Gvz5JiLbzffBO2b/espnCh0JfDMvWV7WS//qY7XpA08CDvFhE5BGecAS1aOMfZ2TBxorf1hAGFvpSazwdLbn2DyjYbgK85jasfb6X9tCJSNv76wK7Ro501RFJqCn0ptZShlhvzAvfZRjOAzCyj/bQiUnZ69oSqVZ3j776jbdTnNGmiZj2lpdCXUjsy/UtO4nsA9lCVSfQE1IFPRMpQjRqsPbOnO+zPaNLSUJe+UlLoS6ndXnWMezyZa9lDdUAd+ESkbN35Q3/3uDtvUYvtZGaiWcVSUOhL6ezaxVX5gQV8r3IToA58IlL25m1uxXJOB6AyOSTjXOJrVvHQKfSldCZPJiYnE4AfYk/hK85UBz4RKReJiYELC4CbeBWwmlUsBYW+lM6rr7qHJzx1kzrwiUi5SU2FWVWuJZMqALRgJWdX/lqziqWg0JdDt2IFLFvmHMfFwXXXeVuPiIS15GQYMaYWC6oGHrk7/pxXdZFRCgp9OXTFrvLp2hXq1PGuFhGJCMnJ0HVBYIq/6VeTYO9eDysKTQp9OSRTxmWy68VAV6z3mtx0kHeLiJShtm2haVPneNcumDbN23pCkEJfSszng/cGTaeG3QnAWo6l8zP/1l5ZEakYxsBNxS40is86Soko9KXEUlKgV25gb/5Y+qoDn4hUrF69ICbGOf70U04wP6pD3yFQ6EuJxaWt4Tw+ASCfaF7jBkB7ZUWkAh1xBOktrnCHfRirDn2HQKEvJTa4xmvu8Tw6spmGgDrwiUjFeig9MMXfmwnEkqsOfSWk0JeSKSjgxugJ7nAcfQB14BORijfxj3ZsoDEADdhCR+YBmnUsCYW+lMy77xK/fSMAW6IasIAO6sAnIp5onBTNBHq74xsZD2jWsSQU+lIy48a5h/XvuJ5cG6sOfCLiidRUeLPyDe64A/M5qsrvmnUsAYW+/LOtW2HWrMD4xhu9q0VEIl5yMtz/6rEsiTsXgBgKmNZloi5CSkChL/9s0iTIy3OOW7eGk07yth4RiXjJydD6pcAFyOkrx4O1HlYUGhT6cnDWwtixgbGu8kUkWHTrBlWrOsfffw9Ll3pbTwj4x9A3xtxqjKldEcVIcPH5oOOR38CqVQDkx1aGHj08rkpEpEi1ak7w+40f710tIaIkV/oNga+MMW8ZY9obY0x5FyXe8/mcZhftfw/8RzS18Gp8c2t6WJWIyF/06RM4njIFsrK8qyUE/GPoW2sfAI4DxgI3AGuNMY8ZY44p59rEQykpkJ+ZQzKBFldjCm5U8wsRCS5t28KxxzrHO3eSHD9DbXkPokT39K21Fvi96CMfqA1MM8Y8WY61iYfS0+EK5lCH7QD8ShKL+beaX4hIcDGGFafd4A5vYLza8h5ESe7pDzbGLAeeBD4DTrHWDgJaAl3LuT7xSGKi097S73V6YYlS8wsRCTqDPu9FIc6d54t4nwTS1Zb3AEpypV8PuMpa285aO9VamwdgrS0ELi+PoowxtxljfjLGfFd8NsEYM8QYs67otXbl8bXFMfLezVzGAnf8Or3UcldEgtKSjQks4hIAorBcx0RAbXn3pyT39B+y1qYd4LUfyrogY8wFQGegubX2JOCpovMnAj2Ak4D2wIvGmOiy/vri6JoziRgKAPiUc8hPOlYtd0UkKCUmsk9bXmeW0mpmcj+CcZ/+IOBxa20OgLX2j6LznYEp1toca+16YB1wpkc1hr8Jgan9tq/0VstdEQlaqanwbpUu7KI6AM1Yw/lxSzQzuR/BGPpNgXONMUuMMR8ZY84oOt8I2FDsfRlF56SsrVzpfABUrgzdu3tbj4jIQSQnw6gx8SyoGtiz/0rb13Whsh8xXnxRY8x7UPQw9n2l4NRUG2gDnAG8ZYw5Gthff4D99lw0xvQH+gMkan7n0BW7yufKK6Gm9uaLSHBLTgYSesP5zsPBmn49BXKegbg4bwsLMp5c6VtrL7bWnryfj1k4V/BvW8dSoBBnMWEGkFDs0zQGNh7g879irW1lrW1Vv3798v52wkte3r77XHr3PvB7RUSCSdu20KSJc7x9O8yd62k5wSgYp/dnAhcCGGOaApWArcBsoIcxJs4YcxROwyA1Wi5DPh/0afQO/OEso8isfSRcfLHHVYmIlFBUFPTqFRgXn7UUIDhDfxxwtDHmW2AK0Lvoqv874C3ge2AhcIu1tsDDOsOKv+3uZVsC/5G8vPs6fFO0QUJEQsj11weOFyxwL2LEYWyYP4qwVatWdtmyZV6XEfSaNIGdadv5nYbEkQvAiXxHZtKJ/Pqrp6WJiByatm3hs88AuJ1nmZn0H1JTI2cHkjFmubW21f5eC8YrffFAejp0Y6ob+MtoyQ+cqOYWIhJyljQLTPH3YoLa8haj0BfAaW7h72IF8AbXu+dFREJJv0XdycZZtX8633Ayq9WWt4hCXwB49vZfOY9PAMgnmin0UNtdEQlJ32bUYhad3bH/aaGauVToS5EuewPzXu9yKVWSjlDbXREJSYmJgdlKcELfUKiZSxT6AmAtvPGGO+ww6Xq13RWRkJWaCp9UacdW6gKQQAbt4j7SzCUKfQFYtgx++sk5rlYNOnc++PtFRIJYcjK8OCaWedV7uOeebzNRFzIo9AVgYmABH127Qny8d7WIiJSB5GTo/e517vjYb6ZBVpaHFQUHhX6ky8uDyZMD4+KNLUREQlnr1nDMMc7xrl1qy4tCP6L5fHBD40WwZQtQ1Hb33//2tigRkbJiDFwXuNrfZ1YzQin0I5S/7W67PwIL+EbvTlbbXREJL8Vv5M+fD1u3eldLEFDoR6iUFIjK3E1nZrnnxudfp+YVIhJejjsO2rRxjvPzYepUb+vxmEI/QqWnw5XMIB5nYctKmrOa5mpeISLhp9gU/2c3T6RJk8htyavQj1CJidCTSe7YR7J7XkQknEyL6k4eMQCcw+dEpf0Ssb34FfoRauS9m7mY99yx2u6KSLi6+4n6LKS9O07GF7G9+BX6Eapr4VRiKADgY84lKilRbXdFJCylpwdmM8E/y2kj8nZmjNcFiEcmBab2z3s5mV8HeFiLiEg5SkyEOWlXsIeqVGMvJ/Ajp7KSHYktvC6twulKPxL98gt88YVzHBMDV1/tbT0iIuUoNRWIr7rPk/d6x0yKyNuZCv1IVLwDX/v2ULeud7WIiJSz5GR45RV4r35P91z/mlNIvrbQw6q8odCPNNbuu2S1Z88Dv1dEJEwkJ8P4jEugTh0Aqm7bAJ995nFVFU+hH2lWrYIffnCO4+OhUydv6xERqSiVKkG3boFxsbVNkUKhH0F8Pnj5vMBf8vUtukDVqh5WJCJSwYrPbk6d6jx0LIIo9COEzwcD+hXSYVfgfv5dy3tGZHMKEYlgbdtC48bO8bZtsGiRt/VUMIV+hEhJgdOyPiORDQBspS5zci6NyOYUIhLBoqKgRw93OLHjpIhqy6vQjxDp6dCDKe54Kt3IJzYim1OISGSbXyswxd+FmfyRlhkxbXkV+hHiqIR8uhF4utQUnN901WtfRCLNza+04EeaAVCNvVzBnIhpy6vQjxCvXPshDdgCwG8cyae0Va99EYlI6RsMkwhc7ftnQSNh5lOhHyEu2lJ8ar87CUnR6rUvIhEpMRHe5Bp3fBkLqMHOiJj5VOhHgpwcePttd3j7lz349VcFvohEptRUyIhvxjc4vfcrk0P3SrMiYuZToR8J3n0Xduxwjps0gTPP9LQcEREv+dvyvlMrsIp/2AlvRsSFkEI/EkwJTO3TowcY410tIiJBIDkZ7v8mMMXf6Lt3nX37YU6hH+4yM2HWrMD4mmsO/F4RkUjSpAm0bu0c5+fDjBmellMRFPrhbt482LvXOW7WDE491dt6RESCSbFGPbz5pnd1VBCFfhjz+WD+DYG/xKtO1NS+iMg+unUL/H/xgw9g82Zv6ylnCv0w5fPBXf12cUHmPPfcDQuuiYiOUyIiJdaoEZx7rnNcWAjTp3tbTzlT6IeplBS4OGs2VcgGYAWn8k32CRHRcUpE5JAUW+v08S1TwroXv0I/TKWnQ3fecsf+RhSR0HFKRORQTONqCorisC2fkp+WEba9+BX6YeqkxjtpxzvueCrdAPXaFxH5q7ufbMAHXAhAFJZuTA3bXvwK/TA1uuNs4sgFYDmn8zPHqte+iMh+pKcHHkIGgVnScJwZVeiHqbMzAlP7U+lOUhLqtS8ish+JiTCTLuQTDcBZfEljNoTlzKhCPxzt2AHvBKb2H/+5m3rti4gcQGoqZMfX5T0uds/1jJ0WljOjCv1wNGsW5OU5xy1bwtFHe1uPiEgQ8/fi/6BON/fc3UlvheWFkkI/HE2dGjju3t27OkREQkRyMjy5pgtEO1P89dd9CRs2eFxV2VPoh5vt252n6vl163bg94qISEDdunBxYIqfadO8q6WcKPTDTfGp/TPOgKOO8rYeEZFQUvxC6a23Dvy+EKXQDyM+H3xwc2Bq/+tjdJUvInJIugSm+Pnyy7Dbt6fQDxM+H9zbbzvnZgWm9pNndgvLjlIiIuWmbl246KLAOMym+BX6YSIlBS7Nmkks+QAs4Ux+zG4Slh2lRETKVfEF0MUXRocBhX6YSE+Hqwn8RupvuxtmM1MiIuWvSxcKowJT/Gc3Tg+bWVOFfpg4ufEOLmGRO57G1YB67YuIHCrfwrp8QGCKv81v08LmATwK/TDxUse5VMJZtb+MlqTRRL32RURKISUFJhcGpvjD6QE8Cv0wcc6mwNT+dK5Wr30RkVJKT/97L/5GZITF7VKFfjjYvRsWLnSHw9d0Va99EZFSSkyEP6nLYv7tnruSGWFxu1ShHw7mz4ecHOe4eXM47jhv6xERCWGpqRAfH1gbBdAtanpY3C5V6IeD4vtIr776wO8TEZF/5H8Az/LGXSjEAHCu/Zjkizd7XNnhU+iHusxM50rfr2tX72oREQkTycnw1YaGRJ3bFgBjLcyc6XFVh0+hH+oWLnSCH+CEE+DEE72tR0QknBS/kJo+3bs6yohCP9Rpal9EpPxcdVXg+IMPYNs272opAwr9EDZ5fDZ7psxxx/Mqa2pfRKRMJSRA69bOcUEBzJ7tbT2HSaEfonw+mD5wEdXsHgDWcizd/9c8LDpGiYgElTCa4g+60DfGtDDGfGmMWWGMWWaMObPYa0OMMeuMMT8ZY9p5WafXUlLg8tzAX77pdCUzy4RFxygRkaBSLPRz5i3ilMSdIXuBFXShDzwJPGKtbQE8VDTGGHMi0AM4CWgPvGiMifasSo9tTMujE4Fppuk4fynDoWOUiEgw8X1xNCvMaQDEkUvzDXNDthd/MIa+BWoUHdcENhYddwamWGtzrLXrgXXAmfv58xGhW4OPqMN2ANJJYBmtAD1gR0SkrKWkwFQbuNrvyvSQ7cUfjKF/OzDCGLMBeAoYUnS+EbCh2Psyis5FpIdPeds9nsGVgNEDdkREykF6+r7d+dqzkCpkhuTMqiehb4x5zxjz7X4+OgODgDustQnAHcBY/x/bz6eyB/j8/YvWAyzbsmVL+XwTXiospOn3gSYRM7hKD9gRESkniYmwhmZ8zwkAxJNFO94JyZlVT0LfWnuxtfbk/XzMAnoD/svYqQSm8DOAhGKfpjGBqf+/fv5XrLWtrLWt6tevX17fhneWLIFNm5zj+vVZnN9WD9gRESkn/l78bxPYs98tekZIzqwG4/T+RuD8ouMLgbVFx7OBHsaYOGPMUcBxwFIP6vPe24GpfTp1guiIXc8oIlLu/L34v2x4pXuua9wckrvneVhV6QRj6PcDRhpjVgKPAf0BrLXfAW8B3wMLgVustQWeVekVa2HGjMC4eLcoEREpF8nJMHfj6e5q6bjMHbB4sbdFlULQhb619lNrbUtr7anW2tbW2uXFXku11h5jrW1mrV3gZZ2eWb0afv7ZOa5eHS66yNt6REQihTFwZeBqf58LsBARdKEv/6D41P7ll0NcnHe1iIhEmuKhP3MmFBZ6V0spKPRDTfHQL/6XT0REyl/btlCvnnO8aZOzsDqEKPRDyKyR65zpfSCHON7cdZnHFYmIRJjoaOjcOTAOsSl+hX6I8Plg6ZDAX66FtKPP4Goh2QZSRCSkFZ9lffttZ4F1iFDoh4iUFOiYFwj9GVwZsm0gRURC2kUXkVe5mnP888+0a/RtyFyAKfRDRG7aJtrwJQD5RDOHKwA9YEdEpKL5pldmZl5Hd9xm09sh8wAehX6I6F1nDlFFXYc/5jz+pC6gB+yIiFS0lBSYVhCY4r+SGSEz86rQDxG3JgR67c+kC4AesCMi4oH0dJhPB3KoBEALVpLEryEx86rQDwW7dtHoh/fd4Ww66wE7IiIeSUyEPVTnfQLN0TozKyRmXhX6oWDhQsjNdY5btOBXm6QH7IiIeMT/AJ5ZBLbuXRU1KyRmXhX6oWBmYGqfLl28q0NERNwH8HzdqJN77lw+Jrn9Ng+rKhmFfrDLzYV58wJjhb6IiOeSk+GrjH9B69YARBUW7Pv/6iCl0A92H30Eu3Y5x02aQPPmnpYjIiLFFL8QmzXLuzpKSKEf7P46tW+Md7WIiMi+iof+woWQleVdLSWg0A9mhYX7/uaoqX0RkeBy/PHQtKlznJkJ779/8Pd7TKEfxBb8bzn89hsAf0bVZVLaOR5XJCIif1P8gqz47GwQUugHKZ8PVv838JdnVuEV9BsUExJtHkVEIkrxp+7NmQMFBd7V8g8U+kEqJQU65u/bhS9U2jyKiESU1q3hiCOc4z/+oG3MlzRpEpy9+BX6QSo2bR0n8T0AWVRmEZcAesCOiEjQiY5m3QlXuMNOzCItjaB8CI9CP0j1qj3HPV7EJWQRD+gBOyIiwSj1u8B9/S7MBGxQzs4q9INUv4az3ePZOF2f9IAdEZHgNGXLReyhKgBNWUszfgKCb3ZWoR+M/vyThms+cYfzuFwP2BERCWJHJFXmHdq54ytwZmuDbXZWoR+MFiwIrP5s3ZpNtqEesCMiEsRSU+HdSsXv688OytnZGK8LkP2YHZjap1OnA79PRESCQnIyxO3qSOHNhigsZ/M5E57awtXJ9b0ubR+60g82ubnOlb6fQl9EJCRcPag+UeecDUA0hVwdP9/jiv5OoR9sPvoIdu92jo86Ck46ydt6RESk5IpfqM2Zc+D3eUShH2yK99rv1EkP2BERCSXFQ3/hQsjO9q6W/VDoBxNrdT9fRCSUNWsGxx7rHO/dC4sXe1rOXyn0g8j84SthwwYAdpmaTNpwrscViYjIITFm3wu24hdyQUChHyR8Plg+LPCXY67tQL+bY4OuhaOIiPyDv97Xt9a7Wv5CoR8kUlLgsrx9u/AFYwtHERH5B+ecA7VrO8cZGbBihbf1FKPQDxJ5aRtpxXLnmBgW0h4IvhaOIiLyD2JioGNHdzjs9NlB89Q9hX6QuL7OPPf4Y85jJ7WA4GvhKCIi/+yTWoHufFcwO2ieuqfQDxK3JgX2c87lckAP2BERCVU3z2pHLrEAtORrGpERFLdsFfrBICuLxj++5w71gB0RkdD2XUZNPuJ8d9wBpzuf17dsFfrB4MMPISvLOW7WjDX2OD1gR0QkhCUmBmZtAS5nrnveSwr9YFC8VePllx/4fSIiEhJSU+H9yoH/n1/Me9SpkuX5LVuFvteshblzA+Mrrjjwe0VEJCQkJ8OQV49hbewJAMSTxbRbPvR8Bleh77VVq5x9nAC1asHZZ3tbj/x/e3ceHVV9/3/8+WEzRBBlawuRTUEwG2ENCAFUkiiL4BdUTFlV5OtyfnXhqE2rWI31V5cqilo4VkRjhZ+7sqgIClgxQCEgUBYhxgiyhEJlCRj4/P6YyWQSZsIkmZk7Mq/HOXMyd/vcd+aGeXM/997PW0QkKLKyoOPvys/2Bx35qIq1w0NJ32neXfuZmVC/vnOxiIhIcHlfsv3oI8dH51PSd5q69kVEzl59+7p6ccFVW2X9ekfDUdJ30p49kJfnel+3rutMX0REzh716sFVV5VPf+RsF/2wmAAAHCdJREFUF7+SvkNyc2Fq/AJPV8+ejpdB06YORyUiIkFXuYvfQUr6DsjNdQ3HmFpcfvCnfzvU8eEZRUQkBDIzoY473X79Nezd61goSvoOyM6G0qPHSecTz7x3fh7q+PCMIiISAk2buirvgat3d+FCx0JR0ndAYSGksYzGHAbgWzrwbzo7PjyjiIiEiFcX//+b8JFjVfeU9B3Qpk35OMwA8xkCGMeHZxQRkdD40GtI3gw+Ztd3Jxypuqek74CcHBhqykvpzmeIKuqJiJzF7pzRhR20B+A8fqI/yx2puqek74CsXtvoaLcBcIRYCtoMUEU9EZGzWOH3xt2r6+JU1T0lfSfMLz/LP3fYFWz5LkYJX0TkLNamDSzgas90WdIP92VdJX0nLCi/ns+QIf7XExGRs0JODuQ1HMhRGgLQhX9zacyOsF/WVdIPt8OH4Ysvyqevvtr/uiIiclbIyoLpsxryVcPLPfNmX7cg7L28SvrhtngxnDjhep+UBBde6Gw8IiISFllZcMVT5b27PffOr2Lt0FDSDzev6/k6yxcRiTLe3/tLl8LRo2HdvZJ+OFmr6/kiItGsbVuIj3e9P34cliwJ6+6V9MMpPx927XK9v+ACSE11Nh4REQk/77N97xPBMFDSD5PcXHhiUHnXfkHnTFfJRRERiS7evbzz53uqrYaDkn4YlFXVu+xgedL/05ohqqonIhKN+vaFJk1c7wsLYdOmsO1aST8MsrMh5mgxqawE4BSGD05kqKqeiEg0ql8f0tPLp+eH7y5+R5K+MWa0MWajMeaUMaZHpWUPGGO2G2O2GGMyvOZ3N8ZscC+bbowx4Y+8ZgoLXQUW6uDqwvma3hTTXFX1RESildd1/c/vWxC2qntOnel/A1wLLPOeaYy5FLgBiAcygReMMXXdi18EJgMd3a/MsEVbS23awFWU108uG4pRVfVERKLT20ev8rzvxwoOfncwLFX3HEn61trN1totPhZdA7xprT1urd0JbAd6GWN+A5xnrf3KWmuBOcCIMIZcKzmPnCKTjz3TC7lKVfVERKLYPX/5FatwdXTX4ySD+TQsVfci7Zp+a+B7r+ki97zW7veV5/tkjJlsjFltjFm9b9++kARaHVmd19ACVxx7aElxm26qqiciEsUKC/FU3TtCLK35wTM/lEL2zJgxZjHwax+Lsq217/vbzMc8W8V8n6y1M4GZAD169AjfsxD+LCzv2v/VuEx2vhpp/9cSEZFwatMG5nw3jpWk8jkDOU6MZ34ohSzpW2uvrMFmRYD3YPRxwC73/Dgf838ZvAdfuOoq/+uJiEhUyMmByZM7sPNoB8+8cFz2jbRTzg+AG4wx5xhj2uO6YS/PWrsb+MkYk+q+a38c4K+3ILLs3w95ea73depUfExDRESiUlYWzJzpGpXXGNfPcFz2dWRIOGPMSOA5oAUw3xizzlqbYa3daIyZB2wCSoHbrbUn3Zv9LzAbaAgsdL8i3yeflI+21Ls3NG3qbDwiIhIRsrLCf2+XI0nfWvsu8K6fZTnAaR0c1trVQEKIQws+r+v5qqonIiJOirTu/bPLqVOwaFH5tK7ni4iIg5T0Q2n1atc1fYCWLSElxdl4REQkqinph0huLvw1vbxrf0enTNeNfCIiIg5RFgqBsqp6fQ6VJ/2H865SVT0REXGUsWGs4+uEHj162NWrV4d1n+3aweHv9rOXltTBcpI6tGAf57VtSkFBWEMREZEoY4xZY63t4WuZzvRDoLAQBvNphap6/6GpquqJiIijlPRDoE0byKT8rv2FXOWZLyIi4hQl/RCoXFVvEZmqqiciIo5zZHCes11W4npgDwD7aeaqqveYquqJiIizlPRDwWtAnuZj0tnxRl0HgxEREXFR934oeI/Cl5npXBwiIiJelPSD7b//hS+/LJ9WVT0REYkQSvrBtnQplJa63nftCr/+tbPxiIiIuCnpB5u69kVEJEIp6QeTtUr6IiISsZT0g2nbNjzj7DZuDH36OBqOiIiINyX9YPI+y7/8cmjQwLlYREREKlHSD5LcXFh6X3nSz2uqrn0REYksSvpBkJsLd95SQu+Szz3zJvwjQ6V0RUQkoijpB0F2NnQ/tpxYjgGwhU5sLmlPdrbDgYmIiHhR0g+CwkJI5xPP9MdkeOaLiIhECiX9IGjTxnfSVyldERGJJEr6QfDUvbtJZj0AJ6jPFwxQKV0REYk4SvpB8D/nfep5/yWX0bxtI2bOVCldERGJLCqtGwyflHftD/pzBgX3OxiLiIiIHzrTr61Tp+DT8jN9VdUTEZFIpaRfW/n5sHev633z5q7KeiIiIhFISb+2vLr2GTwY6ugjFRGRyKQMVVveST8jw7k4REREzkBJvzaOHIEVK8qnBw92LhYREZEzUNKvjWXL4MQJ1/uEBGjVytl4REREqqBH9mrj44/L3+uu/ajy888/U1RURElJidOhiEiUiomJIS4ujvr16we8jZJ+DeXmQq8XPqGje3pJvXQudzQiCaeioiIaN25Mu3btMMY4HY6IRBlrLcXFxRQVFdG+ffuAt1P3fg3k5sLDN39Px583A1DCOYx+Lk2ldKNISUkJzZo1U8IXEUcYY2jWrFm1exuV9GsgOxv6lZQPyLOMNA4ca6hSulFGCV9EnFST7yAl/RooLITBlCf9TxnsmS8SLnXr1qVr164kJCQwevRojh496nfd2bNnc8cddwDw0ksvMWfOnJDG9uCDD7J48eIabVtQUEBCQkKQI6qedu3asX///pDvZ926dfTp04f4+HiSkpKYO3duyPcp0U3X9Gug7YWnuLKw/AutLOmrlK6EU8OGDVm3bh0AWVlZvPTSS9x9991n3G7KlCmhDo0//elPId9HdZWWllKvXmR95cXGxjJnzhw6duzIrl276N69OxkZGZx//vlOhyZnKZ3p18CMyfm0wHUWsJcWrCdJpXTFUf3792f79u0cOHCAESNGkJSURGpqKuvXrz9t3WnTpvHkk08CMHDgQO677z569epFp06dWL58OeC6Z2HixIkkJiaSkpLC0qVLAVePwYgRIxg2bBjt27fn+eef5+mnnyYlJYXU1FQOHDgAwIQJE3jrrbcA+Oyzz0hJSSExMZFJkyZx/Pjx02Jas2YNycnJ9OnThxkzZnjmnzx5kqlTp9KzZ0+SkpL429/+5vP3f+SRR+jcuTODBw9mzJgxFX6/3//+9wwYMIBnn32WDz/8kN69e5OSksKVV17Jnj17ACguLiY9PZ2UlBRuvfVWrLWetp9++mkSEhJISEjgmWee8bn/Ro0akZ2dTXJyMqmpqZ52z6RTp0507Oi6HbhVq1a0bNmSffv2BbStSE0o6dfA1fXLu/YXcyVt2tZRKV1xTGlpKQsXLiQxMZGHHnqIlJQU1q9fz2OPPca4ceMC2j4vL49nnnmGhx9+GMCTeDds2MA//vEPxo8f77lh6JtvvuGNN94gLy+P7OxsYmNjWbt2LX369DntskFJSQkTJkxg7ty5bNiwgdLSUl588cXTYpg4cSLTp0/nq6++qjD/5ZdfpkmTJqxatYpVq1Yxa9Ysdu7cWWGd1atX8/bbb7N27VreeecdVq9eXWH5wYMH+eKLL7jnnnvo168fK1euZO3atdxwww385S9/AeDhhx+mX79+rF27luHDh1Povla3Zs0aXnnlFb7++mtWrlzJrFmzWLt27WnxHzlyhNTUVPLz80lLS2PWrFkA5Obm0rVr19Neo0aNOq2NvLw8Tpw4wUUXXeTnSInUXmT1df1SeFXVu/Hvg7lxooOxSNQ6duwYXd0Fnvr3789NN91E7969efvttwG4/PLLKS4u5tChQ1W2c+211wLQvXt3CgoKAFixYgV33nknAJ07d6Zt27Zs3boVgEGDBtG4cWMaN25MkyZNGDZsGACJiYmn9Sxs2bKF9u3b06lTJwDGjx/PjBkz+N3vfudZ59ChQxw8eJABAwYAMHbsWBYuXAjAJ598wvr16z29BocOHWLbtm0VHlFasWIF11xzDQ0bNgTwxFPm+uuv97wvKiri+uuvZ/fu3Zw4ccLTzrJly3jnnXcAGDJkCBdccIGn7ZEjR3Luued6Pqvly5eTkpJSYR8NGjRg6NChns/xU/d3RFZWFlkBnA3s3r2bsWPH8uqrr1JH9TskhJT0q+vYMXB3gQIaelcc431Nv4x3t3SZM93he8455wCuGwNLS0v9tlN5fYA6dep4puvUqePZvqp4KrPW+o3RWstzzz1HRhV1Lc60j7KEDXDnnXdy9913M3z4cD7//HOmTZvmWeYrhkDiB6hfv75ne+/PMTc3lyeeeOK09S+++GLPf2T++9//MmTIEB599FFSU1MD2p9ITem/lNW1YgWUXZPs3Bni4pyNR8RLWloaue4BIz7//HOaN2/OeeedV6t2tm7dSmFhIZdcckm12+ncuTMFBQVs374dgNdee81zRl/m/PPPp0mTJqxw17HI9RrwIiMjgxdffJGff/7ZE8uRI0cqbN+vXz8+/PBDSkpKOHz4MPPnz/cbz6FDh2jdujUAr776qs/fd+HChfznP//xzH/vvfc4evQoR44c4d1336V///4B//5ZWVmsW7futFdZwj9x4gQjR45k3LhxjB49OuB2RWpKZ/rV5dW1r7N8iTTTpk1j4sSJJCUlERsbWyGxVcdtt93GlClTSExMpF69esyePbvCGX6gYmJieOWVVxg9ejSlpaX07NnT59MDr7zyCpMmTSI2NrbCWf3NN99MQUEB3bp1w1pLixYteO+99yps27NnT4YPH05ycjJt27alR48eNGnSxGc806ZNY/To0bRu3ZrU1FTP/QEPPfQQY8aMoVu3bgwYMIA27kdxunXrxoQJE+jVq5cnnspd+7Uxb948li1bRnFxMbNnzwZcN0uWXbYRCTYTaPfVL1WPHj1s5Rt7aiUlBcq6VN9/H4YPD17b8ouxefNmunTp4nQY4nb48GEaNWrE0aNHSUtLY+bMmXTr1s3psERCztd3kTFmjbW2h6/1daZfHXv3lif8unVh4EBHwxERl8mTJ7Np0yZKSkoYP368Er6IH0r61fHZZ+XvU1OhBtdKJTrl5rqGby4sdA3ilJOjRzyD6Y033nA6BJFfBCX96tD1fKmB3FyYPBnKRsn97jvXNCjxi0h46e79AOW+btk1pzzpf3xKSV8Ck51dnvDLHD2KCjSJSNgp6QcgNxeeuGUrrU4WAXCI8xj9RC+V0pWA+CvEpAJNIhJuSvoBqFxKdymD+OlYPZ2pSUD8FWI6Wwo0TZ8+nS5dupCVlUXfvn3PuH4g6/hy8OBBXnjhhRpt662goICGDRvqsbgwKBs1skGDBgFXLfR1fBYtWsQll1zCxRdfzOOPP+5zu0DWqWzSpEm0bNmyyqqONWk3mPupyWdYJWvtWf3q3r27rS1jrH2P4daCtWBv43kLrvkSnTZt2hTwuq+/bm1srOfPx4Jr+vXXQxhgGF1yySV2x44dId/Pzp07bXx8fMS0I4Fr27at3bdvX0DrVj4+paWltkOHDvbbb7+1x48ft0lJSXbjxo0VtglkHV+++OILu2bNGr9/DzVtNxT78fcZ+vouAlZbPzlRZ/oBaNMGssnhXp7gY9JVSleqJSsLZs6Etm3BGNfPUBZo+uMf/8izzz7rmc7Ozmb69OmnrTdnzhySkpJITk5m7NixQNUV5V5//XV69epF165dufXWWzl58iRTpkxhx44dDB8+nL/+9a80atSoyvYBzzq+2isoKKBLly7ccsstxMfHk56ezrFjxwC4//77+fbbb+natStTp07128aRI0cYMmQIycnJJCQkBFSj/q233iI1NZXk5GT69etX7Up3td2+tpzYf7j2mZeXx8UXX0yHDh1o0KABN9xwA++//3611/ElLS2Npk2b1mrfgQjXfgKhpB+AnBzYGZvAU9xLJh+zjU4qpSvVkpUFBQVw6pTrZyjv2r/ppps8I/GdOnWKN99887SiLxs3biQnJ4clS5aQn5/Ps88+W2VFuc2bNzN37ly+/PJL1q1bR926dcnNzeWll16iVatWLF26lLvuuqvK9r35aw9g27Zt3H777WzcuJHzzz/fU0Do8ccf56KLLmLdunU88cQTfttYtGgRrVq1Ij8/n2+++YbMzMwzfmaDBg1i5cqV5OfnM3jwYObNm1etz7y229eWE/uv6T779+/vs/Lg4sWLfa7/ww8/cOGFF3qm4+Li+OGHH6q9Tk2Eql2n9gN6ZC8gZd+Xes5afgnatWtHs2bNWLt2LXv27CElJYVmzZpVWGfJkiWMGjWK5s2bA9C0aVNee+01vxXlPvvsM9asWUPPnj0B13XGli1b+o3BV/ve/LWXlpZG+/btPddzvSv/VeavjRtvvJF7772X++67j6FDhwY0Vv7s2bOZO3cux48f58cff+Sxxx7jyJEj3HbbbTRo0ICBAwdWWS3P1/Y7duwgJyeHQ4cOecbaDxVf+6+J6sRc030u9y5YFgAbQBGpQNapiVC169R+QEk/YFlZSvLyy3HzzTcze/ZsfvzxRyZNmnTacuujsp2vLx7vZePHj+fPf/5zQPv31X4g7RUUFFQY479u3bqe7v3qxLRmzRoWLFjAAw88QHp6Og8++KDfWObMmUNeXh5LliyhUaNGpKWlER8fzzvvvMOoUaMYNmwY119/vd+k72/7Dh068PLLLzNq1Ci/+w4Gf/svKipi7NixDB8+nJUrVwZ0mSPQmGuzz/79+/PTTz+dNv/JJ5/kyiuvPG1+XFwc33//vWe6qKiIVq1aVXudmqhJuzNmzGDWrFkALFiwIKA4QhW/L+reFzkLjRw5kkWLFrFq1SqfZWmvuOIK5s2bR3FxMQAHDhyosqLcFVdcwVtvvcXevXs963/33Xd+9++r/crLq9MeQOPGjSskC39t7Nq1i9jYWH77299y77338q9//avKdjds2EDfvn1p1KgRb7/9Nv/85z9JTEykqKjI0+Vat27dCvv17nr1t31Vn01Nu259betv//n5+YwYMYK77rqLevXqedYdOnRohVfZ5xeqfVa2fPlyn5UHfSV8cBVU2rZtGzt37uTEiRO8+eabDK9U8+RM69T0M69Ju7fffrvndwo0cQfyOwaLkr7IWahBgwYMGjSI6667rkLCKhMfH092djYDBgwgOTmZu+++u0JFud69e1eoKHfppZfy6KOPkp6eTlJSEoMHD2b37t1+9++rfW/VbQ+gWbNmXHbZZSQkJDB16lS/bWzYsMFzc19OTg5/+MMfqmx3/PjxTJ8+nf79+7N161Y6dOjAueeeS1xcHEVFrrE5Tp065fm5ffv2Cpcr/G3vi6/tAa6++mp27dpV5Tx/2/rbf35+vuc/fGW9LomJiXz00UcVXlVdpgnGPmurXr16PP/882RkZNClSxeuu+464uPjgfLPqKp1/P0OAGPGjKFPnz5s2bKFuLg4Xn755aC0G8z9BJ2/2/rPllcwHtkTqaw6j+w54eTJkzY5Odlu3brV6VAiTqCP7B0+fNhOmDDBTpkyxb7ufr5yw4YN9q677gpoP/v377e33nqr7dChg33ssceqvX1l1d124sSJ9uTJk3bfvn32nnvuqVHMwdpnbR7Zq63afOZOtOtPsB7Zc6S0rjFmNDAN6AL0stauds8fDDwONABOAFOttUvcy7oDs4GGwALg/9gAgg96aV0RIru07qZNmxg6dCgjR47kqaeecjqciPP999/Tt29fmjVrxrqyqpkSEseOHaNPnz7s27ePDRs2BHRWrONT0Zk+w19Kad1vgGuBv1Wavx8YZq3dZYxJAD4GWruXvQhMBlbiSvqZwMLwhCvyy3HppZeyY8cOp8OIWBdeeGGFm6YkdBo2bFjtxK3jU1FNPsOqOJL0rbWbwedjF2u9JjcCMcaYc4CmwHnW2q/c280BRqCkLyIiErBIvpHvf4C11trjuM72i7yWFVHeAyAiIiIBCNmZvjFmMfBrH4uyrbVVji9ojIkH/i+QXjbLx2p+r+cbYybjuhRAG42VKyIiAoQw6VtrfT90eQbGmDjgXWCctfZb9+wiIM5rtThgV+VtvfY9E5gJrhv5ahKHyJnYMwxAIyISSjW5ET+iuveNMecD84EHrLVfls231u4GfjLGpBrXt+w4IDTVCEQCEBMTQ3FxcY3+0YmI1Ja1luLiYmJiYqq1nSM38hljRgLPAS2A+caYddbaDOAO4GLgj8aYP7pXT7fW7gX+l/JH9haim/jEQWUDt4S7mpqISJmYmBji4uLOvKIXR57TDyc9py8iItGkquf0I6p7X0REREJHSV9ERCRKKOmLiIhEibP+mr4xZh9Qdc3O4GiOaxhhcY6OQWTQcYgMOg7Oc+oYtLXWtvC14KxP+uFijFnt78YJCQ8dg8ig4xAZdBycF4nHQN37IiIiUUJJX0REJEoo6QfPTKcDEB2DCKHjEBl0HJwXccdA1/RFRESihM70RUREooSSfi0YY0YbYzYaY04ZY3pUWvaAMWa7MWaLMSbDqRijjTFmmjHmB2PMOvfraqdjihbGmEz33/t2Y8z9TscTrYwxBcaYDe6/f41BHibGmL8bY/YaY77xmtfUGPOpMWab++cFTsYISvq19Q1wLbDMe6Yx5lLgBiAeyAReMMbUDX94Ueuv1tqu7tcCp4OJBu6/7xnAVcClwBj3vwNxxiD3339EPS52lpuN6/ve2/3AZ9bajsBn7mlHKenXgrV2s7V2i49F1wBvWmuPW2t3AtuBXuGNTiSsegHbrbU7rLUngDdx/TsQiQrW2mXAgUqzrwFedb9/FRgR1qB8UNIPjdbA917TRe55Eh53GGPWu7vbHO9OixL6m48cFvjEGLPGGDPZ6WCi3K+stbsB3D9bOhwP9ZwOINIZYxYDv/axKNta+76/zXzM02MSQVLVMQFeBB7B9Xk/AjwFTApfdFFLf/OR4zJr7S5jTEvgU2PMv91noSJK+mdirb2yBpsVARd6TccBu4ITkQR6TIwxs4CPQhyOuOhvPkJYa3e5f+41xryL69KLkr4z9hhjfmOt3W2M+Q2w1+mA1L0fGh8ANxhjzjHGtAc6AnkOxxQV3P+wyozEdbOlhN4qoKMxpr0xpgGuG1k/cDimqGOMOdcY07jsPZCO/g046QNgvPv9eMBf73DY6Ey/FowxI4HngBbAfGPMOmtthrV2ozFmHrAJKAVut9aedDLWKPIXY0xXXF3LBcCtzoYTHay1pcaYO4CPgbrA3621Gx0OKxr9CnjXGAOu7/c3rLWLnA0pOhhj/gEMBJobY4qAh4DHgXnGmJuAQmC0cxG6aEQ+ERGRKKHufRERkSihpC8iIhIllPRFRESihJK+iIhIlFDSFxERiRJK+iIiIlFCSV9ERCRKKOmLSNAYY3q6ix3FuEeH22iMSXA6LhFx0eA8IhJUxphHgRigIVBkrf2zwyGJiJuSvogElXvs/VVACdBXQ1CLRA5174tIsDUFGgGNcZ3xi0iE0Jm+iASVMeYD4E2gPfAba+0dDockIm6qsiciQWOMGQeUWmvfMMbUBf5pjLncWrvE6dhERGf6IiIiUUPX9EVERKKEkr6IiEiUUNIXERGJEkr6IiIiUUJJX0REJEoo6YuIiEQJJX0REZEooaQvIiISJf4/bBwRsswl7CcAAAAASUVORK5CYII=\n","text/plain":[""]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["'''\n","Ejemplo 1: representación gráfica de una función\n","'''\n","print(\"\\n Ejemplo 1: cuerpo en caída libre\")\n","\n","import numpy as np\n","\n","tmin,tmax= 0.0,10.0 #s\n","nopto=100\n","t=np.linspace(tmin,tmax,nopto) #Se define un vector de dimensión (nopto,), con valores en el intervalo [tmin,tmax]\n","y=np.array(t) # copia el vector, matriz, en general tensor t.\n","\n","def y_t(t,y0,v0):\n"," g=9.81 \n"," return y0+v0*t-0.5*g*t**2 \n","\n","y0=100.0 #m\n","v0= 5.0 #m/s\n","y=y_t(t,y0,v0)\n","\n","print(\"Para la condición inicial (y0,v0)=(\",y0,\"m,\",v0,\"m/s)\")\n","\n","'''\n","Elementos esenciales en una representación gráfica\n","'''\n","# Se llama a las bibliotecas necesarias\n","import matplotlib.pyplot as plt\n","import numpy as np\n","\n","fig,ax = plt.subplots(figsize=(5,5))\n","ax.plot(t,y, color=\"blue\", linewidth=0,linestyle='--',marker=\".\",markersize=12)\n","ax.set_ylabel(\"y(m)\")\n","ax.set_xlabel(\"t(s)\")\n","ax.legend()\n","plt.show()\n","\n","'''\n","Ejemplo 2: representación gráfica de una función\n","'''\n","print(\"\\n Ejemplo 2: representación de un polinomio\")\n","\n","def polynomial(x,a): \n"," result=0\n"," n=len(a)-1 \n"," i=0\n"," for factor in a:\n"," result=result+factor*x**i\n"," i=i+1\n"," return result\n","\n","# Se llama a las bibliotecas necesarias\n","import matplotlib.pyplot as plt\n","import numpy as np\n","\n","a=[0.0,1.0,-1.0] # a_0*x**(0)+a_1*x**(1)+...a_n*x**n, donde el grado del polinomio es n=len(a)-1\n","txt=\"Polinomio de grado n=\"+str(len(a)-1)+\" \\n y coeficientes [$a_0,a_{1},..,a_{n-1},a_n$]=\"+str(a)\n","print(txt)\n","xmin,xmax,nopto=-10.3,10.5,100\n","'''\n","Para cada valor asignado al vector x mediante el método np.linspace, \n","la función polynomial calcula su valor volcándolo en el vector y. \n","'''\n","x=np.linspace(xmin,xmax,nopto) #Se define un vector de dimensión (nopto,), con valores en el intervalo [xmin,xmax]\n","y1=polynomial(x,a)\n","\n","'''\n","La forma equivalente utilizando el bucle for sería la siguiente (se parte de la definición previa de x)\n","'''\n","y2=np.array(x) #Crea un array idéntico a x\n","for i in range(0,len(x)):\n"," y2[i]=polynomial(x[i],a)\n","'''\n","Elementos esenciales en una representación gráfica\n","'''\n","fig,ax = plt.subplots(figsize=(8,8))\n","ax.plot(x,y1, color=\"blue\", linewidth=0,linestyle='--',marker=\".\",markersize=12,label=txt)\n","ax.plot(x,y2, color=\"red\", linewidth=3,linestyle='-')\n","ax.set_title(\"$a_0+a_{1} x+...a_{n-1} x^{n-1}+a_n x^n$\")\n","ax.set_ylabel(\"y\")\n","ax.set_xlabel(\"x\")\n","ax.legend()\n","plt.show()"]}],"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.7.6"},"colab":{"provenance":[],"toc_visible":true}},"nbformat":4,"nbformat_minor":0}
![\"Licencia](\"https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png\")