From d0187aaf529a8a566a4c34000a0fc8b374454853 Mon Sep 17 00:00:00 2001 From: Wilmailys Date: Fri, 3 Sep 2021 18:33:50 -0400 Subject: [PATCH] Add files via upload --- your-project/tic-tac-toe_proyect/README.md | 1 + .../tic-tac-toe_proyect/Tic-Tac-ToeV4.ipynb | 676 ++++++++++++++++++ .../Versiones/Tic-Tac-Toe.ipynb | 490 +++++++++++++ .../Versiones/Tic-Tac-ToeV2.ipynb | 430 +++++++++++ .../Versiones/Tic-Tac-ToeV3.ipynb | 524 ++++++++++++++ .../tic-tac-toe_proyect/meme_monkey.jpg | Bin 0 -> 92530 bytes your-project/tic-tac-toe_proyect/memekid2.jpg | Bin 0 -> 72679 bytes .../tic-tac-toe_proyect/tic_tac_toe.jpg | Bin 0 -> 8703 bytes 8 files changed, 2121 insertions(+) create mode 100644 your-project/tic-tac-toe_proyect/README.md create mode 100644 your-project/tic-tac-toe_proyect/Tic-Tac-ToeV4.ipynb create mode 100644 your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-Toe.ipynb create mode 100644 your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-ToeV2.ipynb create mode 100644 your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-ToeV3.ipynb create mode 100644 your-project/tic-tac-toe_proyect/meme_monkey.jpg create mode 100644 your-project/tic-tac-toe_proyect/memekid2.jpg create mode 100644 your-project/tic-tac-toe_proyect/tic_tac_toe.jpg diff --git a/your-project/tic-tac-toe_proyect/README.md b/your-project/tic-tac-toe_proyect/README.md new file mode 100644 index 0000000..83aa9a2 --- /dev/null +++ b/your-project/tic-tac-toe_proyect/README.md @@ -0,0 +1 @@ +# tic-tac-toe_proyect \ No newline at end of file diff --git a/your-project/tic-tac-toe_proyect/Tic-Tac-ToeV4.ipynb b/your-project/tic-tac-toe_proyect/Tic-Tac-ToeV4.ipynb new file mode 100644 index 0000000..c732c9c --- /dev/null +++ b/your-project/tic-tac-toe_proyect/Tic-Tac-ToeV4.ipynb @@ -0,0 +1,676 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "13b3673f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import random\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "\n", + "# Esta libreria nos ayudara a centrar las imagenes que vamos a mostrar en la consola\n", + "from IPython.core.display import HTML\n", + "HTML(\"\"\"\n", + "\n", + "\"\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f15c1675", + "metadata": {}, + "outputs": [], + "source": [ + "def instrucctions():\n", + " \n", + " \"\"\"\n", + " When calling it, it returns us the instructions of the game.\n", + " \"\"\"\n", + " \n", + " print('The rules of SUPER TIC TAC TOE are:\\n')\n", + " print('1. The game is played on a grid thats 3 squares by 3 squares.\\n')\n", + " print('2. You are X, your friend (or the computer in this case) is O. Players take turns putting their marks in empty squares.\\n')\n", + " print('3. The first player to get 3 of her marks in a row (up, down, across, or diagonally) is the winner.\\n')\n", + " print('4. When all 9 squares are full, the game is over. If no player has 3 marks in a row, the game ends in a tie.\\n')\n", + " print('5. To play Player vs Machine enter 1, to play Player vs Player enter 0.')\n", + " print('6. The positions on the board are:')\n", + " \n", + " # Estas son las posiciones del tablero de juego.\n", + " print(' | 1 | 2 | 3 |')\n", + " print(' | 4 | 5 | 6 |')\n", + " print(' | 7 | 8 | 9 |')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "21eae7ef", + "metadata": {}, + "outputs": [], + "source": [ + "def show_board(board):\n", + " \"\"\"\n", + " Show us the game board.\n", + " \"\"\"\n", + " \n", + " # Le pasamos el tablero de juego y nos lo muestra en pantalla con las fichas jugadas.\n", + " print(' |', board[0], '|', board[1], '|', board[2], '|')\n", + " print(' |', board[3], '|', board[4], '|', board[5], '|')\n", + " print(' |', board[6], '|', board[7], '|', board[8], '|')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8d39617c", + "metadata": {}, + "outputs": [], + "source": [ + "def permutation(L):\n", + " \n", + " \"\"\"\n", + " This function allows us to perform the permutation of a list where there are no \n", + " repetitions and no order.\n", + " \"\"\"\n", + " \n", + " combination = [] # Creamos una lista vacio\n", + " for i in range(len(L)): \n", + " x = L[i:i+3] # Le damos a x el valor de L desde i hasta i=3. Si i=0 agarramos todo el arreglo \n", + " length = len(x) # pero si i=1 agarramos desde 1 hasta 4 (no importa que agarremos mas de los que hay toma hasta el ultimo)\n", + " if length != 3: \n", + " x = x + L[:3-length] # Ejm: [6,2,3] si i=1 entonces x=[2,3] Al entrar al if L[:3-2] = L[:1],\n", + " combination.append(x) # es decir nos da [6] y obtenemos [2,3,6]\n", + " \n", + " return combination" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b83b375e", + "metadata": {}, + "outputs": [], + "source": [ + "def choose_letter():\n", + " \n", + " \"\"\"\n", + " Allows the user to choose whether to play Tic-Tac-Toe with the 'X' or 'O' token.\n", + " \"\"\"\n", + " \n", + " while True:\n", + " user_var = input('Choose the tiles you want to play with. You can choose \"O\" or \"X\".\\n') # Input del usuario\n", + " \n", + " if user_var == 'help':\n", + " instrucctions()\n", + " elif user_var == 'O': # Si el usuario escoge X la computadora juega con O\n", + " cpu_var = 'X'\n", + " print(f'You have choose the letter {user_var}. The other player will play with {cpu_var}')\n", + " break\n", + " \n", + " elif user_var == 'X': # Si el usuario escoge O la computadora juega con X\n", + " cpu_var = 'O'\n", + " print(f'You have choose the letter {user_var}. The other player will play with {cpu_var}')\n", + " break\n", + "\n", + " else: # Si el usuario no escoge ni X o O se mostrara el siguiente mensaje de ERROR\n", + " print('\\nERROR --> You did not enter either \"X\" or \"O\". Please enter any of these options\\n')\n", + " \n", + " return user_var, cpu_var" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9e84966b", + "metadata": {}, + "outputs": [], + "source": [ + "def user_imput(game_table, user_var):\n", + "\n", + " \"\"\"\n", + " Receive the position where the user wants to play his token. If the user enters incorrect values, \n", + " the corresponding messages are displayed on the screen.\n", + " \"\"\"\n", + " \n", + " while True:\n", + " try:\n", + " x = input('\\033[1m' + '\\nChoose the position where you wanna play (from 1 to 9):\\n' + '\\033[0m') # Le preguntamos donde desea jugar\n", + " if x == 'help': # Si escribe la palabta help se ejecuta la funcion instrucctions() que muestra las instrucciones\n", + " instrucctions()\n", + " else:\n", + " x = int(x)\n", + " if 1 <= x <= 9:\n", + " if game_table[x-1] == '-':\n", + " game_table[x-1] = user_var\n", + " break\n", + " else :\n", + " print('You choose a position where you cant play. Choose again.\\n')\n", + " else:\n", + " print('The given coordinates are wrong. Please introduce a new ones.\\n')\n", + " \n", + " except ValueError: # En caso de que usuario introduzca un palabra, evitamos el error con el except y el codigo sigue corriendo\n", + " print('You have introduced a word not a number')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "358fc098", + "metadata": {}, + "outputs": [], + "source": [ + "def check_block_win(game_table, comb, letter, cpu_var, move):\n", + " \n", + " # Esta funcion nos ayuda a que el codigo sea mas limpio, ya que no repetimos lo mismo muchas veces\n", + " \n", + " for i, j, k in comb:\n", + " # Preguntamos si la letra (X o O) se encuentra en dos posiciones adyacentes y la tercera casilla esta vacia\n", + " # Si ese es el caso, entonces tenemos que ganar o bloquear, depende de lo que queramos\n", + " \n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " return move\n", + "\n", + "def cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, letter, cpu_var):\n", + " \n", + " \"\"\"\n", + " This function analyzes the game board. Look for possible plays in which the computer can win. \n", + " The function also allows the computer to study the user, preventing the user from winning.\n", + " \"\"\"\n", + " \n", + " move = 0 # move sera igual a 1 si realizamos un moviemiento, nos ayuda a evitar que la computadora realice mas de 1 jugada\n", + " # Estudiamos las columnas\n", + " move = check_block_win(game_table, comb1, letter, cpu_var, move) \n", + " move = check_block_win(game_table, comb2, letter, cpu_var, move)\n", + " move = check_block_win(game_table, comb3, letter, cpu_var, move)\n", + " \n", + " # Estudiamos las filas\n", + " move = check_block_win(game_table, comb4, letter, cpu_var, move)\n", + " move = check_block_win(game_table, comb5, letter, cpu_var, move)\n", + " move = check_block_win(game_table, comb6, letter, cpu_var, move)\n", + " \n", + " # Estudiamos las diagonales\n", + " move = check_block_win(game_table, comb7, letter, cpu_var, move)\n", + " move = check_block_win(game_table, comb8, letter, cpu_var, move)\n", + " \n", + " return move" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9972b428", + "metadata": {}, + "outputs": [], + "source": [ + "def check_inteligent_move(game_table, comb, cpu_var, move):\n", + " \n", + " # Buscamos una ficha jugada por la computadora que este acompaƱada por dos casillas vacias donde ella pueda jugar\n", + " \n", + " for i, j, k in comb:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move == 0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " return move\n", + "\n", + "def computer_move(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu_var):\n", + " \n", + " \"\"\"\n", + " Study the game board. Look for a token played by the computer that is accompanied by two \n", + " empty squares where she can play.\n", + " \"\"\"\n", + " \n", + " # Para evitar movimientos repetidos, creamos una lista donde las distintas combinaciones para ganar se revuelven\n", + " # aleatoriamente. Podria realizar un movmiento diagonal y en otra partida optar por uno vertical\n", + " move = 0\n", + " combinations = random.sample([comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8], k=8)\n", + " \n", + " while move == 0:\n", + " # Llamamos a la funcion definida previamente\n", + " move = check_inteligent_move(game_table, combinations[0], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[1], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[2], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[3], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[4], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[5], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[6], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[7], cpu_var, move)\n", + " \n", + " # Si ninguna de las jugadas anteriores son posibles, entonces la computadora jugara en un posicion aleatoria\n", + " if move == 0 and check_board_full(game_table) == 0: # Si no hemos jugado y el tablero no esta lleno, jugamos\n", + " \n", + " x = random.randint(0, 8) # Buscamos un numero aleatorio entre 0 y 8\n", + " if game_table[x] == '-':\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " \n", + " elif check_board_full(game_table) == 1: \n", + " # Puede darse el caso que el tablero este lleno y sea el turno de la computadora. Ella tiene que entender\n", + " # que no puede jugar ya que el tablero esta full. Por ende, hacemos que move sea igual a 1 para hacerle entender\n", + " # que ha jugado\n", + " move = 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d90063c9", + "metadata": {}, + "outputs": [], + "source": [ + "def check_win(board, letter):\n", + " \n", + " \"\"\"\n", + " Check the game board and see if any of the players have won.\n", + " \"\"\"\n", + " \n", + " win = 0 # Win sera igual a 1 si una de las condiciones es verdadero, y significa que alguien ha ganado\n", + " if board[0] == letter and board[1] == letter and board[2] == letter:\n", + " win = 1\n", + " elif board[3] == letter and board[4] == letter and board[5] == letter:\n", + " win = 1\n", + " elif board[6] == letter and board[7] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[0] == letter and board[3] == letter and board[6] == letter:\n", + " win = 1\n", + " elif board[1] == letter and board[4] == letter and board[7] == letter:\n", + " win = 1\n", + " elif board[2] == letter and board[5] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[0] == letter and board[4] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[2] == letter and board[4] == letter and board[6] == letter:\n", + " win = 1\n", + " \n", + " return win" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a67593f3", + "metadata": {}, + "outputs": [], + "source": [ + "def check_board_full(game_board):\n", + " \n", + " \"\"\"\n", + " Study the game board. If all the boxes are occupied and there is no winner, it is because there is a \n", + " tie between the opponents\n", + " \"\"\"\n", + " \n", + " count = 0 # Nos ayuda a contar el numero de casillas ocupadas en el tablero de juego\n", + " full = 0 # Sera igual 1 Si y solo si todas las casillas del tablero estan ocupadas\n", + " for i in game_board:\n", + " if i != '-': # Contamos el numero de casillas del tablero que son distintas a '-', es decir, distintas a vacio\n", + " count += 1\n", + " \n", + " if count == 9: # Si el numero de casillas contadas que son distintas a vacio es igual a 9 es porque existe un empate\n", + " full = 1\n", + " \n", + " return full" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7016fe1a", + "metadata": {}, + "outputs": [], + "source": [ + "def gameplay():\n", + " \n", + " \"\"\"\n", + " Allows the user to choose whether to play Player vs Player or Player vs Machine.\n", + " \"\"\"\n", + " \n", + " while True:\n", + " try:\n", + " print('\\033[1m' + '\\nHow do you wanna play? Playe vs Player or Player vs PC\\n' + '\\033[0m') # Preguntamos como se quiere jugar\n", + " option = input('\\nChoose 1 for Player vs Machine and 0 otherwise\\n') # 1 para P vs M y 0 para P vs P\n", + " \n", + " if option == 'help': # Si escribe la palabta help se ejecuta la funcion instrucctions() que muestra las instrucciones\n", + " instrucctions()\n", + " elif option == '0' or option == '1': # Si la opcion es 1 o 0 entramos\n", + " if option == '0':\n", + " print('You have chosen to play Player vs Player\\n')\n", + " else:\n", + " print('You have chosen to play Player vs Machine\\n')\n", + " \n", + " return int(option)\n", + " break\n", + "\n", + " else: # Si el usuario introduce un numero que no es 0 ni 1 nos muestra el siguiente mensaje\n", + " print('Your entry was not 1 or 0. Please enter one of those values')\n", + "\n", + "\n", + " except ValueError: # Si el usuario introduce una palabra encontraremos un error que evitaremos con el except\n", + " print('Your entry was not 1 or 0. Please enter one of those values')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cb4cda05", + "metadata": {}, + "outputs": [], + "source": [ + "def replay_game():\n", + " \n", + " \"\"\"\n", + " This function allows the user to choose if they want to play another game.\n", + " \"\"\"\n", + " \n", + " while True:\n", + " try: # Intentamos hacer este codigo, si encontramos un error vamos al except\n", + " replay_input = input(\"\\033[1m\" + '\\n\\nDo you wanna play again? Insert 1 for Yes or 0 for No\\n\\n' + '\\033[0m') \n", + " # Le preguntamos al usuario\n", + " \n", + " if replay_input == 'help':\n", + " instrucctions()\n", + " elif int(replay_input) == 1: # Si su respuesta es 1 entonces jugamos otra vez\n", + " replay = 0\n", + " break\n", + " elif int(replay_input) == 0: # Si su respuesta es 0 el juego termina\n", + " replay = 1\n", + " break\n", + " else:\n", + " print('The number entered is not 1 or 0') # Si no introduce 1 o 0 mostramos este mensaje\n", + " \n", + " except ValueError: # Si el jugador introduce una palabra obtendremos un error y con esto lo atrapamos\n", + " print('You have introduced a word not a number')\n", + " \n", + " return replay" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cf8a0e4f", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_imag(name):\n", + " \n", + " \"\"\"\n", + " Show us the image on the console.\n", + " \"\"\"\n", + " \n", + " img = mpimg.imread(name) # Usamos la libreria de matplotlib para abrir la imagen in mostrarla en la consola\n", + " imgplot = plt.imshow(img)\n", + " plt.axis('off')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "17d00d00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m -----WELCOME TO SUPER TIC-TAC-TOE!!!-----\n", + "\n", + "\u001b[0m\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": [ + "\u001b[1m\n", + "If you have never playes SUPER TIC-TAC-TOE write help for the instrucctions\n", + "\u001b[0m\n", + "\u001b[1m\n", + "How do you wanna play? Playe vs Player or Player vs PC\n", + "\u001b[0m\n", + "\n", + "Choose 1 for Player vs Machine and 0 otherwise\n", + "1\n", + "You have chosen to play Player vs Machine\n", + "\n", + "Choose the tiles you want to play with. You can choose \"O\" or \"X\".\n", + "X\n", + "You have choose the letter X. The other player will play with O\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "1\n", + " | X | - | - |\n", + " | - | - | O |\n", + " | - | - | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "3\n", + " | X | O | X |\n", + " | - | - | O |\n", + " | - | - | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "5\n", + " | X | O | X |\n", + " | - | X | O |\n", + " | - | - | O |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "7\n", + " | X | O | X |\n", + " | - | X | O |\n", + " | X | - | O |\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": [ + "\u001b[1m\n", + " --------THE USER WON THE MATCH--------\u001b[0m\n", + "\n", + "\n", + "Do you wanna play again? Insert 1 for Yes or 0 for No\n", + "\n", + "0\n" + ] + } + ], + "source": [ + "# ----------------------------- ENTRAMOS AL LOOP PRINCIPAL ---------------------------------------------------------\n", + "\n", + "print('\\033[1m' + ' -----WELCOME TO SUPER TIC-TAC-TOE!!!-----\\n\\n' + '\\033[0m')\n", + "\n", + "# Con estas funciones mostramos en pantalla una imagen que se encuentra en la misma carpeta que este archivo\n", + "plot_imag('tic_tac_toe.jpg')\n", + "\n", + "# Mostramos el mensaje de ayuda para el jugador\n", + "print(\"\\033[1m\" + '\\nIf you have never playes SUPER TIC-TAC-TOE write help for the instrucctions\\n' + \"\\033[0m\")\n", + "\n", + "# Procedemos a la definicion de variables basicas para el juego\n", + "comb1 = permutation([0, 1, 2])\n", + "comb2 = permutation([3, 4, 5])\n", + "comb3 = permutation([6, 7, 8])\n", + "comb4 = permutation([0, 3, 6])\n", + "comb5 = permutation([1, 4, 7])\n", + "comb6 = permutation([2, 5, 8])\n", + "comb7 = permutation([0, 4, 8])\n", + "comb8 = permutation([2, 4, 6])\n", + "replay = 0\n", + "\n", + "game_option = gameplay() # Llamamos a la funcion que nos permite escoger como queremos jugar\n", + "user, cpu = choose_letter() # Llamos la funcion choose letter para que el jugador escoja con que letra desea jugar\n", + "\n", + "\n", + "while replay == 0:\n", + " game_table = ['-', '-', '-', # Definimos nuestro tablero de juego\n", + " '-', '-', '-',\n", + " '-', '-', '-']\n", + " user_win = 0\n", + " user2_win = 0\n", + " cpu_win = 0\n", + " tie = 0\n", + " \n", + " # Loop para Player vs Player\n", + " while user_win == 0 and user2_win == 0 and tie == 0 and game_option == 0:\n", + " user_imput(game_table, user)\n", + " show_board(game_table)\n", + " user_win = check_win(game_table, user)\n", + " \n", + " if user_win == 0 and check_board_full(game_table) == 0:\n", + " user_imput(game_table, cpu)\n", + " show_board(game_table)\n", + " \n", + " user2_win = check_win(game_table, cpu)\n", + " if user_win == 0 and user2_win == 0:\n", + " tie = check_board_full(game_table)\n", + " \n", + " # Loop para Player vs Machine\n", + " while user_win == 0 and cpu_win == 0 and tie == 0 and game_option == 1:\n", + " user_imput(game_table, user) # Recibimos el imput del usuario\n", + " user_win = check_win(game_table, user) #Comprobamos si el Usuario gano\n", + "\n", + " if user_win == 0: # Si el usuario no ha ganado entramos y la computadora puede ver si ella puede ganar\n", + " winner_move = cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu, cpu)\n", + " \n", + " if winner_move == 0 and user_win == 0: #Significa que no hay jugada ganadora, y verifica si puede bloquear\n", + " block_move = cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, user, cpu)\n", + "\n", + " if block_move == 0 and winner_move == 0 and user_win == 0: #Significa que no hay jugada para bloquear y juega random\n", + " computer_move(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu)\n", + " \n", + " winner_move = 0 # Volvemos las variables 0 para los proximos loops\n", + " block_move = 0\n", + " cpu_win = check_win(game_table, cpu) #Comprobamos si la CPU gano\n", + " show_board(game_table) # Mostramo el talbero de juego\n", + "\n", + " if user_win == 0 and cpu_win == 0:\n", + " tie = check_board_full(game_table) # Comprobamos si hay un empate\n", + " \n", + " # Mensajes de victoria\n", + " if user_win == 1 or cpu_win == 1 or user2_win == 1:\n", + " plot_imag('memekid2.jpg')\n", + " if user_win == 1:\n", + " print(\"\\033[1m\" + '\\n --------THE USER WON THE MATCH--------' + \"\\033[0m\")\n", + " elif cpu_win == 1:\n", + " print(\"\\033[1m\" + '\\n --------THE COMPUTER WON THE MATCH--------' + \"\\033[0m\")\n", + " elif user2_win == 1:\n", + " print(\"\\033[1m\" + '\\n --------THE USER 2 WON THE MATCH--------' + \"\\033[0m\")\n", + " \n", + " else:\n", + " img = plot_imag('meme_monkey.jpg')\n", + " print(\"\\033[1m\" + '\\n --------THE MATCH END IN A TIE--------' + \"\\033[0m\")\n", + " \n", + " \n", + " # Le preguntamos al jugador si quiere jugar otra vez. Si escoge 1 juega otra vez. Si toma 0 el juego termina\n", + " replay = replay_game()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "062813a6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb1eaefe", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f81244f8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-Toe.ipynb b/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-Toe.ipynb new file mode 100644 index 0000000..537d99e --- /dev/null +++ b/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-Toe.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "13b3673f", + "metadata": {}, + "outputs": [], + "source": [ + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f15c1675", + "metadata": {}, + "outputs": [], + "source": [ + "def instrucctions():\n", + " print('The rules aof SUPER TIC TAC TOE are:\\n')\n", + " print('1. The game is played on a grid thats 3 squares by 3 squares.\\n')\n", + " print('2. You are X, your friend (or the computer in this case) is O. Players take turns putting their marks in empty squares.\\n')\n", + " print('3. The first player to get 3 of her marks in a row (up, down, across, or diagonally) is the winner.\\n')\n", + " print('4. When all 9 squares are full, the game is over. If no player has 3 marks in a row, the game ends in a tie.\\n')\n", + " print('5. The positions on the board are:')\n", + " print(' | 1 | 2 | 3 |')\n", + " print(' | 4 | 5 | 6 |')\n", + " print(' | 7 | 8 | 9 |')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "21eae7ef", + "metadata": {}, + "outputs": [], + "source": [ + "def show_board(board):\n", + " print(' |', board[0], '|', board[1], '|', board[2], '|')\n", + " print(' |', board[3], '|', board[4], '|', board[5], '|')\n", + " print(' |', board[6], '|', board[7], '|', board[8], '|')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8d39617c", + "metadata": {}, + "outputs": [], + "source": [ + "def permutation(L):\n", + " combination = []\n", + " for i in range(len(L)):\n", + " x = L[i:i+3]\n", + " length = len(x)\n", + " if length != 3:\n", + " x = x + L[:3-length]\n", + " combination.append(x)\n", + " \n", + " return combination" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b83b375e", + "metadata": {}, + "outputs": [], + "source": [ + "def choose_letter():\n", + " i = 0\n", + " while i == 0:\n", + " user_var = input('Choose the tiles you want to play with. You can choose \"O\" or \"X\".\\n')\n", + " if user_var == 'O':\n", + " cpu_var = 'X'\n", + " i = 1\n", + " print('You have choose the letter', user_var, '. The cpu will play with', cpu_var)\n", + " elif user_var == 'X':\n", + " cpu_var = 'O'\n", + " i = 1\n", + " print('You have choose the letter', user_var, '. The cpu will play with', cpu_var)\n", + " else:\n", + " print('You did not enter either \"X\" or \"O\". Please enter any of these options\\n')\n", + " \n", + " return user_var, cpu_var" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9e84966b", + "metadata": {}, + "outputs": [], + "source": [ + "def user_imput(game_table, user_var):\n", + " \n", + " i = 0\n", + " while i == 0:\n", + " x = input('\\nChoose the position where you wanna play (from 1 to 9):\\n')\n", + " \n", + " if x == 'help':\n", + " instrucctions()\n", + " \n", + " else:\n", + " x = int(x)\n", + " if 1 <= x <= 9:\n", + " if game_table[x-1] == '-':\n", + " i = 1\n", + " game_table[x-1] = user_var\n", + " else :\n", + " print('You chosse a position where you cant play. Chose again.\\n')\n", + " else:\n", + " print('The given coordinates are wrong. Please introduce a new ones.\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "358fc098", + "metadata": {}, + "outputs": [], + "source": [ + "def cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, letter, cpu_var):\n", + " \n", + "# SI LE PASO EN LETTER CPU ES PARA UNA JUGADA GANADORA. SI LE PASO EN LETTER USER ES PARA BLOQUEAR AL USUARIO\n", + "\n", + " # Check Columns\n", + " move = 0\n", + " for i, j, k in comb1:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb2:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb3:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " # Check Rows\n", + " for i, j, k in comb4:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + "\n", + " for i, j, k in comb5:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb6:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " # Check Diagonals\n", + " for i, j, k in comb7:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb8:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " return move" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "9972b428", + "metadata": {}, + "outputs": [], + "source": [ + "def computer_move(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu_var):\n", + " \n", + " move = 0\n", + " while move == 0:\n", + " \n", + " for i, j, k in comb1:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move ==0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb2:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move ==0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb3:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move ==0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " # Check Rows\n", + " for i, j, k in comb4:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move ==0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb5:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move ==0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb6:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move ==0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " # Check Diagonals\n", + " for i, j, k in comb7:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move ==0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " for i, j, k in comb8:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move ==0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + "\n", + "# SE QUEDA PEGADO AQUI SI EL TABLERO ESTA COMPLETO PORQUE NO PUEDE JUGAR EN NINGUNA POSICION\n", + " if move == 0 and check_board_full(game_table) == 0:\n", + " x = random.randint(0, 8)\n", + " if game_table[x] == '-':\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " elif check_board_full(game_table) == 1:\n", + " move = 1 # Necesitamos salir del while loop\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "d90063c9", + "metadata": {}, + "outputs": [], + "source": [ + "def check_win(board, letter):\n", + " win = 0\n", + " if board[0] == letter and board[1] == letter and board[2] == letter:\n", + " win = 1\n", + " elif board[3] == letter and board[4] == letter and board[5] == letter:\n", + " win = 1\n", + " elif board[6] == letter and board[7] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[0] == letter and board[3] == letter and board[6] == letter:\n", + " win = 1\n", + " elif board[1] == letter and board[4] == letter and board[7] == letter:\n", + " win = 1\n", + " elif board[2] == letter and board[5] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[0] == letter and board[4] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[2] == letter and board[4] == letter and board[6] == letter:\n", + " win = 1\n", + " \n", + " return win" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "a67593f3", + "metadata": {}, + "outputs": [], + "source": [ + "def check_board_full(game_board):\n", + " count = 0\n", + " full = 0\n", + " for i in game_board:\n", + " if i != '-':\n", + " count += 1\n", + " \n", + " if count == 9:\n", + " full = 1\n", + " \n", + " return full" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "caacd35f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " -----WELCOME TO SUPER TIC-TAC-TOE!!!-----\n", + "\n", + "\n", + " -------------------------\n", + " | X | X | X |\n", + " -------------------------\n", + " | O | | |\n", + " -------------------------\n", + " | X | O | O |\n", + " -------------------------\n", + " \n", + "\n", + "If you have never playes SUPER TIC-TAC-TOE write help for the instrucctions\n" + ] + } + ], + "source": [ + "print(' -----WELCOME TO SUPER TIC-TAC-TOE!!!-----\\n\\n')\n", + "\n", + "horiz_lines = ' -------------------------\\n'\n", + "print(horiz_lines + ' | X | X | X |')\n", + "print(horiz_lines + ' | O | | |')\n", + "print(horiz_lines + ' | X | O | O |')\n", + "print(horiz_lines, '\\n')\n", + "\n", + "print('If you have never playes SUPER TIC-TAC-TOE write help for the instrucctions')" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "17d00d00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Choose the tiles you want to play with. You can choose \"O\" or \"X\".\n", + "X\n", + "You have choose the letter X . The cpu will play with O\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "1\n", + " | X | - | - |\n", + " | - | - | - |\n", + " | - | - | O |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "5\n", + " | X | - | - |\n", + " | - | X | - |\n", + " | - | O | O |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "7\n", + " | X | - | - |\n", + " | O | X | - |\n", + " | X | O | O |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "3\n", + " | X | - | X |\n", + " | O | X | - |\n", + " | X | O | O |\n", + "\n", + " --------THE USER WON THE MATCH--------\n" + ] + } + ], + "source": [ + "# Procedemos a la definicion de variables basicas para el juego\n", + "game_table = ['-', '-', '-',\n", + " '-', '-', '-',\n", + " '-', '-', '-']\n", + "\n", + "comb1 = permutation([0, 1, 2])\n", + "comb2 = permutation([3, 4, 5])\n", + "comb3 = permutation([6, 7, 8])\n", + "comb4 = permutation([0, 3, 6])\n", + "comb5 = permutation([1, 4, 7])\n", + "comb6 = permutation([2, 5, 8])\n", + "comb7 = permutation([0, 4, 8])\n", + "comb8 = permutation([2, 4, 6])\n", + "user, cpu = choose_letter()\n", + "user_win = 0\n", + "cpu_win = 0\n", + "tie = 0\n", + "\n", + "while user_win == 0 and cpu_win == 0 and tie == 0:\n", + " user_imput(game_table, user)\n", + " user_win = check_win(game_table, user) #Comprobamos si el Usuario gano\n", + " \n", + " if user_win == 0:\n", + " winner_move = cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu, cpu)\n", + " if winner_move == 0 and user_win == 0: #Significa que no hay jugada ganadora\n", + " block_move = cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, user, cpu)\n", + " \n", + " if block_move == 0 and winner_move == 0 and user_win == 0: #Significa que no hay jugada para bloquear\n", + " computer_move(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu)\n", + " winner_move = 0\n", + " block_move = 0\n", + " cpu_win = check_win(game_table, cpu) #Comprobamos si la CPU gano\n", + " \n", + " show_board(game_table)\n", + " \n", + " if user_win == 0 and cpu_win == 0:\n", + " tie = check_board_full(game_table) # Comprobamos si hay un empate\n", + " \n", + "if user_win == 1:\n", + " print('\\n --------THE USER WON THE MATCH--------')\n", + "elif cpu_win == 1:\n", + " print('\\n --------THE COMPUTER WON THE MATCH--------')\n", + "else:\n", + " print('\\n --------THE MATCH END IN A TIE--------')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "062813a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " | X | X | O |\n", + " | O | O | X |\n", + " | X | O | X |\n" + ] + } + ], + "source": [ + "show_board(game_table)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9bfb7192", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-ToeV2.ipynb b/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-ToeV2.ipynb new file mode 100644 index 0000000..9f774bd --- /dev/null +++ b/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-ToeV2.ipynb @@ -0,0 +1,430 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "13b3673f", + "metadata": {}, + "outputs": [], + "source": [ + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f15c1675", + "metadata": {}, + "outputs": [], + "source": [ + "def instrucctions():\n", + " print('The rules of SUPER TIC TAC TOE are:\\n')\n", + " print('1. The game is played on a grid thats 3 squares by 3 squares.\\n')\n", + " print('2. You are X, your friend (or the computer in this case) is O. Players take turns putting their marks in empty squares.\\n')\n", + " print('3. The first player to get 3 of her marks in a row (up, down, across, or diagonally) is the winner.\\n')\n", + " print('4. When all 9 squares are full, the game is over. If no player has 3 marks in a row, the game ends in a tie.\\n')\n", + " print('5. The positions on the board are:')\n", + " print(' | 1 | 2 | 3 |')\n", + " print(' | 4 | 5 | 6 |')\n", + " print(' | 7 | 8 | 9 |')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "21eae7ef", + "metadata": {}, + "outputs": [], + "source": [ + "def show_board(board):\n", + " print(' |', board[0], '|', board[1], '|', board[2], '|')\n", + " print(' |', board[3], '|', board[4], '|', board[5], '|')\n", + " print(' |', board[6], '|', board[7], '|', board[8], '|')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8d39617c", + "metadata": {}, + "outputs": [], + "source": [ + "def permutation(L):\n", + " combination = []\n", + " for i in range(len(L)):\n", + " x = L[i:i+3]\n", + " length = len(x)\n", + " if length != 3:\n", + " x = x + L[:3-length]\n", + " combination.append(x)\n", + " \n", + " return combination" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b83b375e", + "metadata": {}, + "outputs": [], + "source": [ + "def choose_letter():\n", + " i = 0\n", + " while i == 0:\n", + " user_var = input('Choose the tiles you want to play with. You can choose \"O\" or \"X\".\\n')\n", + " if user_var == 'O':\n", + " cpu_var = 'X'\n", + " i = 1\n", + " print('You have choose the letter', user_var, '. The cpu will play with', cpu_var)\n", + " elif user_var == 'X':\n", + " cpu_var = 'O'\n", + " i = 1\n", + " print('You have choose the letter', user_var, '. The cpu will play with', cpu_var)\n", + " else:\n", + " print('You did not enter either \"X\" or \"O\". Please enter any of these options\\n')\n", + " \n", + " return user_var, cpu_var" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9e84966b", + "metadata": {}, + "outputs": [], + "source": [ + "def user_imput(game_table, user_var):\n", + " \n", + " i = 0\n", + " while i == 0:\n", + " x = input('\\nChoose the position where you wanna play (from 1 to 9):\\n')\n", + " \n", + " if x == 'help':\n", + " instrucctions()\n", + " \n", + " else:\n", + " x = int(x)\n", + " if 1 <= x <= 9:\n", + " if game_table[x-1] == '-':\n", + " i = 1\n", + " game_table[x-1] = user_var\n", + " else :\n", + " print('You chosse a position where you cant play. Chose again.\\n')\n", + " else:\n", + " print('The given coordinates are wrong. Please introduce a new ones.\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "358fc098", + "metadata": {}, + "outputs": [], + "source": [ + "def check_block_win(game_table, comb, letter, cpu_var, move):\n", + " for i, j, k in comb:\n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " return move\n", + "\n", + "def cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, letter, cpu_var):\n", + " move = 0\n", + " \n", + " # Check Columns\n", + " move = check_block_win(game_table, comb1, letter, cpu_var, move)\n", + "\n", + " move = check_block_win(game_table, comb2, letter, cpu_var, move)\n", + " \n", + " move = check_block_win(game_table, comb3, letter, cpu_var, move)\n", + " \n", + " # Check Rows\n", + " move = check_block_win(game_table, comb4, letter, cpu_var, move)\n", + " \n", + " move = check_block_win(game_table, comb5, letter, cpu_var, move)\n", + " \n", + " move = check_block_win(game_table, comb6, letter, cpu_var, move)\n", + " \n", + " # Check Diagonals\n", + " move = check_block_win(game_table, comb7, letter, cpu_var, move)\n", + " \n", + " move = check_block_win(game_table, comb8, letter, cpu_var, move)\n", + " \n", + " return move" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9972b428", + "metadata": {}, + "outputs": [], + "source": [ + "def check_inteligent_move(game_table, comb, cpu_var, move):\n", + " for i, j, k in comb:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move == 0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " return move\n", + "\n", + "def computer_move(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu_var):\n", + " \n", + " move = 0\n", + " combinations = random.sample([comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8], k=8)\n", + " while move == 0:\n", + " move = check_inteligent_move(game_table, combinations[0], cpu_var, move)\n", + " \n", + " move = check_inteligent_move(game_table, combinations[1], cpu_var, move)\n", + " \n", + " move = check_inteligent_move(game_table, combinations[2], cpu_var, move)\n", + " \n", + " move = check_inteligent_move(game_table, combinations[3], cpu_var, move)\n", + " \n", + " move = check_inteligent_move(game_table, combinations[4], cpu_var, move)\n", + " \n", + " move = check_inteligent_move(game_table, combinations[5], cpu_var, move)\n", + " \n", + " move = check_inteligent_move(game_table, combinations[6], cpu_var, move)\n", + " \n", + " move = check_inteligent_move(game_table, combinations[7], cpu_var, move)\n", + " \n", + "\n", + " if move == 0 and check_board_full(game_table) == 0:\n", + " x = random.randint(0, 8)\n", + " if game_table[x] == '-':\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " elif check_board_full(game_table) == 1:\n", + " move = 1 # Necesitamos salir del while loop\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d90063c9", + "metadata": {}, + "outputs": [], + "source": [ + "def check_win(board, letter):\n", + " win = 0\n", + " if board[0] == letter and board[1] == letter and board[2] == letter:\n", + " win = 1\n", + " elif board[3] == letter and board[4] == letter and board[5] == letter:\n", + " win = 1\n", + " elif board[6] == letter and board[7] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[0] == letter and board[3] == letter and board[6] == letter:\n", + " win = 1\n", + " elif board[1] == letter and board[4] == letter and board[7] == letter:\n", + " win = 1\n", + " elif board[2] == letter and board[5] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[0] == letter and board[4] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[2] == letter and board[4] == letter and board[6] == letter:\n", + " win = 1\n", + " \n", + " return win" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a67593f3", + "metadata": {}, + "outputs": [], + "source": [ + "def check_board_full(game_board):\n", + " count = 0\n", + " full = 0\n", + " for i in game_board:\n", + " if i != '-':\n", + " count += 1\n", + " \n", + " if count == 9:\n", + " full = 1\n", + " \n", + " return full" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "17d00d00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " -----WELCOME TO SUPER TIC-TAC-TOE!!!-----\n", + "\n", + "\n", + " -------------------------\n", + " | X | X | X |\n", + " -------------------------\n", + " | O | | |\n", + " -------------------------\n", + " | X | O | O |\n", + " -------------------------\n", + " \n", + "\n", + "If you have never playes SUPER TIC-TAC-TOE write help for the instrucctions\n", + "Choose the tiles you want to play with. You can choose \"O\" or \"X\".\n", + "X\n", + "You have choose the letter X . The cpu will play with O\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "1\n", + " | X | O | - |\n", + " | - | - | - |\n", + " | - | - | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "8\n", + " | X | O | - |\n", + " | - | - | O |\n", + " | - | X | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "3\n", + " | X | O | X |\n", + " | O | - | O |\n", + " | - | X | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "5\n", + " | X | O | X |\n", + " | O | X | O |\n", + " | - | X | O |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "7\n", + " | X | O | X |\n", + " | O | X | O |\n", + " | X | X | O |\n", + "\n", + " --------THE USER WON THE MATCH--------\n" + ] + } + ], + "source": [ + "print(' -----WELCOME TO SUPER TIC-TAC-TOE!!!-----\\n\\n')\n", + "\n", + "horiz_lines = ' -------------------------\\n'\n", + "print(horiz_lines + ' | X | X | X |')\n", + "print(horiz_lines + ' | O | | |')\n", + "print(horiz_lines + ' | X | O | O |')\n", + "print(horiz_lines, '\\n')\n", + "\n", + "print('If you have never playes SUPER TIC-TAC-TOE write help for the instrucctions')\n", + "\n", + "# Procedemos a la definicion de variables basicas para el juego\n", + "game_table = ['-', '-', '-',\n", + " '-', '-', '-',\n", + " '-', '-', '-']\n", + "\n", + "comb1 = permutation([0, 1, 2])\n", + "comb2 = permutation([3, 4, 5])\n", + "comb3 = permutation([6, 7, 8])\n", + "comb4 = permutation([0, 3, 6])\n", + "comb5 = permutation([1, 4, 7])\n", + "comb6 = permutation([2, 5, 8])\n", + "comb7 = permutation([0, 4, 8])\n", + "comb8 = permutation([2, 4, 6])\n", + "user, cpu = choose_letter()\n", + "user_win = 0\n", + "cpu_win = 0\n", + "tie = 0\n", + "\n", + "while user_win == 0 and cpu_win == 0 and tie == 0:\n", + " user_imput(game_table, user)\n", + " user_win = check_win(game_table, user) #Comprobamos si el Usuario gano\n", + " \n", + " if user_win == 0:\n", + " winner_move = cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu, cpu)\n", + " if winner_move == 0 and user_win == 0: #Significa que no hay jugada ganadora\n", + " block_move = cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, user, cpu)\n", + " \n", + " if block_move == 0 and winner_move == 0 and user_win == 0: #Significa que no hay jugada para bloquear\n", + " computer_move(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu)\n", + " winner_move = 0\n", + " block_move = 0\n", + " cpu_win = check_win(game_table, cpu) #Comprobamos si la CPU gano\n", + " \n", + " show_board(game_table)\n", + " \n", + " if user_win == 0 and cpu_win == 0:\n", + " tie = check_board_full(game_table) # Comprobamos si hay un empate\n", + " \n", + "if user_win == 1:\n", + " print('\\n --------THE USER WON THE MATCH--------')\n", + "elif cpu_win == 1:\n", + " print('\\n --------THE COMPUTER WON THE MATCH--------')\n", + "else:\n", + " print('\\n --------THE MATCH END IN A TIE--------')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "062813a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0, 1, 2], [1, 2, 0], [2, 0, 1]]\n" + ] + } + ], + "source": [ + "print(permutation([0, 1, 2]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb1eaefe", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f81244f8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-ToeV3.ipynb b/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-ToeV3.ipynb new file mode 100644 index 0000000..a650029 --- /dev/null +++ b/your-project/tic-tac-toe_proyect/Versiones/Tic-Tac-ToeV3.ipynb @@ -0,0 +1,524 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 67, + "id": "13b3673f", + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "#import colorama\n", + "#from colorama import Fore, Style\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "from PIL import Image" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "f15c1675", + "metadata": {}, + "outputs": [], + "source": [ + "def instrucctions():\n", + " \n", + " \"\"\"\n", + " When calling it, it returns us the instructions of the game.\n", + " \"\"\"\n", + " \n", + " print('The rules of SUPER TIC TAC TOE are:\\n')\n", + " print('1. The game is played on a grid thats 3 squares by 3 squares.\\n')\n", + " print('2. You are X, your friend (or the computer in this case) is O. Players take turns putting their marks in empty squares.\\n')\n", + " print('3. The first player to get 3 of her marks in a row (up, down, across, or diagonally) is the winner.\\n')\n", + " print('4. When all 9 squares are full, the game is over. If no player has 3 marks in a row, the game ends in a tie.\\n')\n", + " print('5. The positions on the board are:')\n", + " \n", + " # Estas son las posiciones del tablero de juego.\n", + " print(' | 1 | 2 | 3 |')\n", + " print(' | 4 | 5 | 6 |')\n", + " print(' | 7 | 8 | 9 |')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "21eae7ef", + "metadata": {}, + "outputs": [], + "source": [ + "def show_board(board):\n", + " \"\"\"\n", + " Show us the game board.\n", + " \"\"\"\n", + " \n", + " # Le pasamos el tablero de juego y nos lo muestra en pantalla con las fichas jugadas.\n", + " print(' |', board[0], '|', board[1], '|', board[2], '|')\n", + " print(' |', board[3], '|', board[4], '|', board[5], '|')\n", + " print(' |', board[6], '|', board[7], '|', board[8], '|')" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "8d39617c", + "metadata": {}, + "outputs": [], + "source": [ + "def permutation(L):\n", + " \n", + " \"\"\"\n", + " This function allows us to perform the permutation of a list where there are no \n", + " repetitions and no order.\n", + " \"\"\"\n", + " \n", + " combination = [] # Creamos una lista vacio\n", + " for i in range(len(L)): \n", + " x = L[i:i+3] # Le damos a x el valor de L desde i hasta i=3. Si i=0 agarramos todo el arreglo \n", + " length = len(x) # pero si i=1 agarramos desde 1 hasta 4 (no importa que agarremos mas de los que hay toma hasta el ultimo)\n", + " if length != 3: \n", + " x = x + L[:3-length] # Ejm: [6,2,3] si i=1 entonces x=[2,3] Al entrar al if L[:3-2] = L[:1],\n", + " combination.append(x) # es decir nos da [6] y obtenemos [2,3,6]\n", + " \n", + " return combination" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "b83b375e", + "metadata": {}, + "outputs": [], + "source": [ + "def choose_letter():\n", + " \n", + " \"\"\"\n", + " Allows the user to choose whether to play Tic-Tac-Toe with the 'X' or 'O' token.\n", + " \"\"\"\n", + " \n", + " while True:\n", + " user_var = input('Choose the tiles you want to play with. You can choose \"O\" or \"X\".\\n') # Input del usuario\n", + " if user_var == 'O': # Si el usuario escoge X la computadora juega con O\n", + " cpu_var = 'X'\n", + " print(f'You have choose the letter {user_var}. The cpu will play with {cpu_var}')\n", + " break\n", + " \n", + " elif user_var == 'X': # Si el usuario escoge O la computadora juega con X\n", + " cpu_var = 'O'\n", + " print(f'You have choose the letter {user_var}. The cpu will play with {cpu_var}')\n", + " break\n", + "\n", + " else: # Si el usuario no escoge ni X o O se mostrara el siguiente mensaje de ERROR\n", + " print('\\nERROR --> You did not enter either \"X\" or \"O\". Please enter any of these options\\n')\n", + " \n", + " return user_var, cpu_var" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "9e84966b", + "metadata": {}, + "outputs": [], + "source": [ + "def user_imput(game_table, user_var):\n", + "\n", + " \"\"\"\n", + " Receive the position where the user wants to play his token. If the user enters incorrect values, \n", + " the corresponding messages are displayed on the screen.\n", + " \"\"\"\n", + " \n", + " while True:\n", + " try:\n", + " x = input('\\nChoose the position where you wanna play (from 1 to 9):\\n') # Le preguntamos donde desea jugar\n", + " if x == 'help': # Si escribe la palabta help se ejecuta la funcion instrucctions() que muestra las instrucciones\n", + " instrucctions()\n", + " else:\n", + " x = int(x)\n", + " if 1 <= x <= 9:\n", + " if game_table[x-1] == '-':\n", + " game_table[x-1] = user_var\n", + " break\n", + " else :\n", + " print('You choose a position where you cant play. Choose again.\\n')\n", + " else:\n", + " print('The given coordinates are wrong. Please introduce a new ones.\\n')\n", + " \n", + " except ValueError: # En caso de que usuario introduzca un palabra, evitamos el error con el except y el codigo sigue corriendo\n", + " print('You have introduced a word not a number')" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "358fc098", + "metadata": {}, + "outputs": [], + "source": [ + "def check_block_win(game_table, comb, letter, cpu_var, move):\n", + " \n", + " # Esta funcion nos ayuda a que el codigo sea mas limpio, ya que no repetimos lo mismo muchas veces\n", + " \n", + " for i, j, k in comb:\n", + " # Preguntamos si la letra (X o O) se encuentra en dos posiciones adyacentes y la tercera casilla esta vacia\n", + " # Si ese es el caso, entonces tenemos que ganar o bloquear, depende de lo que queramos\n", + " \n", + " if game_table[i] == letter and game_table[j] == letter and game_table[k] == '-' and move ==0:\n", + " game_table[k] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " return move\n", + "\n", + "def cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, letter, cpu_var):\n", + " \n", + " \"\"\"\n", + " This function analyzes the game board. Look for possible plays in which the computer can win. \n", + " The function also allows the computer to study the user, preventing the user from winning.\n", + " \"\"\"\n", + " \n", + " move = 0 # move sera igual a 1 si realizamos un moviemiento, nos ayuda a evitar que la computadora realice mas de 1 jugada\n", + " # Estudiamos las columnas\n", + " move = check_block_win(game_table, comb1, letter, cpu_var, move) \n", + " move = check_block_win(game_table, comb2, letter, cpu_var, move)\n", + " move = check_block_win(game_table, comb3, letter, cpu_var, move)\n", + " \n", + " # Estudiamos las filas\n", + " move = check_block_win(game_table, comb4, letter, cpu_var, move)\n", + " move = check_block_win(game_table, comb5, letter, cpu_var, move)\n", + " move = check_block_win(game_table, comb6, letter, cpu_var, move)\n", + " \n", + " # Estudiamos las diagonales\n", + " move = check_block_win(game_table, comb7, letter, cpu_var, move)\n", + " move = check_block_win(game_table, comb8, letter, cpu_var, move)\n", + " \n", + " return move" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "9972b428", + "metadata": {}, + "outputs": [], + "source": [ + "def check_inteligent_move(game_table, comb, cpu_var, move):\n", + " \n", + " # Buscamos una ficha jugada por la computadora que este acompaƱada por dos casillas vacias donde ella pueda jugar\n", + " \n", + " for i, j, k in comb:\n", + " if game_table[i] == cpu_var and game_table[j] == '-' and game_table[k] == '-' and move == 0:\n", + " x = random.choice([j, k])\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " break\n", + " \n", + " return move\n", + "\n", + "def computer_move(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu_var):\n", + " \n", + " \"\"\"\n", + " Study the game board. Look for a token played by the computer that is accompanied by two \n", + " empty squares where she can play.\n", + " \"\"\"\n", + " \n", + " # Para evitar movimientos repetidos, creamos una lista donde las distintas combinaciones para ganar se revuelven\n", + " # aleatoriamente. Podria realizar un movmiento diagonal y en otra partida optar por uno vertical\n", + " move = 0\n", + " combinations = random.sample([comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8], k=8)\n", + " \n", + " while move == 0:\n", + " # Llamamos a la funcion definida previamente\n", + " move = check_inteligent_move(game_table, combinations[0], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[1], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[2], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[3], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[4], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[5], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[6], cpu_var, move)\n", + " move = check_inteligent_move(game_table, combinations[7], cpu_var, move)\n", + " \n", + " # Si ninguna de las jugadas anteriores son posibles, entonces la computadora jugara en un posicion aleatoria\n", + " if move == 0 and check_board_full(game_table) == 0: # Si no hemos jugado y el tablero no esta lleno, jugamos\n", + " \n", + " x = random.randint(0, 8) # Buscamos un numero aleatorio entre 0 y 8\n", + " if game_table[x] == '-':\n", + " game_table[x] = cpu_var\n", + " move = 1\n", + " \n", + " elif check_board_full(game_table) == 1: \n", + " # Puede darse el caso que el tablero este lleno y sea el turno de la computadora. Ella tiene que entender\n", + " # que no puede jugar ya que el tablero esta full. Por ende, hacemos que move sea igual a 1 para hacerle entender\n", + " # que ha jugado\n", + " move = 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "d90063c9", + "metadata": {}, + "outputs": [], + "source": [ + "def check_win(board, letter):\n", + " \n", + " \"\"\"\n", + " Check the game board and see if any of the players have won.\n", + " \"\"\"\n", + " \n", + " win = 0 # Win sera igual a 1 si una de las condiciones es verdadero, y significa que alguien ha ganado\n", + " if board[0] == letter and board[1] == letter and board[2] == letter:\n", + " win = 1\n", + " elif board[3] == letter and board[4] == letter and board[5] == letter:\n", + " win = 1\n", + " elif board[6] == letter and board[7] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[0] == letter and board[3] == letter and board[6] == letter:\n", + " win = 1\n", + " elif board[1] == letter and board[4] == letter and board[7] == letter:\n", + " win = 1\n", + " elif board[2] == letter and board[5] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[0] == letter and board[4] == letter and board[8] == letter:\n", + " win = 1\n", + " elif board[2] == letter and board[4] == letter and board[6] == letter:\n", + " win = 1\n", + " \n", + " return win" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "a67593f3", + "metadata": {}, + "outputs": [], + "source": [ + "def check_board_full(game_board):\n", + " \n", + " \"\"\"\n", + " Study the game board. If all the boxes are occupied and there is no winner, it is because there is a \n", + " tie between the opponents\n", + " \"\"\"\n", + " \n", + " count = 0 # Nos ayuda a contar el numero de casillas ocupadas en el tablero de juego\n", + " full = 0 # Sera igual 1 Si y solo si todas las casillas del tablero estan ocupadas\n", + " for i in game_board:\n", + " if i != '-': # Contamos el numero de casillas del tablero que son distintas a '-', es decir, distintas a vacio\n", + " count += 1\n", + " \n", + " if count == 9: # Si el numero de casillas contadas que son distintas a vacio es igual a 9 es porque existe un empate\n", + " full = 1\n", + " \n", + " return full" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "17d00d00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m -----WELCOME TO SUPER TIC-TAC-TOE!!!-----\n", + "\n", + "\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9+Zclx3XnCX6uLe7+1lgyckUmElsCIAgC3CmCFMkWq1vVKrWq+4fpOX1mfpq/bqZOzzk93Zrp6qpSSZTEnQKIlQCIJYHcM2OPt7m7md35wdwjAiAWijpzpn6g4zzEy3gv3M3N7Wt3+957RVX54/HH44/Hf3mH+f/3AP54/PH44/HJxx/B+cfjj8d/occfwfnH44/Hf6HHH8H5x+OPx3+hxx/B+cfjj8d/oYf7rA/n87kOh0NEhKaOqIK1BmMETaAK7jPPAK3UJAmAIoAl7wjyid82KIaEkLqfvS+5Ov6OAunUi+PvKKAYwJ262smVbOreyMd+oigJJXHym9NH/0UDqjgNqJQsBWb9uYmUaU4lLU4UcCQqWqo8TwouABFIAR1YMAL6aXNxcqjkO+3HdPo2/Of87e91xO5kAvFj1zKAVZCPOfWjQCvQ35JLNS7VKA5ciaphHhTvBCeCAzwJISJ6cgcqBsXRkp9Cf+QnJ/mn9gPS7moRJKDSoLQoLZEWzZOLq89j4zTfkwE1oDbPYy+NpL9JbUFroAYTUJu6Dw3oeSQqpJRfJoBT5iayIBEAizDEMFYDjYHo8kRaIVjDYRDECN6BM0BSYpswKVBVhrZdUhTTT1wCnwmtoqho24gmwXuDnDqF5HVK237WGSBYSzSCKBgSSfMEGU2YjzxwQwRUDEnk+EUHUBuE4yUjhn4JKf3KERDTgdLkJ9Et++NFHU+AoJD/Tjqwdz+TnAA0X7s/jwARUcEhefV0E6jdd2NSVDqoayKgedEpRAUTQSJIjLTB5FN+DJwff0p5nOl4S0L6351etJ99iHw2/G2bH0rswBn76VMwmp9LIXIMUAWS5EXfD1hVIBkwptsgoXJCv2gUCDHhUt5Upft/EiGRr6sCqi10G7NRISXBIJj+UaklYfKzNp5kW9REIgmVDE4rRZ4nk4cUbR5vP78COOkfvyNvpKO83XdLKSnMFUoVhtEgEVQKVsDcKUujJIQCoQFqoNSTZ7MQaASkACvHjzqvTslrpW0j1nz69iqfFedUVU0RTLfd7O8fcfPmbe7evcd8PifFboc5OdvvnCOII2HyMu8WotXUgbVb1t0Dygu7B2a3sYlBBcrWnrrGR2VlP+0na1A+Mq7jfTpFTuRCD8qEHm+j/a7Z/405dZ48ICPC2Ao1BWm4hp+s08aG1eEDZLXLQFqMJkISAgMaMyJSYJOljIFBXFGkmqPSdJsPHwFo3mc+6ZmkDJhTd97f6WcdnwdMgKIRVCCYDMwopxazClahdA7bTZt2n4fub5IBCQEfI8YVRPHYomI0XWe1apjN9nGaMKHGpoBo7BarEMWRcARj80YoC0wy3fqwiFpEDUYNppOn/ZJNGNRCkkQ89chLVawIUQzROJJ1RPEoDsFhkqWQEomCqmYtUCBZQa2As6gRDktDlZRhmyhivvnGJZY+sXRKtPmMVYBBo5S1giorgYVTagvDpqEUGA0rtjamXDy3xua6xwmQFGsCYop/vuRETxb822+/y89//nN+8Ytf8s4773J4eEiMkZTSp/1xN4ETlOp4ARpAjsHZQUBMBuMxIE/tpHmJ4GI/1I/ex+/Kx36l90rxiZKmGlHt/i3p5LNT4NSPgKAbxClF3ACVFZbqKDcvMD13idVqwcH9G+h8uwNnJCShkYrGDAlUiBqK1DKIS7zWLL1BRfJZtdcP9Pjf+eqn5/Z3xaSKfASwf+hRtT4rjCaDLZjT4MxysDT2WL3t1ewgEI2SBExMuCRYX9GKwxVDLl65wt7eAQ8e3MGniE0NVgNGY3dHQhJLEksrFsViZQFq8qZwDE6LUZelnDogS0/Fo1iSyRudYhAxOBMRgSSWaBzROoJ4oAApMMnhpcTErOsqghqDOgPegrPgDLMznjImRgGqqHnTdVB7pXFKlITRhA+Jqk24NhI1sTSRuU3URjlfHzIyMB0PeOThi3zlS0/z9a88zROPbiFGCAF88cnP5TPB2e9Qe3uH/N3f/Yi//uu/5rXXXmN3d5c2tKjqR9eL/C5QVdeBUf64/5rmhXdsyYk5Pk0P0v5MefEJJvV3cFpllY+AU+hVpmyXCCHrkR0Ik3Zq8PEr0tubvVqrmroTdmc+da3+t1aEFsvw/JyzBy2HswMObr1HWu5QaoMhElRopSKZISoVqGC0xcQ5nobWntzzRwAqeko5OJmjkw1IT1RzkSwx/oVHFatOiilBepW12+RUEVWsglU9HofSSdj+cSTBqse4iiAWXw5Z1Mqdu3fZu3MTSS2GkMF5bJIICXsMUDCINMfzbrCYDpyCR/CgLtu1FCgFCQfiSfhjP4OVTlUVg4pFjUONh+67pAJjimyIIiAdIL1FvQPvoDDEPYOJig1CkQSrSnIQnBKsojZ7SHyM+BCQ0NBqSyOBYALJJu7t3MaFmsLBm2+9w+3bdwlty9mtH7A+EexnOG0+E5y91NzZ2eVXv/oVL7/8Mnfu3kaT4pxDSbRtNuXpHtrvHHqyLcgpQHHqncGinX15ot5+xGyEZE+uofaUKngC0LwHdqCkRaRFaI8BGpM9NcKPgbOToNrt6iCf8Dr5S8Xj2kiIUC9b6kVDqltUGyyRiKHFoMZlxw8C2kCqaahJwZ5MsJ6ATyRveKJZ0stHRpM+MjJFiPaz0fn70DMlFdnuQwminS15PAjQBDFh0c4U6cCJnjwjdVkzMkK0nqgNISjLRU27rEFbhIgl9N6FDpyGJB6VbEJIt8GL9qZQt+lqOrX5KopFid3PTvp17kZLgeC7c9vuGXiQ7JYieXBlJ4UN2O73xoMrEByoQdtETEKbhFYNtnsaUSF18yJEora02iDUtLoiaL/BROroCSFSNw11vUuKb7G5vs43vv4VRoMNSv/pz++zwQmEALu7+1y//gG7e7vEELHOIqZ7cB/x7X3SSerue/1TPOW06SZWpAON9JPcX/3UcbzAezvQoGpOQT11BvcJ6E6kaJagenxtODHPP8l+/biqfHKc/paxFjEmO4JSXlB85Px09957MwKYQEqR3vPLR7998jvpcNFfiwzGj539c8H3+4AzdbIscVqzOH0RQz+/p87Mx+cMFZJqZ+dmey6EwMls9v+dSM58hnjqHNlwPD2XvZNFe4BKvq9ej+hHIZ23P0M0kQSiGEK/0Ui37oxBjM9qsnjUFeBLpCiRokJKD94SfIQkdC4pxBrUCsYpYhWVgKYWTTUp1JjWoqlTPUSAiNox4BFtacKc+zsz3nn/Fg92DnnowgYGKD7FJ/Q5gRBomsRsNmM2OyKlhLUWSIQQkG7CPvOQFUiDkG2CvCgt2UOW1Q8j2tkQp77zMWl18rv+87zrnX4w/bv+P6XfPLLk1G5BfHRh9d9JoPH4G6du4NTPU+9FsTafK4NNMSKdB7oPCnQbg9p8HW2z9CRi9MRh9Tvbg/RjP1n4H5fn/V98HvZ+H3AGej3iRJJ/BKAKFoslYk+PrFeBRfNaTEoiYk32VaQUiLHNnu0kkFIn7U4kp3LaNFJQg8iJ00fl9HMiq/29L+IYoHoybAQjESdKNKYLpQjJ2OzN7XY864RjNdeVUAygGCDVACkL8A7jAohgxWCMQZwBJ6hTxKU8c6lBkoVgoVFcSEhQVE1+3nZISBZnAwLUccHBvGbVpiyBI58aD/tcmzOlRGgDKSnWWJIzx04ga81nhFJMN1EJMeFEEqgFPEYcSR2aHGo9qq77rH9ld/nJ6TqXmppsI3wkYiqdOtqDW1BitlEEcoilj0qdlpaJDGZDH46Jejq6enKctm4Rk8djFDEd+I1iLJiYbcasdMXuut01pcUQ827ZTbAqqEi23YCoeuyM+bjyAP0yPfnAfI7NmRe6fuTfv3PO1IeMOm1CsvSTY8VTKbp7skgOW6AEk9XgdPz9vFkbkzAmS0gRPRVLSNkZeGpjFAEVe6xGS8x3qb2mJAbBojhUs2pq8KgUQEk2mwrQCjE+P2NTIsZlX4axmE6tTab7LgUiFWoqsCX4CsoBDIbIYAhlAc5SuhqMkJwBZ4iFIRWSL2kVsTFvttFB49AGXCP4xkJTQ7LEodCuVkCNiGCSYPwA4yuqYQ7pfNrxuZKzKBxtG4kxEmPoJGYipUTbBj76rE0nwciTBGACxuV9P0UhRQVjccUIzIC2dVgzgmiJXcxJJL+OF6EKKqsMTpFsf0oHUrEYBDSgscYYBRpCEkQd3gHSEkND743NIZNevnKs8ojmXVJ6hsVHQHpKQ1ADrmK+OGBdLxBCg2ogxgbR2PkQwUo8JmAAiAQGBiqFoVjaEIiqiDGoNbSaWLaRlkQyAsZ2ADUn9im9k4psC+oplfATjs+SnD1Q42m5LIIRwRlD50LBpYTX2DlmstxriWiCZHp1N6ISIEG7nCHOklKDL4S6XdHTFbQDtnSXO4kzZ59C0oZj8ohk6aZ0nlZKSAUJD2aKmCHaWqBA3JTCDzDGYdIWUUdd3FaIxoK1iPOIcyCOdtGAq5CyQn0BVYUdD2E8JBWeJEqpNnuvPcRKYGBhaPPPAqxLiLakxpOWBlkkqMEvDJIybt1ggJolxAUqObbv/JD5os7hK/10EH4uOD/hcZ96nXrQx+pmtiWl86qmlLJgMZ0KgYHoqZfuWL1t8Hni3RDrhxhTZFJGGyFm+0ymG2hSRC3WekSF0LRom0jdDo8bdhKzxZkh1kTEJTQ2mf2hu93DV9CIELs136lWmr2jKmBEOzWXTwg7ZiXQ9B5eE8BE1CQ0aSePOZY82qmJA1rGCgNg3DbHHCcFgiqrlG2qBkjG0KSU5Ww/RnpPWW8v//OO01LzoxI0IRgMghWhEENBDrCXKpQKThJoSyKSsCxpQVu0i4MnqySJp/xnmXEh5rRfonfdfNTal1PeerG2C6z3HtkBUIEOQIagQ7BjnF1DZEgQj7YOwwAjQ0pfsVg+TBPWcljEOigdUtospjo2g58asIJaQyosqfLEUUkalZhBmfeK+S7qlDQUGAmMLAwl09U8RInZXd0mGCg6MNSLCswSqyWwBI3E0K0lU2BpCcah4j4BRR89/gBw/u4hp0CZvXa9ymkgdbEoOte15p0OHQFDoAS/1tE4CmIoiKYDsRFs6RkOKoKJtG1LSgmRbJdYn7LJYAwpBerVEhXFSMr/blbQNAgTyrLoFPxZt7izyqnadjOU1V7TaWA9G0c0ZZuKk5n8uDWcel+VfJRaZ9HOJjdUwFSFNVGGwPAU9TClQJsMS00UwILMUJmllClyoseS5fj4fFPyo8/oU4GZZZKgeFEKDJUaBhiGGEYYSlEkBuKxe83gsWQrNXXbodCQ1dus4EhWafMFT82aOZb22dHSmTPiQSzW+U6FdShDSAPQMTABxmCmIGuEugQZYvyEYjzCUACGEC26dg7xG1nBcIA3qDdIYRBvMM50m7AgpccNS7QqSN4SHUQn4Aytj7SVoBMLU4GxZHAWCWwEDRALCCXUA1jVMIu0bknUGbDCpENiCJ39WZC0QY0hmpN182nH7wfO4/jlJ2H9FDA7BmXvrAGDYYjqAI3ZxoQCTAV2CCbviuVojaYVVA3eF1jrUFVSStnJ4kqGA3cMSiWhsYtJpkSKAdVIORzSNA2pDRhVogyhaVGUVShA1ruxhTyxBKDpxtyTsBRou1dPEzzh8fZ33AfKRbqFRVaXEi3p2K0llFg8lhHKJpYNDUwEtjjZBKIaVmKYG8NME0fAvPusVqVRQ9trs9qN4Bhgn63W/j5HQcAilGoZRBiJMMUwFcsUxxDD0HnqsKAm0AD7NJ0lCK3CgjxG6Wz8DE6bN2rJwf68FjOg8+gt0rF2FA9qUQrAo1qhaUAG5Vr3mmaghiEwgGJKOZxQuSEA3nvKsuRwus2quoNYk2OWziHegxQkLKjHuyFJPerBDQfIoKApDCl/DB5W7QgGAusWNiQDtFJwESMRQyAlRwoFNCWsAhSBpANS4yEt8U0DYZXvL+WNSI39qD/lU45/seQ8lpqagSkU3Wld5zFdQ3WcuZf4DEhXgSnzv7GYYoSYgKYEHqpRwXQyZDwesTaZMBoP2di8wNrahMGgJKZADDVtu2I2O2J/f4/DwyNmR3N2dvc52DsgBhjIiNAqoVU0KhLWQYvspNEWUguajXVYkZknsVswNqukErNKcmyDZnsSdRh13YKyYBwYl+mGmjo+qMPhGeBZU2HTGM6zYpwCT+A754qhtpaltcytcIiyE1p2YiIRWGBYYalVqNWc8qh22+7nPOOPS8lPkqCDDhIFiTHCmiY2ETbVsoFnTQrODtdo6hGztubABB7oChOhpGGpiaTK/JjjfHot+G61k+dVQ6faZq99nuf+O44Up2gyoGXWrmQNzHp+2SnICHEjXDGgqoZ4L6jWeJfY2qo4d36ddGUHNvcZjieM1tapRusYN6CNlsVMqZeG2Aw5msNslVjGJSuUpRRY66GyuKFy0NoOnN1rkn1HQ28YCBRiUHUsmobZSqgLB7GFpcJgAA3ookDbbvPuSL7JcuwA/P+RWtt7LuV4knupKaekp1Jl9QSLSIF1A9QWxN6p4QwtNaP1EZtn1jh/YYsrVy5w9colLl85z/nz64zHglfDeGIoS2hjHwSGVZOYL5TdvQX37+3w4MEuNz64y/X3b/PhB/fY2T5ERTDiMKsNiANU2/ySGk0r0OXJdknOdMjqd09oOGEZ9aFuTQWSPEKJUubFRAm09HFcg8PjGVAwwbCRLJtimNJyhUiJIxrHEuEoKfsx4jQRU+ryLAwZ3haX+TI0ZJl+wh36ZzyxDowfB+y4A2eFsgZsYjiL5RyOLUrWtGSyhJQKjhK4pJkPywArlhmBReeZFelAiAfNlitaZmmqoZOcef0IFlF//F0waNzqCCclMAEzAbeO+DWMH2NshTiD84liUnP+3IRLD21w+coZLl8+w5mzUyaPXKI801BUFcVggCsL6KhyTQ2hgdmhsJjD3gx2joR7R4G7RyvuHx2wv2pYteAuXCaUwDjBNFGNYaOCMwWsW8PACEnhoIb7c2WbwGIZMwO+AmoLRfbkopkSSOiSA05RJD/t+GeA8zTOT8z5j9ibCNJJzbxzGug8bSIe6yqML4mSA7qjyZjJ5pTR2pjHr13li196kseeuMCF80OmU09RekiGumloDjw7h4GYliQajIGiNBRlwXSrZPPCGk9/aUzbXGZ75wv89s0dfv3SW7zx+rvcubPLfL5C0xjaCtWApoYky5zZkFy3W3e2svZkhfZ4EZ1Wbx2QUicZtMjK3bGb3tMHAQ0eT0FByaCz36YKawgXaJn6IVINmAPbbY1pVsSUOg6NpSUcz6P2GTeaR3Sa2/R5x6fZm/37qfMUSRgmYR3PGQrOUXLRDDhnBqxJxXoxQIxhP66QpRBUCb5z/sUVBaFTWyVrUZpZOtJ7WYGezJCv2jsO+3n03Ro6262fEswI3ARXruGrKb4a4UpPNbZM1wsuX13nqS9c4Jlnz3PlqmMycYgxNPUZ6kZplsLqgdAkRSUiXvDOUjphYyrYM3moiwTbS8+tfeXD7RU3tg+5P1tya+sKrVfagcGNAmujxMWh4UJpOeuFscne1vtzi1GlWUVq3xKLkNXf1iDeIs6g0YDtsGL67YnPfH7/csnZLcSPemvNx/7tsKbA+QKsy1kmo4qLVy7w0COX+fLXnuXa0+d55NEpg2HBYrnk7vZtdnbusr19n929PY7uew6PDlk1RziXcB58IQzHFdO1CWe2trh48SJnNs6xceYy3/puxeNPrvH061/gFz9/mTd/8w57y33amKVm5nIKMZEdFyYHqDW25HzBnAx2QiaQU/cJgu3U2lOglj42m5kq0oXuHTY7WsjSaQCct55z0w2KtSmHmijmM+LcEkODWIvznsODXRosrTG0CAGTU5oyBAj/THvz00A69I4ywigaxskzxbNmCtZNyYat2PIjHnvoKhjDXj0j7d6jXlkaU7OMMIt159HOGxtiO2eP7VKy+o07Gzr5Dkyng3Rxxy4AZVkjiUOlQOwQ69coiinFYEIxqJhsjLj29GUee/IMX/yy58ojFcNRwaq5z83tm+wfPmD/naeZP9hiXi+ZrWYswxxMTTlIjKaWQZW48vAGG2dHrJ8fM1wf8NCmZW3Tce7SgMsHI24fKEdLaKzQeHBDWB/C1shwqRIuOGFioImKxTBbwY6PHLjI0qbjyE/2MHaANNKxhzh2vH/W8dnglBqMRdVBHKNpHdISMS3G1IhpcT7QrBJIgXUTUjsiy/S8WyZbgXMkM6C1E8QNKAaec1fW+Pp3n+FPvvcFHnviAkXhWBwteO+Ve7z39gM+fO8e9+9ss7e3x/zokLZdUtcNISSMdRhxiLF4X1NUK0aTJVtnF1y5suTaFyyPPHqGc+c3+O6frnP+UsFDVwt+8/LP+fC3h+zfH5AW66gGUnMbTMSXFc2iBS4iHIHukd0yOT4qEhDTgARWWqG2wpKlro+eOnhMtEgyx0swZ41kp4dVQ6WWKYZNKTBrhvL5awyefBgNgTPv3kJ+e5vNnRkPYuRDURoZE7RgV1tuotwdlNRWcKvApI0IJduU+JQ9w4nEUhLBdiGNpPiUKFVwHQOrESEYg8UyFMdAPOfcfSqBDYSLmriUhHPJs+5gsD5GHrlE+V+9QIiCf/0mZ35mkTDFk9hNK/aZs9Q5ZTsHXSEmYtWQgiGlYbYXJRDjApUmh1gEEI8yQNMGmi4AG2CfQPUBVC2D0QbOXMHaM0xHBReuNjz+xZZvvLDikSdgY22NvV14+S347fUhH9w+x97hkOV+oF08oG0TbYDIEMp17Fixm2DGylSGDOYFawvP2S3h/Bnl3MQwHQ14YnSWxzfW+PJN5bWi5p/GNbMhPOw933KO5wxsGtg1La9IzYcD5fpUODgc48KQQVCWEsCuMHIbSYqGIdokXDS4OMSqdg61mtOlBH5/cJoAJrNuNJU5xqQCrDDS5rCFjdlpIgbsqAPnOMekIPMYiwHix6gMcNWYh5+4wre//wx/+meXuPaFS+zvP+Cddx/wm5dv8puX73LjnUMOHrTU80SzCoQGkpt3alHeklR7dojLNqVtqYY7XD/XcP3dGQ9dXeeJpzd47svneOLx82xtPcflR5a8+PMbvPlS5N4HjuVBg9opIqlTGRPSyTegU21XZBK9yTEyA61W2S2OQ5PFRockh02OHC/MRyLTxpLajgeseIRKlFB59OIW8vyTVOMhZy9eZMjr7C6vY/ePOgkcCZSMcLRGWTlPK4kgiQGKwVNq2TGUIyqdA0vCcXDfaL5m2WkzXnMisxPP2JeMbMlYbjCMysUkPKEVl7CMnMOvDyi/cInqW19Cvv8l5MY+6d1DRnEDlzY4xGKoWcqCqHsU6QGRA9AaoyWaCmCY15HUqGRLuo81itHO37sG6SHgEmrO4R3IqMZWU5wbMZ2s8fi1DZ7/hvDs15Y8cs2Babn5wT4v/lPNq7+xvH/Lc2//HHV4iGRvoRzm7BMGiJsgTImVEEMnsSLIAgbbic265qGjhkfWI49tGC6vFZwbTfjuGqwNhNkoctdFrghcMwVPpCx6DlNkN664oXBLPDUFrgXbAiFCm7Aps+s0eLQdITFiQoHtUvEs7R8IzmPBq58Qj+myJVMW28b4bLd1IRVxBYhBpcDaMcVgRDkccO7CJn/6g2f5y//+a2xdgNs37/Pjn/yKt964ztuv3eDOh4esjgSbKqx6NILGhqiH3bkL0Aal6Zww2fGUAsyTIaQZB7N7vPtu4o3fjPnwgyf5k28/yxPXtvjmV7/H5vgBa9VNXjK3uPHeNpgpKVpiM8PYGrSGJJ0TqyPQS+g4nhZROSZP5Lhtd89i0WOqWY5JquS8w5yhkuOAvV942SSO7h1QbC+pzl+mem6dIjrmq5byrRtcboRmtWLPGGa2ZE3gbB2RqByqpbU5v6OIQiuwsoZghKggKpgYOxUzxyUdhoEKYwSfJDuZnMXarIqOG8MFLbjImDU/JW2uo89cZvi9L3DhW8/jLMT37xLeuYs0QusmLExBm2pcHOAQattk+p2swIwQM0RM7J4Z3SLU7EAURSiBISpDkCrb77KkGl/AVpZkA6MzDU9+KfKNb415/itnOHsW9rYj7757wK9f+pDX3tznzoOCw3qdJp1F7bRzKPn8LKSz7GwgWc8pLTsv6UZZHCy5NT9gcbBif2G5nyZcPjPh6rhkMix41sKFtOIswkBhX2CeIu82iXuNZdEo6SiRljVNbHNpkxVwtETbiCbNgWtNJ/nE2vOBP125/T1szk8wWbXjsKoQowEpUMlxHDrniHU+Z5u4dVwxYTIZ8NiTF/nmC8/wvR8+y0MPtbz+mz3+03/8R37641+xfWefo90lcQUGBxoIbSS0AVFF7QH0rFTteZV9OMZ1G4GjWRqaOrC/3/Jg+wHb97bZuX/EN7/5Vb76zYd49pkzTIZnGZQDfiqBW+8bmsWQRi3i92ibBQSDxGkHstipYh2JWHunT37KSmZ79MxT7WJ32k1v6pKkGhWWKHOEeYI7i5rlGx8QzYDzWlJ96RrlN5/jfOGRomD52g2uzkdYC3MHk6ahjYESS1kU3CoSi5gYL4VohKaQjMUglI3ikyORSMYQbY4s+iisJ5gCBQaSJRjDpB5z1Qx4LA45yxA7XSM8fRn/vWcY/OlTyMUNDv6Pl9n/x1c4fOMOTbvJ3argth1zJBMkRax41ESSFqhdoVKhTFDN5PC8kSUQh2jTUWkrRNZQMyW5MaQhmBXWbuD9hGpjwRe+bvjuv1rni8+VjAeBG9fhp3+XePONmnev73FQ77FSQ4uSZJC5dmpAyuwVdQZsJPkGLS0Ukld9VzoooTTJEKOhtjBbRu4vGm4Oljxpatb8Ol+lIBmPJ2GxbGvi3brljZlyc1EyWybSoiUuajQe5ZyypYGDGm0CKcSu9FGCpDmj5vcgkfyeDqHTZ+pZHl2uXLKgJRq6JFgzQGxBn541HEwZrZ/hytV1vveD5/nLf/s8G2cDP/nJTf6f/+7/w69+/ha7DxZoY7oaGS0pLkihgRgRY3HO0+pBfsB9RnsfuuhDIMlBsiQtEGco3ACHYfvWkp8t3uDB7SV7O/8VL3z/PE89vcl48gUQ+Mf2fe7fWGGtIYQlMc1R9WiqOgC25G0wZPJDF89FC6QLFeSMfAfqUYr8PSDhiXgacrhkTuKoC76oL1jtLHA/+y3lTDibHPa7zzL9V9+mrCruhh+Tfv0+oQ0EwKRIQWCAIVrPtgvMUmQgliRCI0qrgkueQVJcjuZm8oLpaHmqDFKuTTFGsEnQCNe4zBODKedWBu+F4pHLjL77ZYrvPEPY8Nx941Wu/6e/pfz1fWg9M85zUz13zISVX8OLw+qQVhPBjIiyImKJaYMQ2gzO5Ls4Z4VQdxrIEGQLzCbWThHG2NITkmdUDrn27Brf/4sRX/32iCQtv/71gp/9B88bvyh5cG9A4BzFmicwo2kTxBmsms7LO8y+uo73IlWDGRhS5dDSZjJLjDQpgvXIZJ2wNuFoXVmUykGE99M9nguea27CWjLURrgJ/JbIb1vl3YXn3qFncaTE5QJdzfIYQsIuLekooU1LCiHzXUKuxKEpc7dzzOMPlJx66p1K6k4knSrnjgPHaCYkQ4EtBqgUJJXsoHLChUtn+eaffJEXvvMMaxuBl168xb/7v/87fvyjNwiLETov8m4TVxD3Ic0RSVjXsUfaFfgFJ9koRZZk2mSwqs87pRTQRnSl1HXATDdARyz2DLfePeQ/HL3G0Tzw5//dBR57YoP/5t98mXox5B8X77BzryZoAW6IqCfFMgeNO8JCzqWsszoUK9Rkya2Umf1BiUovyfsMGU+Lo8GyBA4x7HV+3Fk5ZIKjmAv1q3c5MC8z9EL5wpOU33yShwrL4WzG2vUd7CqxUZTcaGqua81+G1jvbU7j8SqMV2T2ScqbZ0BpJctu04XdCpMwJmJSYICwkWBUG543l6miUk88o2sXOPvDrzD+02dYrlm2X3qV3/z7H9O+dpP15QDDBndtwQfJ8EBGLOwZalPSqhAl0qYjIkuMQtANYlpAqoGEZdIBszMdZAR6FiNnwW+ATJiOzhJIXHrc8qd//jBfeaEkDh7w4j/d5G//w5w3fn6OsPckdVshvmG+WrGsF5mPWwHDAKEAMwSfSIMWM1bMOOEmNWYYaQcOOymprSV5ZTVwNOOCcs0wXDe4qVCUgaT3gZZhC2utcuAjtWs5CJHdWLDXeA7mwvKITCdsEjQraAPl0mPnQqsRbUNX06VL5o+Z1vkv8tbmP/5oHZveCwk2O2XEg3ZOFKkQO0DxGGcYTUace2jC1//kCf78L77E5auBn/z4A/7nf/c/89N/fJ3ljqNwI1gcgktY1yI+INpmZTAFQm1oO4sNzfG+rGI2GYxagJSISRhjiIEM9HbFcneG+CHqHAchsD9/wKI9pElX+ct/+xRPPDHlh//6C+zt1Pzk73cIizGI5Fy92PGA01q2D6JB7T6YpnN2DMjcmp584FEtermYS4h0sc8VjjmJAzwjcl5H3KuZ4jkbHcXRkqNfv0Nq5gzrA859/zmm/+23eDi03Ptff0r9i3fZio7CTSCWhFTjo7LnHQfeMWiEUbIYDCscBxjmRggGRCNFUkqTKG3EuxarjnGbeDg6LjSOi3gOxw7/pYc5+6+/wejr11Bpaf7hZfb/5h+Iv3qLuAfbpmC7SLzXzPkwrnMUPIduwJ4ZMDeQrAVdgC5JNqAyBlnSUwyz5ZvLUKoaSGOwZxG7hbgpUgzxZp1Lj6z4wb/e4nv/2sNY+bt/2Ob/+Ov7vPnrMfXBOqlJIC2xqUlLAzqF8YjCVWCUYEuSGcAwwsSg6y3mTKSaJoppIg4Sq4Fm9s/EwzBr1GkEpYNzBi442HIFhVqO2kRKylGoOZKWpomkhUGXnriCdiV5HI3AUYPMGqql4leWQwloiEgw2UlErioh6ST1/A8C50dh2mcWZGDSUddEimzQ6xBkBJQkVSbjMZcffohvf/95fvjnD/PQFeG9dw743/+3v+XFn79LfVQhsaJdtqAR0RmSDkB3CeGQNrUIBY4JFRV1muXrd9kkubJBB1Jt0HZJTEfAEGTajQUkChjLat5iXMudmwv+4W8XIPAXf/llHnuq5M/+4ivs7B7y619CvZqAHqFu0VUZG50KkEfQA9ABooPM/9QBSfPGpGZJSgXS5cmolkQpadSyRDlC2Sfb62dbyw7K28CCgo2FUPx2m9a9TukKJj+sWP/zb9FawzIJ8dV7nF9aCikYUbFF4IbC+xamxrGeDB7HggKHwYslAqVmz25FwptAaVvWteYhhUejcBWHGxZc/to1zvybr1N++VHSasbez17k3n/8GenV9zizStzAcLMU3qXmNi0LY1kBBwKLcUX0Q4hTYAlphS1XSFki/rBbQx19k54uaUAnKFtgzmD8BFNYNtcM3/neJb7zZxsYB7/82R1+9O9r3vzlRWa7ZzFmQoi7+DJgQshz7yaQoDlK2S3RBQwYm8yL3UzIRsoScSSkgXDga3S9hDMC45zWObXwiIOnBB5JwjkGwJB3nWG2WJJMgxrL1HsuO89BhN0V7Nf5tlkYOBDkSHHLiKlzLrM0EVoDoavumBJ6XI/p048/kIRgchgBckhdRnlGpOhSnJRqWHH+0lm+/I3HuHjlLL956y7//n/7O/7x715mtldiQkWYL7q7OkTDLjHOqcrAeDSAVBFqRWPCSKAOPV2QzIuRvsJBX2S4ymUkYo24iDORtm5IeJwpCEEJzRFVOWF3G3750w9YXy/4P/1Pz/OtP3W88/Y13n9vxt2b+911choYsXcAtZBmYBsMA6JWkEqSlsTeOaUlOaCuucyGelRKgljm5DzPSlqStTwdNkkEbhWG1ajivCTW5jOGL34Is5rlgwOe/L/+OWd/8A3Ejrilf096+S6bC7B4BlEgRGbOUCZHgcHgKXCs4alirrhTYBgKDAmMNDDFcEaFSxq5hGVTLNvPbfLoD5/DffULsDziwc/f4N7fvsbqzfvElTLD8QDLDbXcVNg30LrEXr3Hrnji2CPD80jYyM6etkH9AikUKTbAJ2g9SkliCay6FO4J6BkMU9QaKBKPPb3ihe9uceGC8MuX3uM//fUOb794jubwPKIlYbmAdpfWkT2gBMQqGIuYNcbjdVYjTzNMMI4wDugk0k6gnoIZQzuEUEn+PAeJGVvhqheeKw1fK+BRZ/BscIDnNYF3mpqRRp4qR5wpPMUa1Ltwp1Z2a2G5FDgsYX+AOQikFSQNSEyYcCItpSfXpc+Wmr8XOENXsU77HELpQidd3R/VElKn2rkBo8k6QWs2z63z1a8/x5NPX6Rpd/n1iy/ys5++yGqmNDOgXpKt5CW5bnqLaKRdRUKda5tmNXqBUUVYz3fVu6KhC2907B2tj0umaDujRcnbp6NtNd9qo6xmDo0T9neEF391i9GG8D/+n5/je//1FX7+0xsc7EXqlVCUnoY5KbZZglKBTju2a2dfmiGrWrFuROrSGbJaGwkomiQXCu/y9xYi7KuyCjWHQKRkDtyODTcJPAJcawrS2/vs7f0T7wbD4/+Xv+DMC1+naCsOpq+weuUW5c6ScWipCJRmQBiXPKgX7NYtpa04Z8dom23NSEulynp0nEuJh9yQCx5GacVkYDl/+Rz6V1/EPHMJuXePe//4Erd/9jrLD3ZI9YB9LB/QcBPLdmuYqXJAy6zZ4dA55tbT1prnxT6KH0wYjBPW10gxQ8oRDCLImLbJVSG8DLCmRPw6bnAWM6zQwYyLVwc8+/X7fPVbwru3Wn76nw/44I115g+2aA6rbGDZrAnRRnCCGSji52CGODPOWSKbZIlYGVh32POewTkHa8pB2dDQwMjBRsF4Imw6uEziaUk8a+GaGM4l+K1xvLxseTF5rssE2b/P/vI+39jc5OpgwPNbcO++8uB+zXInwKKE5RlkqcwXh2hYZCfjKqCLAG3Euppm6bDGdHHOj6UC/nPACZnce7olwHG6rDicGxHaqnOeeNqUKEclVx55iEefOo8xhhsfbPP+e7fY257Rrugob0vgCGMXpDhHOh5pllIBZUXObJyTC9+f4YRV2ldj68YjXT0XMVnCUXOSGWO6b8Xs0W1bWgKz/cC92zXv/3bGzRvC1jnL17/9BHdu7nP/TkRj0XFq9zlOH9MJGgd5I+lsbNVclvE06T8T/xN9Bn/EgxFqlJkkWpRbMTu7GlWIwsoK1hmGKTJawdk7CfM377Mav0z1wheZfPV5khlyEH5O+PWHbO051tWQ6pqjFiiH6EjRVOBXDYUaKhwlFSXKJsoVY7kkhqKeUYtSPHwe+f43OPeDx+D9bXb+/m0Of/YO6YN9FnPlbjR8IJ7b4tkXz1G0BDwNkQU1SzOjFZ/j0O0mSqIwBnGCrQb4kWBHHTjjJOeWaUEyEVyFtetgx6iFcmQ4d3nAs38CdYS3Xmv48K0Njh5sIWmI9UJqA6QEMgETsW6FKVaoT4izucqBEZg0sBZgKNgNg99wpA2h3hTioMhaV2mZDOBhC48iXLOGJz085pQ1GupY83Yo+W0tvBfgTrBIPaZa7LOlh6xtCqOi5Oqw5UOz4miZWB4VsFyDtqFNc6IJ2Jhj05oSErvkgK7cKPREzD8InCf5SCcCuANmTzagwJiKFEuML1GBtc0pX3j2Go88PmU+W/DGK7d45807HO7VhJVijCGxD7KPsS0p1kiX+c5xECABs1ziwayQ0NPiTqsCvf/4VImnvk6ths5x1OYJ0IimEYREomE1d+zeM1x/e8ErL+3w/R9u8q3vbvFPvxpysJdYHZqcj2gXKItOFRlDMih7uZ4NBamP8Z4U9ejuJWGwXf6gIxpDLYoQiOK5Hi0eg0mKDzkEtq0wRhgDgyBMP1gx+19eQeaO8q++y+Trz3EmCI0fM/71Lfy9JV/UigdRKWooS2GOwXvLIBqKqEyNZ6SwrsomgiOSRhWjh88y/f6X4ftfwx3e4cNfv8mDX7xB/GDGcmG4nxzvSOQ9a9lxnmUwOeUKYUVkwYqGIwiKZYVygJoadSOsE8ohDNZKytkEDhTaaZdOU5JsizgPfgyuIsmKybrj0SfXufb8gnt3G159ecm9m+vMDyvUCtYl2pAgGcSPML7GFC2UBVIUUE6RyiBekI0atlqKccVgw2G3DM2mEDc1S1PrMB4upMDTavmSGp40wkMWhiZxlBrutYe82Gzw/sxxbwWzIKTZiOuzPdaXB2xa4ZHRBo9sCPeGid12xZ2Zo10NCE2Vie4aIUQkKBIEjQpGj2uYq34SueefA07tAXn66Cl9pqsiUoKU+KLEl45LVy7w5DNXmGxU/ObX27z56j1uXt+nXcacs+MimH3gAKQrAqWnkm6Bvt9GLgESMKcB+Du6ekepPh6r5t1R+up3XT1U6aSoRlJUlkeG2x+0vPLiHb76zTM88oTn0WtTbrxT0xwVqLEkM0D1CElKX59CmHGcFIzP4JR+s3IYHEIide9jx2IKkqjFEUg8wGDE4AyMMdjWsEyGA5S7HUl+Kwzx1w9Y/egdzLmL+G8/yeZXvkQ0EzS+iK4+4KHDgmGqGcTIWiNsS8JUAwqxyGzJGeOZqqHUiDGB2dAwfPwSmz94Hv/Np9Ch58HfvMK9X7zD3u0DQmM5FMcNa7ktcN8IuyrUmnNP5ygzlBUNKS2wreJDS9QDWjsn+QnGeIpKGEwN1WKA2w+Edto1YilQliTrwA9Q6xG3ZG3L8ci1AeXkDO/+Ys677zcsVhPamKVhktjR/lyX195AYdBiTCoHyGiMTg06atDzNfacUk1huG5hXWjXyKVGBgoWNgg8EoQvBsOzCpfJmV77Sbnetrxd17xcw8FCmO3l1N+4tOweet5fLbg0WHG+ari4VvH4VLguNftLT2hKNNjs/AlNR+PTrNiFCCY7hI6X8R8Ozk/+y5NmQYYUwbpcXtA4RzmsuProZa5cnbJqG66/u8f1dw442s0kshSPUFmAzBGpu8LJhhzk7yvVxeNwxEncsD0B3sdJEXqSDZJfvXTnGKingZ0dNpbYFBzsGN55a4/bN1u+9FXHY9fWeeUXOxw+gFRXJBmj3ViRvu6RR7oeHyouZ7bjoMv8z9mXiYjvgOnoN7QWSxRDjSFYCz7HJKuoxJTrB+1iEQvrruSRuqW8PmP2N6/jBAZffZLq2qO0s0AMBf61GWF/H982bCbLPQkskoATxFrOWJfDNwLNxOOurjH5k6cZfver6NBw/dWXSf/4AcsbM47mln313MNxRxz7xrEEjtqaBsvK5OY+S1UiCYktNhkcippDCAekuEZSnzE0gnKtwE+HxHaCRgvRZ1eDMbmwljP4AZw5X/DQVcPufMJv3r3Hnb1IsBYtJNM/EuAMYgziA1oktLBoOSQNRsjUkbYCuj7DXGgx5x1+YrBrQhwDA5BSsV4Zm8jjGnlGPE9b4XLKGV77Lbyn8GoLv2k8H9SetLToPriFYlqhXkzYbSM3B5Gn11quTIdcWfecLVvei4usnbUJ2gB1nX92hTekYwj1r3+ht/bT0ux7m9PkBSsWvCepUg1Lrlx9iOmG59a927z37l127q5IweOMpzEd2UACxnbV+Eg5wI92zKJEzgaxoGNIFZmVeirpSE6D0HR1Qk+V1pS+XpE5riaeibohZ4sER0oFzbJg+17N9fcOeeb5TR5+ZJMz59/j3gc1dTPAMM0zq4dkFbnlOGfV2GOJibGQcgWFnPORzX1DN44upaqvSa9YgliiyXJ2JR3nFtg3ltoLVhNOSgatJ71xLxfXahLjLzyC/9Jj+OGU1rzD6o1AurvLGSwjNeysalobMMYw8gKihHFB9dhZJt94ivWvP4WOxxy++RZv/+PLPPZhIh5UzFrPPRVuJ8MOjrl62qS0MbA0hplVFqrEqKBgNPcPgQhxCXEfbc7QNBPaKDm/eGjx0wEx5PqtqTHQdLmfzmOcZTTxnL/k2Tov3Lxf8Nb1BXsrQXxGTWqVJIZcI07BRbRStKrQaggjh64LejbBVo09n7DnLEyEdgyxzHTboYE1SVxJka8Y4UvWccUZyiTsNcp7DbwShJdDxXvBMl96ZKEUs4g/tLlkUDuiaYVte8DORoQ1w8aGY22aELcgNXVuvdcE3KqBNqBd+zaNvdTM3NrPo/D9HpLzk2VvBohFfIEmMC43wxmNBly4tIX1jjv3bnLz5m3mRy2GIjuBjMli3lgMZa7OJxEkM0+1L3XRs5DSRrdJzPlIiz9sllrHqmz3/f6luaaPduDIZTFWXXzWkKLPpUW8pV1Frr93j8V8k/MX19i6oFTjGe2hw+gaEgtSMqjcw7oFGmwu30nOXTydx5kzPk2nhpsuR6Wfv17jyCqiTQbX5goHtQq7nSd8zVlGhsw0EWXgDOvzFl6/k3ffumb0whdx33ySoEMOfc1suc/Fo5az0VEh1DGCN9QSmU8c9pFN1r/+FJtffw7dnNC8+T43f/Qy5o37HB6WzBtYpMgSaJJmsgvZcnZmQENLbcgVLLr+f0LOcMn1DRqIh6TmiHp5hsXK0kRQn/DjEo0OUUNcDUjLBpsSzhZ4b1jbHHHxoZLRFN59Ez580LIQkzOeSnJChQHjFVPk8EcqK1JVosMC1oEtkPMW2arwZxtkUwgjaIYZmEZgU+Fagmei8LXC8qjAmMgeyjsIryXDK63l7XbA/WYAM0UPEzpbYefDXOqyNWDGzFY1O9PE4qIyWBcGWwYdzNDlApoVUgfKZUOTIhqkayyTHUOaeuL7vzCUciKdTgCqpz6xYghtS1FZfOFZW5tyZmuNNhjuP7jPzs4ubZMy+a2pO2eQz2dJikkxq7lmjtplTi/q8kdJG6Cb5Kz4N8gSUfLncAqQH03s/jhATz6rQUbZ05oGZPU0F12+/t4d9nefYXPLs7kF1fiII1Mh6QySpigtau7g/IwY1ujr5upxoSaT2UWS+0qaTo01/bz1Feg0v19KYhJhEnNRj2AMdwth31nOY7kcDetFxe3FEQOpeUyV87NE++49tovEcixMX/gyi+8+jgxaoqw4+Pl1LuwqU0ogkKJy1yvF42eZfusZ1p69ho4qwtsfsv93L6EvXefRueW11nGkljpkmV4BAxIz2pwbXHia0BK6kjSodJqBI+IJ5L45pDk0h4T5AfN5wbzxBNNgBgOK2JVWWxoaV+ECFFJQFYYzZx0XLhmKUrmzLWzPFR04mlXEuK6mrYCWEcoGXwnJDwkDg47zEjFnFbdlcZsbmLUj0iRSD4SmzHTJscIFhC8lyze15AuqlLpim5Z32sivW8frachvU8mdFegcOAB2VoT5HG1LwpEjLfMjXDlhb6IcHAbOnhH8GUsaNbC/hFBTtIFq1dJIzM6hmPomK1lqfg4wPxecx39+qiem9ouw+41qghhxzlNVA9bWp4zHwqppODg8YjFfEIPBSICwAi9gXS7cnKRzAEmXO7oE04B2xPZkyFVeJ9keFeXEprQf2zj66n+ngWqPf+ZxB6w1OU6ZKhIFIkqKhtu399jZTly6IoymFl+1XXGvU/ULBMQFwOVKCmo7Rdvl83eqdc5OOa1xdI41NfSFkluxWBUm5BJX+wLbziADgw2Gs7UwKEY0Zcsdp5QhsKaWtXnk8IMH3P/Fa8jYUf7wT7n8gy+zPhwym/1H4k8+zLVfsZBq/OaY6ZevMXrhOXR9Svv6+xz8w0vMf/UO03tLJsWIg8GEpkks4yFNarAUDBhQUBJoWKZIlK4cmZpO/p+kw2XVXukbNVEvaJctzaqkrUCczTXdBFoLiMPE/HS8T4w3hI1NcCbyYNeyCpZiXLFSm7tX9I1dXUB8gx3murJSJnSoxCnYNbDrBrsGMsz02mRzyCKndAsXgccFronjQmjYiwvutIe82UZ+oyPejZ4HTQFLkP3OkjlYkVY1GhrapaU9EIwqrYf5QeRo3nDmvEdGDgoFVpAaXIj40Fk+ncTMqmw8DgN+Hj4/R3K6DBZ7lDNIZQw6yo5Qe5S5ps5izRb13OO9Y+vMOtOxYX4o7N2a0C4HKDPqeAjFPknug5+hydG2uXat6AbSXsK2czIhYZG9tLqHckTOOjl3ys409JX7Tspx9jV8eq5rdep9B9p2QKKh8b9B3DakL7E4epY6DbDrv+VufZ8vbpxncO4Z7OAywTvaUYuG26TmAJrLHB1dBbsA9QzDkI3FlGIe2VtdJOkaKxas6JhP0iCasuUeDSZOgU3AMGZKAD7s4rYmJoZLpWiU1ijvWWURas4zpKgtB+r4IDnOLzxnP/RcuVlQvXIP+9rPcP/T9zn47lMcFDNumz3OvX4HDQ3h6XNc/B/+BPvNZzisHPNX36b+f/2SS/9whzOrER+K8O+nit3OTduXjNlhyl0c28axa7P3eKEtoV3g2y6e3NWIz72GurBXmzB19lLTBtK9IYfvb7IYVPhxxXRNSGegGUDtFjR+BrpgGOfMHp3y0MVHeXi/4fbdAeXgIgeLQBzVUCxh6sAZokkkH0nFHtU6uPXAcrxCz1nahzeJV9doNi2pHIEJlNpyMe7xRBv5BgUv2DGPRkuMgR+7xC+rCT+pxrwK7C0MPLD4m5GtW4nxDnxYe8rFJv5AifuJdpW100VZE3nAg6Zl/2CI7I14ODzEpWVk9+gtottj6SLJnUfnBhMOibqPMft4WeDMeYy22OhzSOkPA+enHb3tBLEJOC8YYykKx2g8wDto25rFsiuoKyeFs3rJ8dGur7lw1kmrhE/YUqT7208M7XzKGD/2NRGT45NJ8/lMi8gKMZYYhKYrW1uUButM9ze5J4Z2Xcq6smofu9bpTeO0o0o+9p2T923nfe4b4WXJA04NRchEN5uyzZrEEfDZ04vJlRWSI+yvmP38dcQH/J99gecfe5r6v2u4U/2UsRg2fvAn2KevMt+vOXz/HeYvfkj5/gxiScRyR5X6EBocOZqbWHUe5aCG1D2jvpFtP/a+25mqnNowuyJoElDTgrS0KdG0kVgn/NJQleBLkKHJbQ3EYlPJeL3COGiD6ZKbHC4JqM/cFuMx1mBtwpQOO7TIGrARMeuOeNbBmSG6ZkglGImMULZwPGyHPG3gmlRsAcnDtlreXc25EWFHhLoWOBKYCboypNZQxy7TrY6kFcQmktruNoOiYmhXSr1sEQNFAd6mXDMplZDmJK3hOGZ/wmzLc/r5K/j3BKfhdLNM6VU0tZDAlDlmZ50wLEucE0KsaZoFMSX6mrZQ5IFLy0lR5J6C12W/SP/A4djr2quwemo8kn/m+OZpYPTfN/3W3p2vSzVL0oU+C4xrMeYQYy0xQD3Ppy1LKGzXb1IUsS1qmy4sMiDHZ7u5+J3GQP31ulfn4JLjMebxNV3xacjqXp4dgw+GAZYhShFzAnkwnpU4ljhWyRIoSBQUy5rhzTnL//wbRuLgL6eULzzHaKtkUwvMY08iBwv0tZv4X33Ixhs7DO46GhmwW3lmK8+wUe5a4TBGDlHmWJYYGgwhZbNF1GD7ygLdVpL6zZK+QLLvwl8BNZkJ3rYNdZfRI4Cf5n5Ba2ctq01H8p6NKJzdGmE8NEtLU0EcCs5aCq2ySWSyHzE5iw48Zr0ibAb0rMK5EVy0cNHjhpndN5YV54g8KiVf1IJnxfC4CCPgAcprJF6Ulrei4U4t1EcO9gyyYzD7Qj2HtgadQbsImJkQ5yknTdvs2CEamlliMasRgbICZxpsKgntkBQWJDLzTTtGm2rfYe10H9hPPz4XnELqeiXmhS6dP7JPLsaUGCyqkZTCcd9ECIhpu6iizzakVvStv3P8UeC4hWBf7L+3bSXbtmqOCQkn0omP/eyB0G8iPSil+7c9kdipyptKLKBoMf4Q40qSWkLbuTksmO7auRZrbsSbVeTxR6/HqUqDvRTpxyDZZ9sD83RFwtYt6Xu4J7FYtRkE0eHIVeJzgyZHqwWtWGo1tDhSRxE0scUc1QyXh6z+95rbzTaD/9ufMfmrryLRIO/OuPPS66z+/m2mbx6x8cDRNhV3xfFhVbHCsUZi37ccSuQw5OVUYwhqOj51JoDkuQ/kNO4cJ/5ItzcpwGlOFrANSE1INawSYJgrDDdgYmBt07D2kEUGlvVoWBt5bAFqHIuB0A4CamwmXwYwRrKP0EMYKZwxhE2PngUuCv5cJrQbya0HN9KCR4l80Xiew/B4FCYR9ozyJi2/dDWvOMPt4DhaGOKewzxw2B2D7gmrI4iLBIdz4iLSzBSdK6QlOJ/DIcETF5awilgD1imGOS6W1K1AeEBihvREmFOlVY854P8ym/MEojlz/VRIoKvTAjnBV0zqmqU2uV2gTbgidD0sc4vwDM5RjjfSdtKvB2fXIl70RHLqKc/r8SLoh33a0dPX8vkYUOm9tV3tWSk7u9nnezEJ3ALjlnirOJsrBoawIqaAaNXdc+xU7j7R+5QTqs8xPRXiQfrxOk5cZ7mkiXRzJhJz2KgDeEJI6kjkLlq5oW0OBWUyQ77/HKjpSk2bEvEl2qyIewtW2wcYSVQTR6uGOtYcHhyRdhZMDxKmccCQoI4m5Q7OYwxLt2BJpNFISJBUOtW1L9SSldnYbYjSb7gd8eLkJR2LJ2cKpdTFYyKgOSl50MCggHJd8VNYj4Zx1/fS93vfKJJcTh9I0UPHXWhL0KnAGUXXBTagWhOG487PKLlZ8rUQed7A08bwGMIEOGqU97ThddfyGxO5ISXz4Elzi9kzuB1BtoV0AGEOrBSO5jAX4pGgy04tdUAUjLe41mcKpokkPSSujpBmAk2R45vM6Qk2mUTTZ1H15ttno+4zwXlMMqff+U/6Tme1Mfe3aNuWskxYk6jrFSGALyxlmZvGgEO0IFdGr7JXT4V+R9Guf0Z/1V6N1VMqqnTqU6cIIpzU7fndnp6nPbc5Jpnfd9XgKPNEd/xb41aUg4LxOINzOV/R1mQNIUmGptJJ5n6MXVdtY7t+KT3p4dRGIf33OB5jrjFksCpdb85ujDiSeBrjqbVkpZYS11WtcRRqKDWrvo6cWI0RUuFYlUN4+iJXv/1V7HiT/Xf2oUmM7IgLjz3G7GakXmxzeFupViWbDGmC5R5LwKM2gUYkBkxSrAhOwKkSNN9BblNhcotULMdtN/pcVxFEcv/MHGLqzJBgjsldqxksDhuq1YoBLWUJY+sYiMXYrBqubcHwjLBaZHA2STITqDJo3zplA5hCsQZnRrmNyTC1VClSivIN9XxJHedxDIEDo7xvAq+nwFtGuZMKFitLOvCwK5hdkF2BfYiHwEIz+35Ww8KhSwN118oxemzyODVUxjMalBiJ1Ms9VvMDpB5hW0tsI2rrbn76rgEhq7VdZlXvhP6DwHncJOe4ylzP5lH6Fk6CI8WQvXYamM/mNLVSliXjcYH3XckOcZ3kHJAzRzg+X3b/6inmTy+J3KlF7z5hoZ+Wqv13fveVu1h14OybrkKu/K4G41qqUWJtLdvQ84OWetXZk8mQgkOjR4xAbDppbUi/4wiyH3tvcwPiDMdT4zb4mG20hM3V8CWT6BtTsKDAJ8sQh6ilUsNIYaTa1SlWokRqE2m9MH/8IvK9p7jw5SfhwZK9198ktYq99gUmly7QfE3ZdwOWbxyw8YEyPRRshAWRe0CljqBCq7kZRei25SjpmFQZuuBQMqYj83eFoLsNWsjgzJtwQZQCq66jquX1GeYw36spdlcUR5HxpmcwqKhMNid8CZfOw717hr1FYk7KtYUrkxOoh+S04XG2Xc+M4eFCuZCUaduwlpSJM3wlVVx1jpgs25J4T1veMA2/scJ1cRw2BXEnwY4g9wXZAfYhHSo606yKr0IuW1xHaELmyGoOf3kRvFVG3rI2rjASWc5mrI7mSBOQjlerJjvIRDp8HM9sbvV4zEP4FIR+LjhzlTTT2Z09YLN6JRicK2lDRFNLG2qOjo5oa2U8qhiPhxRFfcL66W1PGXSqbdfpS7TTmE3eefU0AHvJ2Xt45djW0U8CY1/X6DRwe4CbHuydAyOWOZnbtFTDOaNJhGhZzoS2jllXSI7UVogOMEZJOusk6Ckbty+P+TtA7T2ceaPppXyuhF51lnuuii5SIKYgmoJaHCvJFdGLIEwU1lEmRApRohPmhSWMDP7hC5T/9RdpvvMwq7UB/OhVyv/8KtQt4VuR4pvP4p9+CBlXLIZ3cPU9Nuct4+RZ15b3qpa1UGIDOe6sHDt9ghgayQ1zVXLiXhTTpY07jGYwHps2UiJyUiXCawHUdF12oRbqg8BsO1HtOeL5AcWkojCC0Yj1LVc2K+5sQhwEGoWVmNx2byIwNEillAWcKRJXC+EawsU2sLFs2UTYUMujlAyw3BblbRN4SVe85hI3TMle62nnBu4n3AOwDxTZBQ41S8xlzK86YpYlGlaQVmgUjJZ4sZRRKFNg6GE8ypUvVvNIO28xbU1udt5phxJBOtqn9Ou9t0E/+/hMcJq+49ZxsD3BcQigVxUBDcS0om08u7sHHB4s2bo4ZWtrg8lajStitmOSg7ZrWmPKHLAWB8QTt7z2XtbupZ2Ke8wK6qWTy6U3jztUnU7bOvVeuvxK6SSoJUtAyTawIWLcLmubNWsbynIGh7tCs4SUYiZrpzEiDTm/dDfbwpJBaV0uZnZMij/uQXoKsCeNIulb3iUGnQXqcLgM0OQxtsA6l2HcKFM1bBJZp2WKUhaZlnY0hnRpjbVvP4757tNsn/fcf/l9xn//FqNXdgh1TV2/Sj0coM8/xvixs5SuoDhSmO/Ag5ZRCrhpy8aewceESSet+VBLEKhFWIqC0dwlWqSrTugwsRs3lohDdYCkEaIThILKeuauJbQREYNRSEvDas8ye1CwOF8Sxh4zUoyJiB5xZVzy4KyjOVyy1EjjLe3EoyNFikRpE1teuOo151+qci4ENhTOWMuatZSNYy/mGPJvXOBlC28by1G0xKXD7IPdMQx2QHZBD5W4SKRlxKwCaRVgFTALD2ZF1K6relvhsXgJDIaBjaljMrY0deRwN9HOE7RzTOwoqUFIcYWmOusfmvvB5paVid9x9P9zwJntss7xooJ2yo321REQ2nYFYkmpJoSC7Qe73L+zz1PPjrn80EXOX2y48c4uIUJSh4ZcFDp3KZ6DKyGF7nIfA2avNmrvgOgXTr/YP0ZA0NNkhK7wl5QIuYZuVIsYRZyCeIyZUjilqva4/EjJuXMFdz5Udu4mmqUS2gaNBmEKBFLaR3Ub0kWQLGV8MUR1l9zIqM07Zg9M7dPUstbQ94sGQxCP1ezaqTrvrGAw6hgYx4bAWlqxhXKWljM0TI2BgdBsObhYMnz2Eu7bzxBKz+q1++z89ctMXnlAOa8ojWf3g0Nmf/cKRdOy9rWnGDx8Hvm2R1eJ+pUbtIsl62VDSCVlCr3Cje3s9FaUhXTFB/pE5k6bEDwmeXLRLguUBB0hOsLKGGMLBmVuxDsPTd6CDDSppDmEg7uG4abhYAS1VygDwhGXiy1WFwbUfk4TGtzQshorWkYsiWkKPFaWfKHyPGmVc60yNbA2qBh5i7fC7UZ5r4W3jPKWM3xgSvajgZnJ6us2DPYsxT5wmAizSJxHZNFiFg0sWnQZiQcVdqhgcs2j1LQYScCCyTBy4dyQydhxsFfz4G5LPVNSPUPiKjPeGkhxTt/vVWkJoSHG7CWzQt/T6A8EJ3JsU9DTnIXu9/nPxYGYwKpeMDtY8uD+IfNZ4szGec6dP6Qa7bB/sMpWSzmGYLCuJqYVmdDuT2KSp507/RhEOuBJF2vrpWqR//ZYepYcd/rqmhAcJ3CrBVuhJDQtMHaC8wPEREaTgquPOdanwsu3l8z3B6R21ZVKMUiqQAYdF78r/EWW9LlJ7ClVVkw3L31YSE/dV5+I7XK6mFrKZLJzAfAKPsBIImdQHi8GnFsdcRHlslRQNuxVK9pzUyZfvsjkaw+TzpS0bx3hfvRbzv98l+FdzZ5en/mvg/cXVO42PoyRZ0u4skn83mXuugfsvXGXtdmK4egi92dzTIqdayp7ew9iyNLdlVjtbPDOgWWSx4jFicOq7bzMuR82DBGxOUYsLda2GDxGC4gOVkJzZDncdextw36lLLaWJLPiksm06pWUmAB3bWJe1IgNDFQ5a4QnXMETwCMI6xZc5VEjHEnLIjS86ga8ZTzXrfBeMuzUCisDBwZ2gB2Ie0rcAz0IhMOWuGhIyxad18iigWUkHWb6IlWdPf0mEcKccbnk7Kbl3NkC7+HenrC/bUkrD/Wc0B7kLB110Gub0nJixvUO0M8wOD8PnEJvb+ZMDtFAJo9Hjr21EvEeMC2hFWZHKz64fo/7dx7j/OWHeOzxOa9evMXOTksbFOdGtDERQ8T6NYwobd17szqnjvb2m2ZnEakDGqeAm9vH6e8AM3eaRHJMVY6llUVshdoGTMRXhqr04CJnz4156umzkOC9tw7Yvy/E2qDH5Uky4EUM6jSP7xTrKdGX7LQnACXzTYXcil2Oq8TnYD7WE5LkXivkIpsjEiONrDXKWZQrheESyhlgUETqsTK5ukn19UeZfudpiovnmV9f0vz4Ous/usPwQYX6kj0TqFOLWSXGuw7/8iFs/5a0l5DvP4V87RGqM4p1S+JP32R9CDE44gpSUmoCAzxjStbEkqRglSKtGpKYjificx2c5DCaw2VJCoLp23DkUq1qalQalCJ3D8OCOrSF1QJ2j2BnphxNWpbDyCWBamQph1PWwoo7qWWmuRzYNBkuiOXx0nMJ2BTwVphZzz2UD1lxVxf8onS8Q8FOhAeNITTAXHIfhW3gAJqjmJNTZy06y9JSli2yCOgyQK25rKruQ8yZMGIDoodMJomrD29y+aE1UOXWjcS9Wy1h5dDmkFTvZ7tSbAfG9pRDKDuDeidotkv/AHDmo19o5JPLiuM263igJmmdnRymoKmV9965yztv3+PSw1d49IktHr22ye3bnr22oSwrYquk+ZKoDrV9a4VEn8h8cr3eaRQ78Mmx1DzOqTy2NwuEqivs3IFSKoTyJJSSLGZQ4apE4QXrVwzGgSeunePRqxf44P3I26/us3PX0TZCbmDUm+4KuFySpXMyidgulGLyNcSiYk92TOkS3EROmsR2m4+IwRiDE8GrMiSxSWKTyCaJcyTWm5pNaylLYVE0DC6tsfXClyheuIZeGHB4fZeb/8sNRj+/zuRuBLfBHQk8aFcUMZfDHLox9VHN6s0ZcvQOIyyDv3qOC88/wXCRuHuwpH69xk0MI1MwXwpltIypOMOQqAVNMIwkkcSSbLY7swdeUJMZWuorKHNjZK0k97wa9Y9Sc7Exl9DS5GoEXc3uRYSDRjhoDEeDksfIaQZDMWz6IQ9oWWrAJWUahbMYLnWGhgBHwAHKe5p4nYYbtLxklVsGGhXaJoORQ2BXc0moGVl6t4oJgm0NtrFZuOWaz4hANRowt2PUjqFwVF4YpQXnL1Y8/Ihnum7Z3ml46+097txaoI3DpITRSOwrb/ROoK6cKxKOpebnUfg+B5xdrEotdGwRpO4umGNdYiHEeRe7GaDBcuO9e7z+ynWeefYMlx7a4ktfucr1Dz7g6OAuAlTliMViCaHNlCjp4o7H9mMftulCLiLZy9uNqe+i3f9UfLYt9cTeND1IpYvHdaCxzoGtadIRpTc8/MQZvvEnF9hYg//8/77FB7+tOdz3aCtAQ5IVYgKkkLtZ61oeTwdE4eSl3Xh6b5xALo9y/J3eSeXwCUYIYyuMSUxSZJ3AWSIXSGyR2LCCFoFma8DW1YeYfvUp7FcehaJg55Xr3Pnxb/E/SaQHkQeM2BbLu3WNY8hlpgie95uE+oCVGvugZu/vbzJRx7kfPs306lNM/8czfPD/eJH2/px4r8ZimdRTNEwJWjIDBipsapXVeYGVhWj0mAiVLOhgAOMKjM1VB9a7TJHS5qbJaZDpjwNgkKCCxhr2E+w1yk5TsZ/WcATGJjvEhsAFHBGLM4kBiYkKo85aaCwcolwn8gZLfhMCt3HcxzCLoKsMRNlT/K6SdpWwS+bRLmJOIKlBGosJgsTMW47GE01EV3N04MCfB7fC2DnT4ZJHHp9y9ZECVXj77Zo333rA9s6KUi1GDV4MrWk6wsJpUJ4QEPqI/b8MnHBKzcxqrYjJC81GilJY1qu83dASFLa3F7z9m+u8/tolvvPDiq9+8xK3bz3Fg9sz7rx/hEkTctuDgKY1YNmBv5eCtgOn6W4MeltUumFLz9bhpDuySF9xPWejCGVWacXnc/khGEdKDdYv2bww4qvfWueZZ4Wde8rLv9xj544hLCzWWRItsEBlmcGdSghnOnWFY3tTenZM/+pZS12KW06zOmkoC5ZLbcvAwMjCxCZGRCYpskFgk8SaUYqR5aBoGD/+EOMffgvzhQvQGuoX32P+T78mvL7LaPch5n7Ae4Xh/RDZZcAm6+T+2YaDVGNEWSuFNVYUD2bM/v429Vx55AdfhC9ucfWvfoC89BYPfvUBGsHKkGo1YtIOOUOFpeIeHTfJKHOnrGzs3YOZjlYJlAl1gbaypEFLXZY0SWkbS0wOOwDWEoznUK1QLzS25EgqZmnCPE4gLTEuMbCOsnOmWVGcdkI4JSTVJIG58ewg3AotN1aRu8az7yua1qM1cBThoIWDBHuK7JPfH9ms5s4FFoLWmbqpyZOkM6Wsds99mF+rG4ThPpuXhKefHXH54Yo72y2vv3rErRszmkYYqEG0wFDmncHUHSh77S+detGZbPDRpIjfG5x0cU7JP6XfBXJUWcnt2zOT3OYqSNYSg+HWzQf86pev8NDjFY8/eYUXvvNlHtyK/GjvTZb7BmwJDPA2slp23tpjydmRxiR2wMrAleMb6Tt59epttufEnFa3e2ZQR5kTg/EDrC0oBrB1ccLzX9/iK98aIk752Y+PeO/tOcv5ua6tQsrSUubZXUnO5o/tBPzq2AsrnRQ9BiU9SA09E1nkVHyzC1Nc0oYqKs4oA5sY2kiVAsOUGBml8kq56Zg+cYlz33kW8+x5RB2L195m/x9fIb51k8Ge5UY9454xfCiG/VggZo0ZI97p2jFWjBnVymFKHA1KNnzF6GCG//UeB/42U72MPF1wXq5xGIdQzji45RCZ4Ow6IyZMBLQG57JT2pXgnFKbRJBc76mpmqyuOgPDhJkGzKREnMMwwAWhWhfsGUO9BelcgC1B1ivs1MNACEa7hGQoTVeQRmNX2uOERaYoDYZDhEMci+SpFVJy2dMcBWqFOkGrSOgKOgfwTYLa4FqHpEzkVyukzldF6pdeYuwjKz9kVQGc4cKVmi9/fchTzwwJQfjt2wvef3+Hg1nAWIdqQ2xSt94UzIreMSj0Cdb6MYB+OvZ+P8l5fCjHnCPN7I26WeXvOYGGHKOzJQf7B7z15ru8/LLnwmXDF565wv1vf5Vb7zfcfPeAg+096lXIdVW0tzF79bBTa7UL8ot03uKeDmeOf/Y1dEUEPf1577CRE/qfiMPZkvX1kscer3juy1MeeVzY2Q384udvsH0/oGGAwSNaoyl2YZ/OCOnpf1LTVz04PVci0tHWelCa/BCUbkzSf5N1UraiRfE24UXxqrikOAFfwOjslCf/9GsUL1wB9Xz4yjs8eOlVePM6Zx/UmDTljkbuaOReBKFiWK5x3w64J5aRHbExDxAaJKU85qrANJHB9hFHr9+nlIJ04QzVpZLHv3IVF5fcCg0LW6LNiHljaJaw5nJ3vaaAtoBYKGINjXEkFDcpcWuKs4Ifgl+3TM8JYTalcIJP4CZg1wU966nPV7izhunagMlQ8IPOemoEL110ICkSI4RO8hjACCpKLcdtjVFvscHgNbv+xklAlYjNS8ibXOLEg7iEE09hXc5HLyAotC4zpCAXLZAkVEshWWGwAYPpBl/92oRvvGC4cNny2kv3ef21B+zvrQhBKJwjpdSVppO8oRx77E9JzN8nV+z3AqdW2ex0B+CO8mKPfe1Wi+gKa4SYHClk2yo2v0HYxDBk+z3h5Z++zMULhu98a50XXthi78G3+F8PXmR/D1w1AbMghW2Iu6Bz1CzITGebWwKmDSwViS8i9AWjawwBMX0csSBpRdQhImskRpkpjYWqyt1pRPDTPfzmbR5+dsp3/+IKX/+OY1bX/P2P3uatl49Y7l9geWBJreTEXno2U9uxliJ5ScwBoSmUelKz2l+SWEDbUiZLV5EWIyViBbGKjXosGSsCnoItSs61yoWw5LIoF2gYyZI0jqweH3H2r65R/cllEMedn7zL3k8/oH0LmoNL7MfEfbPGr4tHWZIdj0FK1A5ZmZLWWuZS0FaJmSoTY5kay7KBFRepy0A7t+y/VbL10jblF88yeNrzyJplcHbO/m+O0DvbuJnlybbgw5C4uTXilUlgNmjxJbjYstUE1sRxOPDcnliWG8LsDMhDnnilYm1xSNjdxtpAue4pp5b1dceliePqwPO4UR5Ty2UsUwxNWRLFYCTrPMZ6jHH0tYmTycYVIkwRnhBlk4ZnyyU7qxmL+YqXy3VuTCtWrmXmG+ZVYDaIzEbKfKQs1z0+TtGFJc0SuswUPQkNPrUUKWR+cXWFIfsMzxzyxDMVz3zzDHLO8ov9hpf2I+/EkqNijWJtTJsS7WCJyk1I1ztZs00p69gUUXL3b69zrLkEZqurwhgoKf754FRsF09pcp4eZDd4T+WT2KVTkYHEEuJB5qHagnYRuP72jF/84/usV0/x/Jee4U//9ByHB8/Txp9x+/YDnPMslwNSu4amEiFhyHZcUkOKNmdn2O3c/CX1ErLMzCX1IB4Rj5GCKDltSVyJMUOSG2CKEc6XVBtvce3ZIS/84BzPPj8kpZbXX93l9V/vsnvPsTyyxDZBaojaZvAf82f7bIuUbWUkN4v1mr2QEhGNGO1zUQw9r8qgeHKcbqqJEULEYkhsqvKEeh4lMaGmLqG9ssb6C9c48/UnaWPg6LVb7P7sHVav7bPaNRy0A3ad4bYd80CGRIQGoRZLqybv12qIKMFmLqwYh5UcU/VG8DbHVcMchm/XLH1k+IxhcN5w4SsV04lSv2sw9wMsLcO2ZG2jIg4TUkZ2BhBsoEiBIUI1tOimY7VpWJyDwVXDQ1csRTuiPki4IuEnhqo0bHnLw9byqIGrolwisC6BEkMjFSCYdJKkeKw0df5JJH826HhqQ3Fs2YJ5UbIkUfmCh2zJoXXsDkp21yO7FxJ7y8TsQIlHnrjnkJlDj5R2rrR1pA0FySRsoZQVPGwS1itbF0Y8/cWKy5eEZQMf3E/cPyipk0VMRemnJKvEYpjZQDqDtADNfd8sDVEV0VWnnldgfPZ2fwb+fs+UMf2EF9mJ05dGlO59ly6k2hJTy979gtf/acXI32BYXuTZZzf4N//9RRqu8Pd/d5uDvYYmJoysk1qLBpMrWKbOq2UUMYlY/hZSgTYjSFOiThEd5xtVh7EW6wyJhPiAqyJRMlunGk3Z2Jxy5Zk1vvODLb7+jbNUheO1F2f8+G/u8/6bsDya0DYOaME0wByVOhvz2qsnHfunmwLp1O1MB+QjVkVeWIpVxSalUKVSYYhhJAZcjScyjYaNlBti2WGJuTxg+K2rbH73OVw5Zvul6+z96B3a1/eI28pR47krlrteeGBgFpYkhEYNKwxBXVdEJGKwFMZl1VmUQrJML1QokqXoermEmwP2aInGMfqCUF3y+Kml3iyo31sS7sHafIT1BeqgFPhA4aBILCulNS31OCFblsGaZTAV1ieWS+sgOOajCl8qbgCVhYlk9TMRWWrLXAOl5DSCoi9PDCc590aPw1JWes2wNx3A4jAiGO/xZsxlCnx07JDt5OSyTdxUASmUNPCEnBJEiAbbMa+igVhBWhPcNPDw4j22zm7wyKUNLpyxtK3wwYdw77eJw1uOdOCwK0dqAz4G0AVCQJPL9WtjRPUDEnOSLlCWKE0XP+9Txv5AEgJCl3PYBU2P9ecsSXpPXc7qPnlpaompBixhfo47Hwx5ydxjPPotG5vXeOTaOv/tv32cZO/w0q+uE69H2vmEsBwTU4EmycW1qEFaxLaId9lAoIQ4ROIY1Sk5oNY5gIzF24gbCK6yrHSOdysuPDzl8Scs3/yzh3j2+SFVZfntGzU//ptDXv5Zy/69ddpFVteRnrU0A1aZE0nsAJozbCRxEm/tymJme5NjeEq3pqwqRVKqpIxUmIphKhbjDjhXDDnTWlzT0gzAPbLO9FtXKF54lMGli+y+9iEPfvouy1/fQbY987rgngo3DdzDsEfiKM2JKtQdQFt1nTWbQ02VlARxXWkT2+UUZVmeWstSDA/fn7KsIwup2SgM08pRnLWUVUFyyoo58U7NYGG5EnOqWlxBjIa5UQ4K2NaWeWgplhZvDWG3ZLlmWFk4WDX4FspaGDohOQFnSN4QjM+xYhQUNtIp3xrpeP2JJFD9SCKGVYuYPO9JLY1aVqlgEWAeErM2MguRoxg5jA1HTWKxhDBX4r5BjyCtLClAK7mfqTqwBQwGkYem13nskSFXppbVkXDjeuTdlxM33kzs3oDlAyXs1cTZgrSYQX2EaQ7RMCOFmOdbZ8AhSRYknaPUGaAajpMM/jBwQrdNnQZmB05Rcom/Ls+NjgWhLUlXudKAAsFTpyG3Pzzi5z95DfEL/pV5lseurfPf/JuvMVmf8suf3ObBLc/+fc9KSjQWoEKKNbHNu42krwAG40vE5d6exApNFZoKMLkKu/fgy4gdLCmrwNYl5bmvw5eeg+e+sYnGhtdePuKnf3vEKz8/4uDuOeJiSLtskTRD5QjkCFiRi0lrpyiEE9e35vEZMpFATF6wiKB9gDlTFXCaU80HqkwRNsSwJpazYc6jI8u08qy05fD8iOG3rrDxg2fRi2uEG0fc+U+vM/+nW4T7kQUjrovhPYUHGObRsUzKnh4RU3aM1GpzpQSpybFezzK0rIyjxlKLZaXCUoVlcCy0YhQ9l5YlrAKiB+xpzcVYcfaLQwZnCqqHPauV5XBnhj4QpKlYN5Y1hGIBKSiLQeIoRGYhURUJV0FsDStTsm9hZ7WgdDA0wqSwTEeOB1PHvYllu3LMrNBKjmqv9dRpyb0ts+l0ErjP5BqLjR4jhqDCUmA7wd0msd8kXm8DN+qGw0XN7qxhf544XFoWq5zH2S4t7UIwIedlmhRQXSEkJkvLOVtwZSw8ebXk3NgSDlreei3w65/VfPAW7N0RFnvK6nBFMz8i1vuE5S6p2ce0cyTkAGqui7+NyiFKnQFKIB1v+p0E/MPA2QHy4wA9Pl/qqowoXeUjcorQCo2OkBIaDzCpYrkIXH9/h0Vzj3m9y5//xfd4+NGHOPtvL3P+/Pu8/vIur718lzs35qxmKzSWWHV4nSDiOTo8gzEJsV1JiM7BmxJoMljr8JUHWyN+znC64uGnRnzl25t89U/O8shjwt7ugldffMBP/vY+r/48cnT/IgWXSSmSVrfAHoDZI8ddyfWG1HGceCcrICEpEyJynNNmcEpWbZPkxADTyyfNDWyHqkwxbOBYN45vhJZRs4+eGREf3sA+9yjlt66hV9cIHy44+k9voD+/jbkf2Usl75jMgLlPjtlW0aKaOGBJ1KxwtzhC8kSpEa0Q43FpxQLHUixLNSxUmCVhbhyzuGLgHeXheaZBGaaaqr5HWLbIfI0Lz56nOL/G+lNTjm417N87ZHW3oU1TrLWUq5w5IwNBRhY5MsTC0FZKrYbDobDt4WBpGYhjAiwLw8HUUbSOSoU7CfYraExu8/BQV6QibzcRQ0vZlbCRriNbLteQ48jqMqfgRgNvL2rurWp+WR/ywWLF8jCy3BOa/RKdjYjLCan2SBf9I0ZSaKHdo2SPrWHD44Mxz29c5AsXSx5b+zIPdoWXf77NL390wDuvJg63J4R5SVy2NKt9QnMXDXdI4S4at9G4xKbmWJBF7iAsUNosNQV6P3OGmPlUfH4OOP+/1P3Xl23Xld4J/uZaa5vjwl0H4MI7wpAgmPQUla4yU2qpurtMP/ZD/1n90q/9VDVGm6FSlUrpxFRSSZcECO/9tWGP2WaZ2Q9r7xMBEASYTFWlet9xbpyIOHHM3muu6b75fTmc1W3PcSwUp8F5pnPOIGPIS2QwzmSHv7mLEvDeklaGTz5w/OjP32Z1NuWP/uyHPP/NCf/1//kRvvaNR3npxU946cUPePO129z4cMnqFIwuKIspbSgQmzlDrROsAWMiRgLGeGzZUM8Ss53A5XsLnnjmHn7v+w/x1LM1UiSOj0/5q//1bV782RHvvgIntw5IzQQl0jdL4ARTnpLS8TAgPMlh9JbYrM0tFOORtIdNZpjeGHLObd6ZWQQzj4PiNFGiTMnqYXsCl8TxVQxnfsNmf4fFtx/l2g++yuLyAf0Ha47//GVO/+JVihuBk1TwvhNelJ63C6FVwyQofWpZ07OSlji0uXssfpjOUQl53jJZCrV0amkxNCqsETbRsk4lk1jSss+14HmwddRHBX1/xuFySXnacvW7j+EeXfDQ81ex/YYPTo9Z3U2YsKDWkkknTI1lOjWEnUCaQDsHPzGwgtMSaGp64/DGsAFWIcuJSFTuxqz3M01CEWGzf87CKETc0Lyv0Ay+j2TFABRcbrB1AicWblvPR3ZDIzXClJginVfavoBuAo1BmsikBbuE2p8x17tcmp7x0L2Jp56Y8vRTFY8+5NmZWN54Z4ef/O0d/ubPP+DDt6E5mdMtW/rNGcmv0HQX+AT0I0z6CMshplhiTSD5QCTSc5bxACMUVR1Z/rLPidEXYN+/pFo7eMttvnkx5yS/2Pa+IMNYDDp4HvWY+i7YhhgKlD2cucztD4X/cPIut28bXn/9Ef7ozx7m3vst/+rxe/nBf3Uvb7+54rWX7vDOG0fc+rhleeYxu2+QohCDg2SwpqCuLXWdKCcde/vw4CM7PPToJZ565kEeeWzB3h7cvqn8xx99zM9++gJvvZg4ulWxOd0htXN809J2HwKnyOQumDtkqu9pzj+1Hj7fENJKbuMMtdvcUTVmACLkUP88rFVynTSRKbksUzJFzo4Ii8owubKHe+oxZl95Elvtc/baXT750Uss/9N76EdLuljynoXXQ8fNwhKrKRodZ6njKHkaPB1hMM6cdwYJKFX2NERQQ9Rx7tUMlV3wGPoYmZjIZp45kxY+cBArdF3RnLbcXR1ShTl7/RzziPDAc1NYF7zzypLNMjFLyl4neCkJJkLlaV2kTcrImFFoHpYqjZJqZTmHdg/iHtgdxUyUXgTjDZVAhScqeFKeH6VgZCmsRXLEJJKHMTBYl1X9dgo4mFQ0IcIHJXsbOGwbbvsNd+OGlhOwhsom9iTwwD48OIXHr0x48sFHeOzROZfuK+jdhg9vv8vf/uwjfvFv/ow3XlnzzltK6h0mBvzqhL45ROMRIoeIuYlwA5EbYI6wrMBuMPRoyIMTGW+dC6cqJSrtgBPgN1vmlxlnQkkyNk8vQo9k+4jcfA9kPMcoWju2H/IOQlwDO4iZEPtASMp62fCT1Wu88eab/PjvFnzr+0/wze89zUOP7PDsc3Oe+/qcrn2E2zeFTz5KrPwdfB9p25YUIq4wzKYl80XFdO7Y26u4dmXKfA4pwofvwb//N7f45c8/4K3X73D75pqwfAjfzIh9QYoOTWuQE6jOEHOXtPwY6t3BMEek0thM7oE2t44YChNDQzmDhXQ4Y5/N0eMwGh4z5bUIlVGOa8v9jz9C8dTXobpK++ohpz9+ieNfvE17p2NdVnwAvK2Bd9o1XVcxlxkrIsfacWwS0eS2TxLwKWe5SsxFOhknYgxJCgI51NRtK8oOvxO0XHLc9NxoPVNNiNTsBcXcVG6/tML3H3JFHwCB6wcFN2qlO1nTxIJkLFUF9QRsLcgEqBRjeyapQPrEsl8ihUEvz2kvQbyssKe4OrIniftUeNCWPBosu60iBWysYTV4+gbHGqEyMHVCNYFqGGJSAzsoDwOOkmtOcQ84whXHyXrK8WrBWbMmRk8hMBGYpcjVcsL9eztcWRicwmYNb34Ir73t+ekvT3jpV4d0v9oQ+jnOX6Ht7rJef4zvbgDHuHIFHBL6m8ARmS71DONWCA0pbQhKBqVsZ3oHm5GxYvvFx5eGtXliW3Kp2hjMkFudG6phrGJmr9kOP0vAgImKAiYS4xnRC7gGzJy+Kbj9EbRNz60bK37xk3d58NGrPPToPTz40L3cd98Blw/g+v2CLa6eN3Iko0nEhC2F5eos8d57LXc/Ud59fcmbr57w0TtnHN72bDYLNO6yurtL7Cy5eLUBljnPjKckXUO9yHoBcZzHHHODdb4/ji2QtlSgST0pDRpvW36Y7FsjYbgx+M9I0EDnOz6ulWLZcfWX78ILH7O8fcrmw0PkrnLWwvt4XtaOW66kdSUpKMv2kFOEs8KwrIWokWrVDD56oCulyO/VpyGwLvGE3LPeYpLzphM1se479FApxHA3T13SiXCJir1GWX/gOTu+jb1dMKmnNJ1BW4XKkZzQWrgT4BMVbjpD5wyNS1TWMQfmYijrCc0BnBRL0szB3CJlYpfIY8DTVDxlLA+VFm61MCmYzAsODXyE5xYtDRZHwVyEfQuXLMwjiFeShblJXJc1czacuh3S3HHPHKprJZWW1AqVyejAVad4IxyewevvBD54r+ejt3tuvB249Y7n7ocPsD66F7dcobpCuUvkI9R8jJ3cQvUQ1RM0nOY1RIslgQre55HBjEgbWozmAketGSCvGobo6h9TrR2OLe/eaJsDik8kDSjBwJbPdpyDRMkSUHUurhgPcgqSeU3RKcQZ7bKgbxxnd1o+ePNjXti7yf7llzi4XLB3qWQ+q7j30p9R1lBOwJYbgp7QtMesVis2q8jJYeLOJ4HN6ZST2wXHt5XVsaXfzEnJ5VnMzmW3Kn1ulZgVufgTs7iGllkvjoHVgIZMTbIEWQ/GKdkIByHeLIH36bA/N5kSiUyQ5UkEhFYCDYE1cNwI5oNTDg/fIwVhs+xZbwIrr9xIkQ9paCkzG4GmgZE9sjSwNBkrZfT8NXNmnDAaMmhjqAYKfgA55mw4DvczJjlD8Uv1qFqWhUNLZePgrBDucQ6SpV5ajt8MtGXHWgqOvXJoInfqjjuTkmNrOJ6WHO9WhBn4GUgN6iRPLZmSbmrQq1PYF+oa7jfwVVG+BTwvwjUlc+/YGSicdXDTwjtS8oHAqeStr1bYV7jPwn0OLiFMyV2D1C1Jq0PeC3AYhao3TBvLtLVUrcBGWZ41HG9aPjg84dZZ4ONbDbdvJM5uF/RHUzibI+s9TC/08WVUVii3SfoxiU9Ab4Mega6G3DGzuucrnJXe0TDYhM9rDWUrVrBdK/n4IqqSL8k585HGmsjnPiJ3/JIylCU8W2SRjtQiI8a0I9Ni5qwn4w8L+mUu/XfGsj6ynN5M3KpXVJOeovYUhbAoH6YoCsrSIC4RtaPrWzZtR9c19F3Ad0oKHbErCG1N6qaon2HiFCgQvYWYJcgGZTi5GkGrAe5Xnhsf47zRGsyGkagqy+IEtrN64zDAhamDNBTMhYQfCudrIksJnNDnIoavOT0VTpcb2qCsk9JYR1sXHHmh99nITYh0RO64xLFN9CZntXgwcQhPGbfCNOCrhiIe5+Ca8ys2aoQmNO/vJIQG6JxnVcFZoWysIQkUsaDyFboylMawrB03KuHmPHKzaDmcdCwn0Exr2sWENIc0g80CznZyhLNyBX43k0rPK+GBBF/r4RsqPGPg2kAkccfAQQ13Iry5CbwcA28CH2I5VkuXDDYouxHuL4VHJ3D/DC6XgqTA2WbD8fKMV0+u8sGJozkMdIcROS0xawenEE5r4qpgdZpoN2tWq55m7fFNJHpPCutcFJSIpjfyOtAj0Dtk/qgTSEtgk9fxGE1pQOlJDFjsrVTFcIyFik9Z1hcfv53n/Cyh9Kd+N/54rLBlQQndPr5FaNkClVTQlPfvkWSLLhu5ul0oZpAqUpjQbjwtPaqJE7lFJuvK0yw5TNtBZYZKR2JDig1bGeHYQRI0CjEmVB1i7iKc5r6p9IPik8mjYAxs9FvDPANzmg1T+qHfmVkhlIiOdIcj5YSMuWkmoI6DcQoJK8pKhFPx1AhBE4sYWCSHNZZGhWNRTiWytsIa6L2loyPmDhlnJtG5lEeaAtgALl4chGcw0jT40TG1SNsKcu67mSzlJ2moKVjWUVCjqI0Ym5jYRJQs6lsp2FTi3YIoJSeu4MZMuTXvuT1Zc1J72okSpxYmk6HiBWEfDg8gFRDsimrXcaWqeECEr0V4PsJTES4DwSm36sCRTRxOS24G4fUz5a0u8WE03ImGZRC6IeCa9pG7hXA4t9zYg2t7UBYlbbXDZh64u6q51TpuHcLxRxG9Y/LA9akgZzBpHLbZw/YTbG+ZxFNcWtPpmk5bNHZZEU8/BPrsJdNZ3syT5zylG9dAfmO55jI4HjP0/9NQn0ggKsP4oBnAFF9UDvotplJ0u/eOF3yEr4014EHsTskLQcbxnmyAhtXwBvJC0lRkF69u6Bue5Q+jQEyk1OP7CVEqjBSIlBiEVKyGtn4JtFk4lxGVk3KvMp4DAEgBDR0aT4eNQhCOQTpEQpa710HYaBuSDn1a1hmIYFb5PWoaSuBZQEjJ6tjjxZELTN7jGYmDQSRJYPKkSa2Kw9OlgCOw0ECVLJ0IRyTupshp9DTp3KByGUrpo2ZFRJHMOB7zhR5Z2MdrpMM7kMEzsjXK4fcSsQODQcYwC6ca0ULAKWLyxAcCpQrOCEGEZV3S4jidG+7uCTeniePSsCpBK4NUgquVOFXSIsCu0u0btFwjsmR/UfOgDTwrNc8Zx+MIuzHRxcAd6fjERI4Efm5LbkV4t1dubOCkFzZe6FohNCCNsmwSKwkc1fDJvuHKNcdi31HM9pDFjNO2Yn3iWVcNG41op7CcZArMUyF2YKMDv0F9R4prNJ0R04YUW/A9xDZvznjQTa6l6LZBytjqER1D144sAN2fdzcESBnNlDV9AHXb739jQPrbGuev3T6lDibb//PyHuPpcbGCsMLIGOpmD6WJIT81IAlbkPulqUfjmqhTMlnUDCcTskL16WD8kWQg6dBxHQ0mOUgX+Ydy589Ii9hskMPq3mokZsvWC49XZOs1N6gMnKs64LpS5hJKksNaHbymbHfSc08ViUQSUTRXTiVSaIIUaTXD4U9EsQQ8ypLECYmzBJuUiEObyiOcIcQk4DPYwUSDHS/4BaMc6wI5RhkZEtPw+4gag0reQMWkLfPbyvRQGnAWYwxZFN5hTEkUy9LAjbKlsYbN1LGeOo6nymnh8LXB1g6pLK7qoBb8tINFQhYWVy7Z0YbHKuEpY3jKVVzPL8UhkaPQcMd1nBhYq+FvAhyt4dYysjlN+MYQWyVtNI/erBOhifjo2Ziewx3DR0cV+/dO2LunZLFXsZp2+P01LNbYsifFDW6zwCwLdGlIfcJrR0qHaLwL8RjiBpJHYsq6mip0MhYEG5A1uUPckqPBLhsmfghphzVl4meCVpfXzmglW+rULzLL38o4R9MbnmjbkNet5bNdDOM3ub+VJRYEkQ0iHXk42p9/iHExa4/YBNIwshfk6ugUYY1qTVSH+IQSiHQkE0gk8qxmCTrJoAGdnLdAJIJp8uvbDYInpf1sxGSj1K2GRXv+fqQf3kuHqGbWPi0gZRFdcDk6GG8j8F/H+znzGzeqiBIFVNIQgCo9kmlUxBPwGW0pGRPTR6VJiYZAsCWd5M5qSnmEzmIpMZTDs3XbSvn5tdjWCi4UqfJmkg0zmWycmcVB6V2LuAK1BkyJl4JgSoKt2LiSI6cYu8SXSqgLQlWzqQqaqkRrg6sdqY7YKiC1IU6AWpmUyqwwPKiOr9map6TiurEYI3wkiRtl4I6N9NZhohD7xJsNrE5gdSpwLHkpbBRZpSwDv05IB6mHVpW2jiwPe86OK5qlob8HuoOEVoqroSiUmHqKrsF1gDd439K3d8AMVHy6BO0QjbikFBoxBLo4hqwb4AwjJ4jkVonRzKanmoa1NOCVU8i48K3ZDDzNwxU5J6j7RxvnZ73k+P2Yz/z6o3Xb6xsXRcr5HXnMXHQsVgw3LQhdD1IhZEIuI1XepUY2cQw6TK1HJct4S5FROdbkMp+0QyhyDqUb6SE05paPpszUp58SlRkSGQbqQjsWdsZdrhhy0rGKe7EQNHy+8fMOCuCf+jckFyoJJ1lp2QOiSq+wdpmTR0VwEVyAqAmPsnHCppLs8b1BekuljgmWEotHSdIO1mi2Qc1FA93eG/uww3uBHMIKIK4dgo6aaEp6M6EzNW1RsKoskyJiXAuVx8wKtEr01Qxf1lBZUinEEqQ0lKXBFBZrE5eMcEngKzrlayx4MFkKFW4qvKyB1yVwVjh2qbjUgr2z5rSDfgmc2pzxrASzTHCm6CphNopEIXqXL9MqEU+V5amnOLPYQyE9XBBkhnQVFk+wEJzDFFnJXOIa2y5BThB7CHKKyAarPZY+b+TjsIP22WvKCZi7CEtM3i5zDWLLY1WSsIgqRje5NgCcKxAwrPfBa36qOPT5hvolw9bZmCxgNZtJ2iaxOTRLnzLSXD3MQWvup+UqYhyWakTF59xt3D00PxPDjGg27kwkJqYY2ASELkImZZ4jAzdqGuF1ksjer8s9JQNGcvFGokODI6kZ3tO5v8/vp0elzSGs+HNZiFHhTEdQBdvcMutcDDxHks+DATTl1kQON802pBTN5usR2gtno8Owdo6uzDQwlcZc6hooTvyY5osOlHC5dTMSngQYcubxzI25P9vztp2HBFQuUHhag9oBAWwBW5BsQbQVydaoq+mLgr4U2ipQlYlyIpgp6ETwtRAmiTTT3CmbGGTqKKZQ14ZZoVwzcD8FT4rysMAiRY6C8r5RXlTPa5LwruSeVBE2SnGnwzega0VOEnqWYAm6VFgmdJkyNY+6gXfT5TZB7NGjnuVJhb0NegZp6kjLihSEWIGfK2Gt2fuGSGksNoHxHsMaY87ArkimIdCRUsRqTa7KrrPH1DVGNoNxjuaTsc7nCggOxSHqswqFjBKWgxGKoGLzteAcKfAPNk7HBpdgnjrm0TNLno4s0QAFPYYOn7PLQXJPtMBRDXu7xWuu354jJSwjE15e+JZioLJUKiIVyZSocWBtZnPDgJehqBHJjd+BMWGkMhmNPch2YxoRp8bmELxQwegA0Nex7WNIMsUzJYgZgPxjBTSRS+UtliVOMyu6jTt0YZYda1Vi7YTCz3ARjPZkuYWEJ6JRsTE398GyoSQg3B5fY4DsilG8KOti8MTiCX2D9IOHFw9GWZvEevR8ugvhscHUwzbEtkScCiNBC2pRKQhaEqQiFBVUJRQFOJuJtQoL1XCzJhNcOUNXTOldycYJpgQzgW4O7DRw6RSu9LmVXSwwboewB3u7sD+HR4rEd6fwlFVm6vm4W/NCaPkpkVeKkkO3gzLhROGNAMkt2P0Y+ibSLRNhnUiNoJ0B7xjVAFIn0Euu3XlAZ3kpnApnH0J13FIcJJytIRWkBbRXlBg6SBsohfZkAZuAaQ2iM9BjNJ2S7CkUSySt2O9f2KZoWZVgglIMlYCcYgU2CMutzXzKByqsnJJsHLROlVgaQunwRUlvDTFDhP/hxhmlQEtoC0dXlbS2pPE9I95ejYC4oXuc5xo1Gnw0eIaSsRSDgV0wTmz+u5RZDBJVZgMfBO5UTfZMqWAky8JOh+cYDHIbu5tzAx3gQ+fs9DJMcmXP1OAGAx/7sOTwFM0hsjEwneXXEIY80ufEX/sBFZTovSUsHEyFkwmc1dBPBNNarHcYk4hFIgyTwSblcwKOIA41JqO9deyHyfb8bfmUtAZZsNVdSRc2oHEJSIEtZ6jkEpRqzAUzzeif7Eozv24yFnVllvIqy2ycrsgbYEqDukUuXImYHIE4hULQUoh1ATNB5mDmZI+ZNQkzG+gUilpZVHDNwSMOHptYLlvoJXAUe97xDR/iOTP5upUMFcxOCRvo2oZiXRG6gG882sZsgK3NjO2dDF9NHmPphohCBXxBcHmlb056jHpcDa4UCusIdSDMezjtch5pDZgJKjNE87BG3vBzyqZEjthhm56NbO0X2NtFwoACGu5f5AwaxgsVk89vGqa5NEdbhvwWfpNhfqlxnmEIkmjrKebyZer7rpM2PTFpZiyzSh/bAVpv8lVKuaopqcCoo4oTrJYZrorJhMSDxzSpxCSXZ/O0RLQgURBNgTcFwRjicCFnurtdnGkIH4RxMY/hqiCaQ+kMOdQhzMy/Pa3mYA1WEpaIkYhYza1OY0imoN/CoCQbbor5QqvHqscQSQUwq+G+A8K9e/iugc0GWdTYEInaE4zP+askUsyYVtShJm84de9ysDPiXdUMVWebzyEVojWqNVtVcB3OL9mLiPPYyTIbp1zoZ8aAJs2hmXGIsTixWOuIZYEpSvrSQuEyW56swMLECRMLzmjeO2vFTyP9pCdMDHbhKPaBOfhZTb+jpD2PLGCyCOxPDrnPFjxRFjxTT3i6yHKatxReiy2vi+cT4zi2NVZm7IYaPPgzZbVs0WZNoZM8n6uSRw5T3nBztD5s1EYYL72Sh98NkUJsJq9uC2xlmJQl87qgnIIeFKx3DGeVIdQevRUoihmmmCC+yvBKo0TX0dsNCQ/2K2wzeB3qFDKqAXtUPNth/FE5bItBz8fctaTQk2KG600mNYv5HGMMMeT98XcyTphggGr3Egf33s+1BjaNp48JNWAKixSyJRg2A2+njQVWs3HGMyE1kCSHpXHMezRTE7pYIlGwaZRVcCSxBLFEY4kmg7Or9W6+KMOsR6bMtIP2psVYR+HGEa/cvxuZYnNRSigX+6TC5UkRE7FWsxryUFgK1lFMF8N7zNuA1YBTj9OA0dzXbOue5azCX7vE9afvYTKb0U53mC17qpShXL31BBtQUWyCIhrQgt44gjEcnHlM0qzfmSANgImULFELNBYsz/phdG1CFh4eIIaDPAYmoMUuiJAEklFCSiQNmSIjKs46inFyxlq0sMTCUBeG4AzJGYp6Su0S8wJqp9giolUGFvhZgZ/U9KXF7kB1kB16mArdzpS0C8xgZ3KX68URj9kFXzM7PCk52j0G3kqen8XEjdk+K5kABdNkqPuM8Wg2gM+Gt28zE17nSkKVTcMMHTw1OeCSgoxf6Qc0Zsq5tjGZxsTLHIlZ0nNRwnwnBwz9jmVVzfEzWJXgjiEtW7SbQnIkE0muJZgGb5SmuncwOEU1z5de1DxxDorS5GhjS9GTxm0ESOyn2+A3w0Yp1HXFtXuusrM7p/gS6/vCX1cIQYF1oj3tWB6uWa5bfAioEcRBF9rc75PBayWH1TIn7epwOsVSZsM0ZtB3zN5Q1FFEC71gY1bYyq0KSzKGIDYvOrHoZswPc0FDcahkQ1YsxhQ4V+fnHYxShvBhDGtXfSIag5FIIZFCEtZoHkW1BjUFx/EWYaS4lITRhMFjNWDVg4mEWllOC8L6jKKacue9G/Tv3WSy6qhiROnpjad3uXfqEriUjTOIpbeG9cphkqCaSGm4qeb+bcoetSwmpFELRoc5Tc5zdXRCavcRk40sGSGMxSwvkBLe5DErC4iNuSVVCNFJdsJGmLY91EIzgXYacqvKpiFzcKi0RDU4pigVaoRgJc8zDD3LK2XPM1XDk8x4EscesGwTb/SBl1LgdSbclppAyaQXdleCnoE5U9ploFtvaLqW9SfQtYJvPLGJuZjeA32CXodbwgzgHI0RTRmJMxpGpwYKYbMjrA4ts8sl9SJHV2FpiL3Q+UAfE8GvSN0JGo5QuYvaOyRzlyhnbNYXveE4mZS95migki48Rsdq3LnnDHaJpIyvLUrHYj6n27T43hNTzip+J+OceNg0SndnxfF7t7n99ke0XZd7O0bACar5hXPQajOFBDmsRQ1RSpKxjGzoOU/NYSkqSBoW0lb677wPNPLQIoY+XQNGfgFHxrgOuevw9XziYshBtxVLyH5wMuR3uY/liDgZamlGUGNpEyTjGOczR70WGVSJDYopK/ysgLann16i/+Am+t4ndMsm4zNpCaZHbQBRQgIZPKcaC8Zw5ncyQomxT5pfR7c9YMG70QhHcIW7cN+AHqDpK7mYU7ocporJuXKMEMOgqZlLX2LTWHZHCwWXwAohOLqZod8la5JeEDVGDQSLnVik9UhXkjoLhVL1lp2+YtE7Hg6GZ+uCeygpMdxJkbc2Pb9sI6+J44aZ0rUG7SCuhHgC7bFiTiPtWcOyaQh9x523zvBdj276rC7tUx6u7nW4H8FHJA3fx4QmP+SeGeyvOgFX0k0My5sGu1dQLCqKaoJJFa4vOVuekZYNaXUHXX8M/QegH4F8jJpbQ8n3I86B6heVwoYQ1wwcRxebV8r5feBE+lxMSgrWcjabsLuYcnpyTNf0yKSk/A0G+oXGaWIm8a4jWB/AezTk2U2rimgixZYLvhBRi6Vn1M/0psEjJMk7+7ayKm4oK7ts6Om86CEMngu2oaxVM5SfTVarkkEQdyvfYNA0tAm2MvNjayebaMECl1xWUaan0GygI9QtikFUCOKIQ6iYY6ZRISoORN41NBOYTpmctdSnDe3JCrNeYVKXc1MJRJsFC7JN5H5YxOHFQHKMSJ7PTrXkz20wcSAo1iHP/qw4r+bihQxEV1hHKkY0ypAHZR4XzMBuZwbFLhma5ySl1Bk9lmQgFgplzLdCochFlXq3wu8Zwp6gOzCZwtV5xYNTw70T+Hox5eGkYGpuq/JO3/OST7wWHR9qRReHzXYDepJBOe0JcGLoTivCsodGiSeJ1CXYBOh8piQJo1GG/DWEzM44bEAEnw0gDpxPdheKac7hY0XqIJxZ4rSiqmucFZyd4Ms1qWjQYpnB7HFJnlLKqJ9pPL7Qk88KB3med8BQh0DS4XrJ5wsT9dWcsTRE8ITeEHqPKFhnspjAbzi+OOr12atYZzBFDo8yd89AxZE8JQmngSzuJlhGdeRc4epSHgEOYvAiRDX5SbaM7G7gO8yJvujYnZNzQNK2J2oGTK3dek8G1eosKz94Uh2N0oxZJ4Y8SV9QYFPApR5HPxhnzO92WPS9OjyGKAyQijx5IgMaxwZLoQUSoIrKRBMxRlzssdoiBIzm8nuSOIjkWs6nViyWLhe0tluHbM+JkotCGXiRtV/MBYHg3FOzKBMSEYkW8QLOYKzLm8pYBkt+WymU8dnjiHBSUKUrK0Lh0MIMp00ZqAMRm9E2sl8S9oW4HzFzz6yC6xU8XQiPO+FxpuxqxZ3k+CAKL/SJl43j46Jg1QvaCNJnuLI5gXBKrkecQTy2cFTAMmQ4cy9oo1lOISYIMeNdg8/s79EjKSAxMz1q6AcjHVpkLkJqM89lP4PGoKXiJxbZsdganFQk6/CFZuRHGLxh0qHib5B0NlyziGwJ7AKjtMKIAZDB9thezYsmFMGco9Igj48ZK1gZf/a7gBAMJFGCDXTSE6TLzG5DsUSSpzARFzw1aWjsRowBY3LjtYmeXiPR5OW4iYpXk8tUMsx+JrbtkC1IXYYeHQweczSx0TCHBvAonmvGKuZ4uixZeMdSiMGIodYNJQVOAk4ycVRpFNGIj5GApTAFm4FCIhcKFTUjoD9hxlaNGWY2NRLVk0Z8JRHFD0PWGdaXQ/F82fLGIigt57ISA6xA7RANlKAZypjyuyRz+A06oaMWzNB6ytLvQ1tKXD6V6BDighiTPaeJiAkkyehZayzGCeuFkGpDKnL6IWNnySlMlbhQ2pkh7CTYTUwniXtKeKKGZyt4zMBOKlj1BZ8E5TUf+VUf+aiasOkNQ6qOWWYseTpT4gq0kYF2yiLNBF1Z0lmHhpDbJH0aQOg+G08clMP7FtXsLXNIO1SG0tDrHdkf+xpkB6yHwpL8FJ8qZALWWqxMqKodYtwj6CHa1HnQPuX1FYateYSUjDmlSEJk4LzQXzeti99r8DmVGI1zwFcbdCRs/I3HFxtnoaSo9OJptSUwou6H/p34gX4jMAGmkl/QMmj/iGOqSsIRjGWtigTPWpQoNk9sBM3h7NjzG73kmPMZySHYSOg8eCDhHBp3Hg4O/dYBbODEUqujNA4ryoyQda41UOCZGKV2gkToYqInU2GQIKgSNMPttsXx8YJgiFZRCXTi6fAEkxvT2TgjgUCQuG2njhc2yGD0GoYcecQpD/ogOuTjw/cJQ8INaCkHYs+NWh2iU9Q41BUZ2G4NUsiQ4huSt4gOvK8SiYSM0nIKtYPSEfYTFBGpTG59DoADppLD2APodxRZBKZTz/U68tS05Ona8JAVLsXESQevd8KrbeK1GPgwRTaFgS5m4aAI0nq0TaReSUGySoA3SKfQGGhLdL3J4apP+W+9z+N/sQf1SOzRbpPXQxp60Mlf4E5OkLqhQFTn3NFssmeVfD67UFNWDuemFO4ypmzRfk2QFaR1fj0Snnq7rgw2e07xiASMZDqYGD/LPHuhD42Q4sCCYMyQRthcX9Asqmy/QHf+i41TYubJkYiaizOMuaFRaGAqianAXGGuiQKGkxMQW1AwQ0xFq8Jpym/KqNDEjDCKQc9D0UHefqyu5nBhixa44D3HfPJCU14HA1DFJKHQRCmGSpVK88jWHkqlCaeJWjOfTB0lTyBgWSehDTmvjTqOwgk+QZAc+qKZxixXMyPeRrxRMIkgmdZFSVk81eQNJGq2SCGPX2EMRJdbQgxyilsF7grVrCmqZth0VLE25WqrZQB9CKoODSXJQnSK2lzkkdpiC8E6S/ADgz46TMrYnOeXQppYisrBpSVYxTlLXVjcFNIu9JcgXAG9pJiDxGze83AZebYWnp+VPFoIUyLL2PJaY/jxScUHPvAhMbfzJ5D6gHjBBkFZgenz+5d8DmgK9Iw8b7kE6RWJivYJ+iFUDR5Sj2g/VD47ZPieYTIkbRnuEsIp0A3QxgmkUwhL6LOco8YrKAfEUGDMLhI7DBuMrAfO37zJJ6aM6VnaGmcuUIrkCCnXI4bjQjp1vjZHXuexgju2WrbcIr+jcSbFpUSp+atJkagRm5SKxCwm9gT2NDebdxNMrGQ9ExWsMUiyeG/ZDC8mVDgsS0rWONYoSTPqR8Yc8WKoEHNLQ0cA/IB11a2M+xDeJoOkzAI+Bny1OibqqJPDWctBTORhNFiYggWGCsFaoRfhpA+cJEsx+CaLUEShU6Ej5qJJ0mEiJntsRUlb2tB0YYEMnt1ILsaS69kjfFGLoRKLy8aoJcow+TKKAJfzbS4TSUQTyE1TQZzJYV3vM3lWJUitME1IaXLUY0f4nmS2Tx3On7EwKWAuyAzY68BC4QxFXcLcEvahvwbpqiJ7icm05ZGi51ul5RtVxWOFpRY41paP9ZC/8zU/ax2nvWdJnniZNNC0CRtzbm9mLYkOgsevE6m30BTQlNA6aE0GFASIUXO+GdNQ6MkoLRnmKi09aB5wVi4UaUhkUvB1Ngo1+Vymm9AfQjqG7kGSMQzqvojuY2mziJZp80igDp6XMBjaaGCWMTraRnhcjPrg084DIBeLRlOUbYg83n6XnHMY+i5DrtiaCBKVUpS5wq7CPnANuERuOu9RYFwGA9uiZO0Nq5hoMNQ4CgwWg4ScXyWEnlEVeqw0Dh9p+ED5g5kt9E7HtkJyg9d1Az2/wWHI8qWGKY4pBRMKXDTcR2IPmOPYp2BuLAWKUUOPcILlJpEKiyMjiEsMmwQuN4oIRBKJkHLu4FLCpYhPmQbTboNgzXrCCUQNxVBsCmpzbXsytoFKSHUGG+h0uE3IUzCzAV8sW11hKQ22NNhCIBj69RIKRzEtMTOPmTpMZcENQIyiQGwWN+oV+jjs106JNTQVMPU4J0idAeJ+z9FfNqSrwOWAm3TcYzY85yzfr2u+4goqhRsaeCmuecmf8cugvBMWxD5BgCIJuw7sxpNowHZcurqDSyXdtOUsbFjdbQkxYm2FFCXRGhwdajJRd7QGTZrRlIl8bmPIBk6HSk9mVvcXqqqJPDSxQdIIu1RUbkM6An8K2hCLguTuw7gdnBFEZzizj7hLhNiQ4kj7emFuVgcYn45tlbhNV/LXuDXGc+PMkaKMZOOaMCPpuOrWfP/hxqkWVCjUUqS8OJ0KpUI17PMz4AC4D7hEwa7U1EUNWKIqqwRrlAY4JWtNK4lWI2vNUniGkiAWVcOFASzGsSvI/KVsU/PzvAx1mEHu25EB5iXCBMsMyxzLFEeB5X4iV4AZiQWe+fCsmpSNTxRDyyJ3tQy5vZzIvLCJQJ4jNUS6mDGTNiVcSvgYhxbNwDmgMsxzC0XK1VoZ2O8kOcLY79UCpAYzA92BtEN2Z5NMdlUUUApSKsYGknTE1BO7nsJ6dq9oNtjKYqb5ZiuDlAaxhhBTbmO5EmsLBEc7Dh+4DHwvpgapICyUuBeJB4peAg4i1SJwX9HxjCSer2c8O5mySMKNTnm17/l5H3ixK7jRlcRowYPthVm07HVQ+BmdS0QL917d4dLcYe6BQ7fho+MTjm50qCmReo7vDUUXSSbjkWMyJDXbNMdoruDHMFJLZgNV7XJ0NQpOGUWMyQPlyUNqQJcoG0LqUUL22nFJjJdIbkohIYM17AzMHjG2jOxMY1aZs6Y88D+KW130e+duJW5/cn7vU2Uitjwlv7Nxmjza0ltL7xxRCoIEguTRMR16PBbYkYpdW7BjHFd296knCzZty+Z4xabpOaHDISSxtAhrVXoyKLuVHhGXiU2GECzq2AUcGOUZ6USGnoAMeQsJNL+HEkONUiMjlU0eMJPs7RdpyT4wMYZ5Ybk8n3KwWJBUuX22pojCctlQq6VEhoG33E4JJDwej1Js38vAZ7dVIbs4yzpelEHNmhEPPGwqfRYbQmpgAszyuzZzVKZASVkVJHpi3CCpZTKDnQPH3uWand05+7s1914qsaXF1Q4zgegCnTZ0vsXHQBugjco6dJz2DYdd4jRaGlfDdI5MphhZoFNHv+fQA4H9RLGT2JsnrpfwqBGen854rJohwEcoL6zhZ2eWV9odbvkp3bqAM0F6SxkLapMZ3Et1aNohBkvRCZemys5C2Lk8JcwMG1as+gJikXHOY0VzS9A9GkMuxmTO144kPaKeTOSSe5AwGkymBM093YAdiOWSrhASvfRDgekGcJnIHrhpTmdswrkpkvaRVA0eeZz6GSrtOnhSOe9U/+ayzhgOZy8qg/v5bTR0v9g4B9XfZWk5qSy+tqhYOhKrkJiGc1BTKgrUOKSouP+xR7n26BOID5y+/io333uXj5dn9L6lUctuWbEvBY1Kbs9oRLUcwpMMBMjWPzTndXgzQwvjHFKVeeSMWJw4SiOUUag055U1lplE5s5SiuLCimIizOqKyztTHnrwMlcffZTUeYo33iKebtC4IqolqKHTzEq3FmVFpEkh58Bhse0D9jYRDGAz48Fol8mQQRfk6SaJucraY4jioJsjVBhqrJlh7QRjq5yn20iyKxJ3mCwil+4Rrj9S88hXFjz0xB4PPDLhyj2GSwvYH0FRRS4EBlPQaYGPOwSFO8dwsobDDXxyFnj/eMP7Jw23m8BpWuFtCzuX8DPQA2AXJnO4OoFHyoInTc/jYnm0nGARXgNebDwvLpV3TwtunlW0K2DZw7rNU0nOsXJC5eB4DRu/QdOSSV+g+xW7KjSfwPKW0K0sm7VFV0AHdd8SYkvqN6R+k+lD4oYsr9cgqdsaiw7gkMyu4YeTHyEIScoM6yNHMzkL7EisEEYNzY8yE5lcJprLiNmlNBPEFjg7p2OOqkdxQxnn3GPmw3M+fTJW5eF8EMOQp3g///gyA/1C4+wcbBDWpaEtDanMpf6g0EpeaJQVvunonNCqonXB5Ycfwn3/u+AcB7Vi+xP8jYajoyXH9FRGqE3EBCF6QYppps3AbcVx1WSc6YBkg1GVaQQvjKEBdihLgzUmh93RUCCU4imtobCB0kBZJ6b7Jbs7NVevHnDl2YeQ555BTk5ZnH1E8qeEuiXg6JOhT0IrSkui15hl6IPFB82FmZz2EV0OpTLn3sBRamTsJ6HJ0GvedOIAQHd+RiYbqbCpzvOvIjgbEROh6HjwsR0eemLCc9+7xrO/Z7j3IajmgS7dYtXc5NZty7vvP8y627Bqj9mEFVJGFns1O5d2mM7n7F7aZ3+/5LqDR3E80e7w7tGC12/Du4cbjtYbDhfAQmAPih1YTOCaUx4Ry1e05mFj2cNwS3te6jb83VngtU3F6WpBPAaOhWJjKNSRJBOPBwObCGdL4GwD7SkfLVsOFYpGSceG9k5Be1qjXZmntTpo24HRou/ADyx4qQHdoNpmKQMzMB4y0sGMueZQaFEzeLmCDOIY5YXHcfeGTEVzlPPQtMy5q0moMVl02VQEnQ6FKGHLnLGdOtGhGBQurEUZUsFxWsqcr9vP6Yd+2fGFxlm2UCQ4aD37Xc9NH/ApUYhhakpKY0FLkgptl3Mfpz033/gF1y8JxTe+zt3/5o+5+fxTbP76J1z/Ty/w6Ce32HRrXmbJrBJ277vM2ydrKj0ghRltMDQpEWBYukqB5xIdt3Dc1gJJM/aZskuNULIh60CqUcrUcZmGq2y4Rx33lFMuW8M0JB60UwpXsfP4g+z84TfguSdYrda88epb3P7ohPS68mB/mQkTwLLSxG3b44sNwTSMI0PqPgHuh9Uus5u7rA9v0vZDbo5iNKKhx6dI70owC5LeD2EXS6QIazpbEIrrGO6l0F2QiCluY6YfcPX6EY8/XfIHf/YsDz015er9ltMWXngj8v77jhsfXeXw9iXungi3z9yQXV9CTUeoO9K+wqUCuyM8/pjwyDV4aA8e3hWencG37xFWlxLv373Be7ff4f95z/OclBV+UnG5gmd0yXf6I77tNzxaTonT+/iRX/BXxvI365Ibh+BvCnqYYOmhtXjNDE90HumUSmpmAeJN6O9ehrMDaoB1piFJG3C9sBOE1EKz3tCtN1Rnb6OpI6QVKQ19Rxowfe4j6wg2z0riKgM/obQYfA6BU5U3bXoSDR0bOslGqSa3SowGRsZe0x9jesXICqs3EaYYddTyNRINPh6jHAJ38howXY6cZBzaZ+tMRTP1zljoiUMx6ZyM7UL7b2wB/gar/ULjzC2NXFWyW3SDZtTd4NS8ZlB1EyNNNJxu1nz4ycfMX5uy54TdP/4TqueeZdV4Tjc9ISrFrVs8iOGOBg5XLbvqhmhVWalwLI6NyYUfiRmkfmwsAcs0nSOEWgosDoewo1CHRBUTToRJUVL1kaI94YAZD8328FdqrjzzIFe/8zWmDzyEP9xw+OIrHL7wFus7S2IwHKYsS3CMYU3KCsi5f32eTw69LYkm22vMUK58js+B9vk2VGSZgszyDi4BZvdC2iHFAnWKqzzzncD1Byd8+589zR/88QM8/vSUk2XB6y/DK2+f8PrbGz76RDg8rFkta5q+pCPXE50l52y1kNYJbSK6mzjsA2/eFq4fWB65UvDE1YLHrhZc2xUeve8+7rtU8Va1z50EZygLidxvHdeKBQut8MZxB3hzs+Yd5tw+hf4UOI2wjMg65Z4kA2C+T6gKHkuUgrTKLUZdCbRC2iTiKiJtwqWhih0TEjNrl6Rc4BHtIfVcGEtBJWIGnGuutgVEBz6n7YBCBDFDHSAD1dMWyH/uaXUbfvYoLaobFDugrD1CmYkCtiyHF68p5wZ5wbjOazyJc3zbaEwjVO/i81ykyfsHGucWDjrmfYltLphUiAlajWyGSH6ZAraLcHhE8ea73Nv3XL5yL9Pnv0H1zCNUZKqK/mzN1abmieC5tVojhSNpJKSekoS3jr7IxqitwahyY8dQtAV1W6AYemPoLNRJ2Umwr8KOZsB8VRgKB4uoXI2Oe6m4x0w5/PqjLL7/HPOHHsI0Pf6Xb9H95FWK9+4STzrej5FbZsEN6/lYlEON9BqxMVLrILMgSmchswymvHtr3NbtZCj85OtmGelAkRoGmk8jEdJVjJ3hSqiqE/Yudzz5VM13vv8U3/zulPsfmPPeh8pLv+r52c9WvPO+5+6pYdl5unhEwJOYQXyAaCBZi3WTDGNsE7SGMImcdol1G7jbdHy87rmxtpxsap6f1TxaTDgo7uGPKLijcBgCoomrMmXHTllL4o4m3uoTL7drPg5Cu7RwamCp2DW4DZg+U7IEjRlyp4akgV4c/Vrp1z26CoRVQDcB3UTEa57xEYckRWOHGZTMNZ1P6WwpZWQEn8fh3A+95QtMjjrmnNoNCzizsI/Pk3PUHAJrSoNHc4Nx2mGJjyFwQZIZoxL1xQpsDlsNW+zdaHPbHHK02hF48LsdX2qcCR0GjzWP6cScX6kqPiXWmgEJp1gWQ8lb+0BxdIrH0P3NT7iaYPF7TzH/7tPsRY8uE+5Xn/BY19BS8J4oJyZyRkvEsKakQ/DiqGxFmSa0ZYv1Fiu53RKcoi73GmsPuyocmDxfMnHC1cJx3Tuuq+Hq3iX277sP+f5zTJ9+BLNK9C+9x/pvXkXeuMmsDbRNx7va8vGk5obzHGmk8YngPS4F7HBRgyqdzbmNDL1OTcOEBxk7e44QAZjk1oiZgc4weMQo+EvgoFocc/naGU88bfneD6/y3e9dZjIVXni14a//4oi3Xy94+62C1XpGNIJ3DdE1UB7n6mX/ICPbIFuV7THnDaQy0dcGP/UwTezWcOKgU6XEsq8l3xJYqnJKohMwJs/KfpyUd0Pk5W7DazFyp12iK5cnlVclbmUpG8X6gAIBB32ElOlH1EFaJ9K6g8YTlxvYeOgiGhTEEEwGHmjwSPIZM0ufDUL8UOi5MKY15pc6AgHG0HI74Ll9rI6zl9Jti0fbgeg0Vlpl0JjNIhpZSLFEKECVpB2ZWHxo+gts6XZ0gOJ9jhFuN4ovqeX+zsaZzHAqBkpHSYrENOTdgk+5imlJTDFMhbw4VCj6BKsO8/IbSIy0k8T0u89z+fe/RdXVtKv/SP3aB0ypmYVT3neRj41ng2E3RaQ39KbGmCwzP28DVRxGwQyURnFEFigzEhMRpkYoYs9VtTwhJdedsDupmD/9IPW3nmP2+MOEqBy98R6bn73C5vWPCcctG1Hupp67leXD0nPb9TQ+hyEmeexQph851PPZVyTlItHIXTpW6C4C3bNhziHNwS4Q9YgVCpmS5IzFwYonnw9854e7fPX5HYq58Oprnr/8Xzf85G8bzo5r1uspSImUA9OfDAUNKRiHfFwBUglMLGk2YBomJu8NU8tkIRzsC/ccWO5ZOC472NfAflIW6vAa6PE01nGE8F6A94Pwq2B4LRV8gqUJHbQeNga7qXEbg20SxmsedJBz4zRqMS2YTpEuoF2XKQ+6PsPy0rh8dfCcHg1D7V9Gb3Xx9hnj3N4/J3Y+b6mMGiYjk+NFTZNzT3vu6vLjspzCOFiQ++eZAaEdcts42NlQ+KFgC0zYdhW2C4TP/OAffHwxwddgnLo1zoRJAxhc8/62IUMCKkkUKdMpRyWL7HSJve6M45de544J7FvLwz/8Z1z5k+9zdhTpTwO7N25l1Ez0rKtIQ8IEy55X2qg0haEvC66vHUEtveRwYhGUKZE5kZkkKklMUa6lwCO94SGjLGZT6kfvZfLPv4r54TfouyXHr7/D6U9foXvjA8yywZN4J214j0i3uMRR6FknQ4qCCymPfg3wA08iyHDih+kCNA4TEefEwjknHugSdQFyfhPJJNp16SkWLY8+Yfn2Dy/x9e9ewbmSv39xzd/+ledXv4Cjo2tommMqySwJoiAFhewiUiBioVZsKRkPO4E4g7gPaWiLlHsw3TNc27N8Zd/xtV3Lc7XyiPZcCT2TFBEWZNXuQC+ZES54uNvBLQzHtqKRCRAwUTHBUHlL4Q3WW9Q7RCyGgtQnJIFTgyvBdgnTB2KXp0kIGbBODEPUEdEUMu+RJhjQP9lbddt8M6NyBtaBgfs4iwOPLIojcifmvx3VvcZcePRiegEAoIktDI5AplcdRvZwJK3y70zA0A8EamM12F3wmrJ9ft1iZ9M/0jS/xDgDSjIDCGAY0h0HdbNk0ZhnDfMVMdBpnu5IyeIJXDJg7xzT/fR1QmepdM713/8BO//9Pyd0nuZ//AseWDY0KbGUHrWGXUo0FTRRuBsCJ75nGkvWCI0xlMmyE2GKUljFucAcz9WgfI2aBwPYvqd65mHu+dffZ/qNp2jnwvIn7/PJT17h9mvv0N85wQosnfCaD7wryqZ0dM0KUXC9wcQ0tEdC1o8SJdo8AaRkGFYmAFLyuJtlJJ/ezpvKAtgBswCmGbliPeX0Jk8+W/H7f3Cdbzw/oyoNr7685K/+/C6//GnB2eE1ktaIG1IIn5BkM5jfLnBmgZiILTymdrAQwo7QLoA9kIP80jtXLPdctjyyD1/dMTw3UZ7UxPXUsvANpECczFESql1m7VOXB7jJa9gkwaQ5pEgZE3WaUA7InSiOZExm7uwM2gtWh2KmAdl4dN3CZgP9BkKX5zFDHgXT1JNiHv/KPDxZkl20RQfpA0aBoG2PccwtR0a8wVviQSNiBqPWMe8bDZHsSrZ1mYs9c3/eqBxwsqo1mZdYQRLGhBwN6wUI6TZsFT4Nbr9Y/Pndji80Tj+GcZKGim0OQy6+fBIh2RxqxpAImkHqVg0ky3vaQYLrh4nFzz5mGX7E+9OK+//ku1T/l2+xiBumf/kLHrh7izO/xCo0lCQp2CCU2lM2kVOZU2vGbM4xzMmTnWoThU1cCoknovIMhr2iZPPwJWZ/+g32//TbrDYNr//Hn6E/eofm9U84PTzjKHiWTrhjIh9TcCiwPl1h2kSZsvR5Nst8i6IEo5mZfYgcRBWNaWDWM2Tm7wmJijSwgMN8KAQNeFnnEWO59sAr/PM/+j4/+P4uxhhe/MkZ//Fvjnjll5Gj2zVd02LqgbZ7kJTTVBJ6g0lK6sEVAWc2JK2JpqJxQjOQ9eE0e8MkEAImCi6VlBTUJCaSMm43Jk6txYuwaXp6EzhzNUVdcmBgb6mUq4Q7i+jSwtLAxqAtpE7xvdAHQ2pA1gpec7FFE6oF4awhLdewPIFmmSuwQyVWw6DolXJYKkYH5ov2129ywftt04vzfFS4kINuc9TR3gb4HcPUiArGDIBduYDy2hJ0pfw36ZQ8gZIlJHIBMDFOeZ6PMI4mOHj24XVHTPzvenyhcY5mqIxV4HOg7hDNZ6idFcRZIGD6ggrH3NaUZc3bfQNBuR/HtVPl5Ofv8eH833NrtuGxZ5/k3v/rH7A+O6R4IXH1Q8U0PS0Oj+OUhLDBAIfTOfuN4d6UAfaOjMixJHZ84nqAh1AqtyLde51r/6fvMv2vf4DWBcf/4QVW/8vfU77SIGcRdMKxFd5Kaz7SjrYuScZxerbCYEmMupqRPtdoB6CyYNJQ/h67KsMETp4qyZMlwgwdDBSm5MQv07GoSRjn+cZ3G779HcPlHcOLv1L+7t8HfvnzwPFJSQoG9JS0uk0qKnA7uXcXArGLdIWnqLLeSe+VED2dVpnWc0zH+gRF4HTZQNHh5pZZmDDXSS53JOGRmIe63wSOtOBo0FOZDsPEV4Ar60D5/il60uGbAn/b0N5uKY8nsLL4Ljs02yum0SHnHCqr4mC5htUSNitoT4dQdZgwiS2aWkh9Hu7WcUl2YFpIQ4g7CNRupS9GRgFGvZtsjIY+h5UjdQhwkXQ8i2flkyQDgduAbyPDBUfjHiuzS0QsQsYkA8Pr53sM87ijRXyq1SKftkvVf7iVfgk5H0SNeN8Tk0c1DUFsrphGElihj4E+eFrNbV2LkuKG43XHZbHsiOV1bUjaMV8X6E/XfJRuE//1D7jnD/6E+X//Q/TSZa787dtc+mhJWifOfM9HuibRUxUF75fwYDHhwaVQxhYhMatqrjjLlRC5RGIytZxeLZE//TrT/2NGKL3/P/4lN/7fP2X6zjEnm5JDVe4i3DGWQ1dzLJZ1k3MeQ0Uk0JJYuZTV5wcpBAlQpQzkWpOH0Iu54/R0lY3QTUm+QnWOYQ9HTTAWLRdADWUB9CRZ8+w3HuaP/6jj0Ydq3n5d+clfnfDWiyvWhxXNqiOGU8BDOYXg8iKVBCZiikhZRsoKpChoiwm9sXkudqyRDKEXWpJKZTM1fFJHgnRs+khbzajcHjOvXN4EfrQDnyDcSQWOyF6/5D4buVzOeXYe+Whzyo3bAS/3wnECX9OvE2VrkVW2hbiJxGUHoSf6btjeFGka6NbZKGObQQXaonSIdozs6aKeFJUQbf7sY945yGTksHPwaltYaxxoKQeDkjxUnlvyF7vO5xV0GQwp6+dkfHa2Nc1/uy0WATa3ZFJypIF3OA+5m+2Y/Pk4mWOLAx4PASOfZu9KKeG9J6WEc+53Z0LYtkovGP1IujEWordlfASvwkaESi0Gh8cy04JDHK+inBK4P3kO7q554Odr6nLG23HCo3/8p8ymV7Cz+9C/fRt5/SY7J2eUZOnYLpzwbX0It1oRY4/DsS8lB23DNSKXsMis4vTxBeZfPU/9R98kpEj3P/0E9+9eZue9M5qNcqQ2AwzEsBJLq46ogZACOVOOeGBjfBa6tsNIUBoa/YzKGAYdiMSSlohWZFW0CcoOyg5iJjgr+Ojy7GRaYyvDzsLz+FMTnn7qGyxPhBd+cYdXX7zD3RuB1E+oCosvJvi+glCBLfMiKe6A3SCFgpsgZkEqS5odlydXKnOuIiHDG50YdGYJUyHUhlg7QlnTMeUQeHcCNzeOXyq835fcSLs447nOGk0rLtvIw9MJ37lnwfsfn3K2EkgL2BjoAnUPXZvrPLQR6T3J9xCyOLENLRJbJDRozBA8aBgl9MynKrHjUHI5/Oxivtnl4s+22HK+GkUvhKLbws6nDfLTw88M98dcdEiOP/W48bky+4ZIGtIWvfC8/8iY9bc4vtA4CzLxGWxT8LGFm0mkLjZfNac3XoX1kHN3AtOU/fuhUW6ViRMCz3SR+29v2Pnz1+hPDJvJdWZPP8f8T6+wKRYs258S+jU7qeQ+M6HbrHnkVGmKgjsmszNct5br3rGvIHs1y2cuY//kK0z+xTeo9y9x+D+9yPJ/+E/E1045CpF3tOUTJhzhuKuWZXT0qcRrT0+gxxLoUEl5nEvTQLeYhraYZNKvbRV2KKXLICCCkidLdvPNTjA2l/qlduhqha3ggYcLvvUdYT4X/vbvT/n5zz7ggw8aun4Xa0tKICXBB597JBLBHkNxC4oVWhSou0y0i9wqOWjBRozL6s64bNNhJ8B+S7UXOJgr1wvDI1rwmFY8JJnG5G0Vjgy8dwTvKNyRklgUnPqGadzwQNVz39TxtQf3+bvXO964tQE/zzqZjcVuYLICswbvPTGs87RHzHQ22hdov0TDmoE0CLQhCwGNKtA9WYD4PJ/b0lAOHnOkf5GRG1Yhb5ejNmoYws2RiWI0ztGzXew7Xzzk/OtIzSrnjzUytl4GNbHtms8h7Ej0xTYc/ky/83dvcQJfapyCJIMZzkcUJUjmPhnKQdtke0xMA9CRSbF6IxiFtQq1CJ0x1EXJvo0s1rC32nDw8xschn+P+W8LJt/5FpM//BqhguO/NsQ33+OgiRwU17l+0rIJjvcLISTY9y2iynp3Ds9ew/3pV7n8h19lo3D4ly9y9P/9T7Svf0Sfat4u4e/7DStNtBiWKCsMjVo6HBv8MDuQwObpTevBaAZgJHLhqxGDiMHEkXW+REwJMs3FlbAA3UFkF2MqzIjBNBHqlnLS8eSzD/HMc/DRbeGXL9/k3Q/WtN0eRq4RvKOLzTDV3oLzUHgoV1B2UEZSURKdYJ2isw72W5Aah2dSOOIU/CLBgSKXGw724Stzw9eLiq9qyUPeUhZwW+CNXnk19WxOSjZGSIWgHRw1Be+2yqPVmkeuTLkym/PIlV14+Q40+7DJXMNhBcWypWoiGlcEPTvn+xGPegdhA2GVjZNmWB0tDED0c6859hATF9FBcvGrjoUgGeCSF4tD2W2MoDg+dbt4XPSyOQeQcQQMOxhcflwOlwfPsxWNHse/GN5J/v2nRwX/83jVLzROm/LKNBeqxZmNbnjhOPQ/NSe8eS9JdJK5coxAWyY2CgcRpr2wQrhRFhSFZeINs9WG2QufcGT+A2Xn2f3Os8x//ynSVDm0nvTyB1zxhoKORfLcF4VYFCjK2gny+CX2/vBZFt/7KpEC/+PXOPu3f0/3wkecJfhgorymnhtJ2XjoMTQYlpghaFK8+CF1yLGBjT21ypBFQCdCbwzqBBWDxIElTwqgHooLBUYWGHYwgwBR0gTWoWlDMVd2djzPPLPHpavCX/645fX3NxytStq4h/Zz2i6RpKeYKcXC4/Uod2YqoJwMtxKtSlIVYbGByRqsR1yCoiAtFHOgFJeEnT3PIwvLc5OC7xQlz0rJTi/cbeAoKa8Gz8+aNbPbZW7b1YAR+rbmaD3lQxu4ZQJXHhAeuzLhPhf4ZLOGsAcB+k1ANmuKvsHqCnQ5eM4OjEejRdOaPFXS5LxzCGP1M4aZLrIIyFiBDZwXaOLQm7zg7WDwnJ8NbQeytPH5Rkfyqfvnf6eMhg66FcK66GnHvxmPsfgzVgW58JzKBajKP8ZxfknOGbOBmkFIZkuTMrrSIf+0ep6DjlF/EBCj9DaP99SqNF5ZdsJhsliFioTVjsfantULr9DqmjYsufLN51h8/XFsNGx0wtlL77HgBsbM2Csrjqyn2Z/inniQxQ++xvw7T5NMwebHr5H++lXMCx9jNnA8KXgjbfjYR3AVp9GySQaPo8XRicmtIcm8MGMVMbMqXGSVHf4bWetlIMmiAFPln5sCMXNMyvqhSZWYmly8oKeeKZeuCU98pSJozytvwEe3a1bR4o2gxhOtYKwlSW4RYX1W8qomUExzUaku0IkjTYBZyC2TiSHNLM3UEBdKeWC4vOu4f8fx9MTwRF1yjy0pVDhulLc3yq+6yKt9z8dt4qGbHcmUUEsecwslTbvgNokb1vDkZeHRA8szexOO39nQ+D0IQu8Toh1GT9G0zEYYR8B6GESYhqIOGZaXoSsjoideKMCMayobYg5hL4Dax2LQMHo3hpWfzq3GrxdvF382GugFlJFcNO7x8QNT3qdMS9mOfzH467Hc8rne84sISH6740sIvnKrYIvKF4YwjS3M0Oi5nHqe805D20UGcSOfB7bFYBXKKOyro1PLDXxGH1UddRcwr71N56ALyuQb32D+/DPYNOGmKeA/vIVaR5hYVoua9okrXPnnX2P+zJMUauh+9jb+z1/GvPIJetywNAV3JbAcBH0qHCuxnJo85xcoiJKVvqxaYhqgYwOvbGAUEjwvgI5qOjrkMEmyBxWTy/JiaoxMUC2J0ee8PEUwgaKM3Ht9xr33C0cnH/Hmm/dz9/gyHafEYoWYBltl9iIfFE01ttxFix4tC7SsoKyzcU4NOhVMHamMIdVz4sGCsFfAQtnfEx6eW56pE0864arNbBZvRuV99bzYR/5+A+9vhH5dEe6sQT24Sc5zjaGLNXeT5xM8Z9cS13eEb1zd5bV4yJ08GYYmQ3SRLpwR4nJASuUNLoei/XnuaAJZ4/IC+JwR9jgu8PMwcWRDOPdGKUdp27DyM97r8xbvp4z0gmfdTrFoNs5tFfhim4Rhe77oduDXXm9EjJHhnvq/p3Geh9wXGNjlvEo72uo5PuLiyYAy9BiNLE1BcI5ZsJhUMSUL7743DayLM77mKh5ct9S/eg+NBQ1T3Le/SfGNp5hNJ/Dh3xMOjzmZBvSpq1T/7Gmqbz2OSkXzi/eIf/EK9a9u0B6uOEsdH2rDSTth5iaoUZoQ2RhhaQxmnBzRAqNCpdBrRxoMM0kuZo2fZstwEPIJ0G0uk6cqcqM6IaZETIVGl0mmVSF6jFPEeO65dpXdfXjjtXe4cfM+Ns0eyWzQ4gYUa8QukHiJdFbg5AoiHWpXJNehpQwhroWqgMpSOJio0lYLlrtTuGxhDtMpPFjDMwU8KFlV4Q6JN/D8PRte0cStULHaVLACWS8RH8j0DTWUhp6Ck1hyM7Qc39fx9EHNV6/OuKK3WQboPaixaCl4vyH6NeMI1haELjGPx8lnPdSAyvkUA9352hFGGNwFQ0UvGM+n877PX7gXDTeev+Y2RL6ANpLPGNxwfNZvnj8+nf9uKy9vLry/zz7D75Z/fjEIweTK4ahbskU7wacikTTsHDlyH0rNSSAaJOTT3Dkh1ob1xpBSJuBSDMeF48Nwyv2m5tFYsHvkiS/foHMvEozDffMZ9n/wON27f8Q7P/8JtybCI3/wdXZ/72uUpiC9/D7dj18ivvQB5bEnpMzecKKedV/nPIzIOjU0xRmdSYjWSIqITnIrhBJr5mCEqEoaYGlQktFRgh20XJSSaA/ATogmkVyJFCViBDEzoolo2gy8tVkAV0yLyIrr9+1QGzi5eUK3HHIyY7JALZFoetAWVxjKqaN3LVSKqSKmBCkdqQKtS9K0gspQ1oEwLzC7ETnome3A9crySO14oBB2knAS4IMIL3jl5xv4pJEsDn4E7jjRrS3aWFyvBO+zCpkRVuq45Utu3k2kp4Wrlyw75RQbgRhBzkA7JFSId5loK+XijYkJiTE/LuUi20jKtTXgT+WR4wLecA4OOEcFnS/zz4aPF8PVcfP8bGg7hsSjgX7293oBJKBbwM3oy8dC09b5DL//tDGOm81F9MHgxH7H48s5hMQQJC/OQcSXkaR6BL+fl6oHvKFaCDZTNyKoE6KxWFfQlnDYbjij4ICSvZOCwJy+WHAWHLtqmZ8a/Esfs/QruniHS//iexz9N/8dP3niGstJy/WvPse8rTB/9Qr6179E3r7Bctly0yei2WGiB+wR+EAS7zUbjlOeuOjsRwRToGGO6h6aLoHuo3YHLfYz3Ug8hXScoVt0GBOpgEJz9S6aklX9VSg8oeqwkwnO3E/aGJBAl24S4wrsHOorUB+QuEFZ3uThBxfoClbvOuxm4MMRB8WjQCQFj2hLvVghi1NCuYRZwlaOSVFjywo/NXQ7FXFvRjtPyCwiV3vm+4HpfssTly3fKSc8IROm0XGyTrzbwWsdvNGU3FpaOApwO8KNFZOjyJ1NjVktKBuTmc/tGqyjdwvupCu8farcNiD7wmTneqb8xEN8G1kpxel1jHd4+ya5oqpZWrEN0IUsqWA6MpfsGqQbEoex2p/5lRQDcvtCLjcscNj+IKdNcbj/WY83Ag26YSj7143wQn7GuWu5aJjnXlovSPmdM2COUVM6d/wXIsVf95JfivP5jcfv/pef8zY+7/BGQcB6pQoJE4RDEm9LZI2yILLvJiRRzohsECYxkI7O6F8+JZkI1Zzq//Zt/vixf0llApdvn6B/83M2f/NT+tc/gFUgRIci+NTRoHQ4QpmVs2xjqbGYmEAdRAfRImlkxMsamAIEzezr2UUxUCHmTdKSQCcQd4fFNmFSOEjg5SLOduixWR2k2yO2trh6QkhwuhaWRaIrFI0RQo45TMwKMGodyUmW8pok0qQklCU6mZDmE9irYNcR9wLdZctiLtxXFTxmSr7mah7DUiPcNMo7seetXnmzMdw9TcSTBEcJjhW71qG42pNaRVslhTAIAVlSSLSrxPqsw/vpVqVeIA91i8vzl8PInKbRkM6N5nzhf7raqQOBx7m34/zxFxfWmNP92mL7vNX3u4WP//i//d/m+K2M87MsYV/+MXI5e9ADR1Qoe8NCM0TqVm1ordJp4OFQcOAMXuEkBk6iMJeKGZarS0//2l0a+0t+/M9f4OtPPsHVYk546xU+/vHfo+9+wE5I1HWNeMFFZRNgrYGViTRi8SmikqkzJAwanilDsGRkXB+pFLG5xxh1iOnbrIdBVkezGIzOIF4HcwbGMJ/UZCYaRdOQt6kjyywrFD3UHrsoKKY5qLtzWrCsEqkViEoRs2SEUc1jeoXFlw6Z1pljembp5gXMp7BTY/YcxQ7opYTeF9ixjq8VNT80BV9LUBp4W5VfBc9P+hXvNsrdpWVzV3KD8y7YE7ArwfeQ1h5dd8TOZSB6EcCUxAQNHcuTM/rNhPkARsopnwNbcpHhHhjCwyE0HBkUB7YIdAi9NG6hcrINae2FPPPzjvH5Lz7mc74KF3LZ3261fupx/5jex3/m48vhe7/22Ua3/hs+tAyGOe6UAQoMk1xqoXOQCkWsoUlKlyJnoUH7SDVwulpjMguaCFVVkXZmPDZdcKVN0AeK6Zwr1+5hffmE6I/ZLDvUW6qiwlpBfaKNXSZuI4fWAcky9zqqVMg2LMoitg5SSelqejMBXQzjTZGMIzYELLCA+CC4O1QuMq2n9AGM9JmmQzODbpY2TJklrfaYqcHMs3GebKaZybBMlH1kKlAKRGPoS0c7MzAtqGYTUq34OeiegV0He0LaVexccfuR4qDhEbvg66bgeeCeBm465d0+8DO/4ZdNz2lrYWnhSDC3hPquYJdK3yl9TJkmr2nQ3uR2SNK8uQRLVE971hM6MAUonhSLfG21RFM3TKDErWFuI44RXqdjRTRz/4iMDbeIDoroY86on11XF/O3T/0uffpB8tk/0E///rc6/svynr+F5/x0TD+G7PJ5BrotfRtyIi9cwbDDMK9uMrX+IsKVqOyQsCIUVc0iwvVYc8XNqWxJkkB3UJP+8Clm/+0f8ajfQ//y77PxP3A/0z/7ISxq7v7tC/i3buPaHvGJyk6ZimFK1kWZU7EpDGvNBYqSQMQTh2Z4IpBSzIMUUlCXC1zaw5ue4CPaBVLM4IWEwcqcwl0mlUJVNhRFQXCAydMNIg4RkxWsXYKig6IhFZn1PFrwdgHOgANXGOzAeNEVQlsPWNxZRVnNiHXCTxUWAfYjHATMTstkUnJ1lni8tjw3r3jc5G7F+0v41Znn79sV70TPpivgrISjAjkW3IlSngErT+oDxIjZRFLTZZJiOjK+1SLBYo2lGMaPQhS8XxH7/ewAkx3QNQO58zhvOUgPZIMdKqRbFbBcGJJPwd0iOb34PPP4jBHqZ77/3PWafsPPf5vjvxwD/VLj/HUvL1/wyzGHGErZIpnbB2FNhjFXQbkWhXtVOHCwcIaDaHiuvsxTfck8KGkSCV+5F/nDpyj/6BnCQ5dw//f/mQ/+7mechRWP/fF3mPzhN5n+y+9x8OAVTv/qRbq/ewf70YpJ8uxhuYZjhcNXBWsLq9RTE5DkCckP7O0dkZagPSnm1kfFHONKKlvibA4zQ6+kODDKmQJTC266i9SWaA2BQDQenMPEIofRRsAksJlYqo+RLuQzPt3ZpSwqYpkVjr0oqRC6ihyTTiqKckoxKbMywyLBQQeXE+wn9uae+2vlmYnh992MA1NQAq855TVtebld8dYqcdo60mkBJwUcWsxdxZwl+k0gNQHfZkFat0mEvielHrTJZLxkxz+tDBNbUBqha5XN+pDQliRfQpdDcWWQRLiI8hkKN5+esQxD3/MiJ1CuxcqIV9XPM6z0qbWmnzXYz+Sknx+ZfrZ6e6GK+7nG/E9//A4FoRzWnvc0P3so+aTnObo4VMWmZJa8nQSXUfaJLLTgIMC12PIIu0yxLMvI6tE9yj97hr0//RYntfLqj37MD372Dvd8vGRxesZp+AXNpGD3z75J+c2vMNGsNl2aT9BbG+rOsy8lVycVy6Sc+kgnllY8YiI9gZR6PD2JjkimZSQprRdcOaUod3ClQcu8nlLKiygZkCkUM9BpSWNhQyCYiHVlzjkDA+56uPAp4vtA24IpYf9ygatKtDb0ziAWtJTsgQuDlDWuLmEutLvAZQNXLFx2XNkLfGUiPF0anisLnjcFKxHeUeWnvuEX7RkftIHV0qHHFnMbikNFTiLxNA4MeJ7YNNA0eaRkM830IaaD2GQggnqMKHUSZtZSF3B0umG9OiV2O5nhz2f2ApV8Hs+pOrL3NNtWyGCUW+aCTCsig35ppp/M806/MXTdVkW3yiWfeexvUyDSX8/Ttu76s6/7T+9BfwvjHJEa52/2/N6FTj2JrZIyMGqCLTGUJPYRLiHso8xyZ5GpRu6JlkeYUBMJewX+yfuQ33+C8vvPoIsZ/QtvsPk3v+DV12/yaFuy1zo2b5zw0Z+/wN2J4+D3vsLima8w1zld/AWnL73P5qMjSoXLQTjxPScaiWJZ2jIL46gbEEDj7jmW3RPBJ1JhMdZiSsNI17vta5uI1if4uYGpY22zXINaRQs9b3eZcSEIREvMo46ZsnOvIcwMPg2crQawgpgspuqchVpY7YA/AC4Du4mdeeTRSvlGJTxfCo+Ugq2EU1Xe7npePDnjlWVHvypIZwXmrsXeVsxRQM4grj2x6TPZVtdAs4auw24qovZghwFnLSH1GOepNDIxUFoIXaJtW9S3WWMiZLmnyIYMZj8HiiuDfuXWQ17AyBIRyZQiChgxQ67+eV7ss99/QbFn2wz97GN+S0P7z4NX/892fKlxWmswJtMHZgzpaJAKRhAxyDDGk4uzihWDM4IRw0Y9hYUDKai94FKkpGBRltyTCh5MNVerBUdOKJ69yuxffof5N58kWcPqR68S/uoFHvjlEe2sYtUpExWmnWXy+imH9lfYI8/kG88yf+RB0p9Z+t2Ss797hepm5P61pdHIMZFiusdJL6RkMBQEKlomMAjXYipwNQDJt7ShoFxMsFNDtJBSzN7VdLB/htqCMN0jTqE7VDR5oimxhcMZl4HkVkimpCgXGDw3PlmhX5tx3/0Wc9VC5cBbUDI3EJlFVaeOZg/8VdCrwKVENQs8XCSeLx3fqgueLR3GCi+q8tZpw4vHZ3x42tI2BSwncGhJx4IsITWK9BF8AN9At4GmQfoGCYG5TDhs11D6vKGkhERPVfTs1oZLO1Nqp5wctty+cRf1V+F4BXYJrkHGOU3tgbxHW5MwLiHmAvfshflN3TKus23mj4MTv358UTHowvc6frkYwl5s5YyFqbxxyqcgfr/+OiMw4VMAhf8drffLc06TiZwUBqTQxdAjsyLIgHvMg1RCgW4FaFMFsUh0MbCJUCZl1xTMk+dKMhyIY7Mo6J6+l/kffxX3/CNUpiC+9DH612/Bz29S3fG8fq3kIwn0IszUUZ8m9l88Ztp+gN3UpG89gX36QcpdYVKD/Yv3uLSKOHZZEng9wo5eQrXEDURcyUxRWaAs8HaSjdMAdCQx+CJR7pSUOxY3SahLqI3ItKc786RY05RTUm2htqjPl9tK1tDUQlBb4dwCKx3Hxxu6fsala1BfEUQs2qYM7tBMjFU4S9wzhMug1xQuK9N55OHS8M2q5puV49HCsEPkw6j8p1jw4Trw3lFkc2IpNhN0VROOBU4jaZPwXQDvUd9myfZ2BW2D6TpsjPhlm4mcC6AYhBR9oGDJYlJz/doOBrhzu2F12iLBQxj0S2SdRYGGcbAREWOMYCSHrlt8bbowibLl64FzfO1nWNI/x0vqr/18PL6oUPR5xsp5D1U++/uL4IPfZIz/2xvpl4e1cnGvyEWe8/OVwb5ZOzF3Cx0ZTVOmPOAgopQ2EkzPJsFchYkGrgTDFSpkp2D95AHTP3ue+XeexaWC8ML78KM3KV74GH97wyZ4Tnvh2CSOK7gULQfesn8mTN9Yof59GjFw6RkmTz3AdWNpbyr14Q3qTcW9GvnArzjgCo5ZZjMwJdbNsx6jTlnLHC0mBGRYpC2pjMhuzfyBmvIeh1k4oivwjeX2hx6OOroCmDqYW9gIKeZow1YZd6quxBaA23C66jhtEjtXKi5fEs46pbVpCIUzYQdTIV1R4oHCFZguAo9VwveLku9NLE9UWdLwtm95yXt+GoWTZeLozNKfFLhVBcsCPU7EM4+uPLHtoW2hHQ1znb/veyQm+mWb5QOTAhYpDDb1lLbnYEd4+AGHbyIffnCG7ywmRrRQNDakcIbqGmTwnMMgd8Zee2Q7jXIOeN+GtzrmClz4+tk88jcZ2mcf+3mP+RyD/I3HZx/7Tx/ffrFxyripXTDQC58h90HHMdVMBlmiVJgsVa9K7SOFhboU6jrD8642yn1Y9hYL4uMHzP7gWfa/9RSL6Zz0iw9of/Qq8Wfv4++suBNbPpbI0itrK9yxwkmw+FhRJkt9FolvH7EplbTvqH//K9zzyMM0PwzEs5qz10+ZbDwP4Sj6K0x0kcWRTEFhpxg3Q6WmMDNitcMGYGphETC7ys5V5dJjwu7jluKyoxdheWOXZdzQU1NW4BtDmAlGDUYtLhlsZdAKUlViaosWU+6ctdw+bfnKo3s8ftWwWQfuiKcXITlH54R+oXBF0UVPtSM8NEn8oCj5fWd4uhAqAx/HyGttx4/XLW9vCtrjRH9mYFlSnBXYU8EeR9LJQEvZt9A32Si7zfB9j/pACspEHEEiKbYZseR6rPXszA3337vH9XvhzqHyzlvHxH6ChIhzHo1rNJ6SaFEZPCdmmG8F8KiMM5sXxr8+A1wYDUG2K+03F3fO2QfG47cJg7/Ik37+6/yXcHwJ+55ucbx6Ec+LbP/POBvd8utkZZBMaO+AiQqTGJmHyP225ulyyqMtzK3DPnGV+g++yn2//w2qcob+/H3W//5FVj9/j83dNUcoH7jELRGSTzQIXuFMlc5aWim4Rw3TJpDevgt/FZnERPWD5ym/+xy9W/De//wC9s1Tng017nSHic6YI0xsQeVqrJth3JxZsUtXzpgXBhaWtNsjB4G9e0ruebhg/0nBXoU2lsyLS6zWc+5ozV4Byw6WC6GQgsqVGC+ohVgJWhek2hLKKbc3Gz44anjsyUt8/ZrQHUc0tRw5RzOz9BOFeYT9hKta7p0I36xLflganhNhkeCTFn7lA3+z6XnhLLA5gn5lYW2hKegbh10lOPOYkxZpNuAb1DdEv8mkP94PNuLQBJWraDRkLlZRYuqpauG++xc88uiUSa28/3LHh+8tMbpD8gEbG2JcknSJmnFmsycTZgkM/c9MOZLpWj4Vzl4ALOS1lO+YzzWk8etFJenfHMZ+XunyvNj023jV/zIM9EuNMxvm57zZIYG3W+NMgxQsTDBUGAoRLhWwh7LfwJPO8DVXc1BbwqU59nuPcN+ffYtyvkD/7j3af/sCm79/n5Ozho9Lyzsu8rEGQlHg2qxYHJJhLZZVabgrhisJrvnEvcvI1deOkLMXCQ3Iv/4B7vtPMYkG1beZvnHKZfU4F1m4gsoanDFgLcZVrNyEhpKWHGL2sUJVMJiMVKtASoWozGthUlYURcIYARegaJFihglDTcXmfDtNBF8btKo58gXvHCpPB3j2XlieKKepozFdbpnslDADt1AuF5GvloZvTxxfrWA3wJ2N8mIH/6lTfto5bq4M1ZFDW4NfC7Q2tynXAVl12HVD0bQY35Bigw8dIcRhBi7PtSaB6BN98jAt8oownr29gief3OHxx3doG88rL7/P3dsRo7uEviHFM4iniFmRNS9H5nTJFSExQ0g7FINGgMqFOU1VHWCUnxdKfvZnFws7X/T4z1moX3r8pvD5n/b4Ut7aMczYgvEvHAI4MThVKuxgmJJvxlAaw6LvuG6Ex6h4vHVcomN23xV2//X32P1X38dd3Wf5Fy8g/+51mp+9x/K05VbleLOIvJYallHZrSpMCETNkoPRCCrKxy4yl8A13/IMyrRJ2Fdvc7w5oXKRxb/+Y576g+9y2l/ixslP2F2ukL5FoqXTirWdM9PE0hvi2mam+rKia2C9TgT1hH3FfmJo9yE1gTZ1TG/OOLmtnNxtia5is7qB+mNimNB2BRIdDPj6UEVimQhlQZIF7x8XvPwR/Ml9ymMPOj4SuNN2nM0Msmtwc8OVqeG5quZ7peGpylIJvK+JX0b42ybwi8Zyq9tF1uBOIbZCXCXSaYJTD8ctulqT2obUN0hokdBjQkBCQqOFUKEpC/Z47zNiyWZCMVsIV+6d8fQzu1y/X7l9u+OVl95idWpJoUbDihSXZNKZDWhLbqUN4awImSNj5AmKZCGg0Wt+uo94HtTyBYb6RcbzRd7vtzWyrQvnokf/pzx+KxCCyq//IHtNgzOWKioVQkWiRphax8QZSrHses/9QfiKm/BQMcUtpsy//zR7/90fwD0HHP3NL/n4//MjqpeO2CxbbiK87YW3Q+IsKUZKQtuhKXCbluOB5rkesLjHJnCkGzY20avjWtiw80GH/V9/DvU+039xP3vfe4YgFQf/y6+49fYNwsmG066gLg8oDNBGojeIXVAotBFitPi6ZnNouPORcNd51rMT1n7JlcMHObzVQAtmrlhZE02bFanlXGs5GoUioDYQyhop97hxlnjxLfjONWX/XscDxYwbx4nWKDt7lp3FhIccfKcQniuUuTa8FT0/bdf8uIOXuwl3N3P8qkSOA6uzBlkn7Ili70b0xJOWHanZkHxDlxpIDSb2GB9wvUGDJSaHUpOkBDXU9ZRWOtQK914/4LmvX+axxxe07Yqf/+LnvPveR3Tt47BRSKOGZYPSDOggzR6TYSpHNIew25D2Qii7HVA+F07M1pBJV38d4fNFoe5vXLVf8Pf//3F8qXF+4ceSLPVuVLFJB2M1OCuUYims4X434cE+sAiR3b0J+9/5Gvwf/hk8fIXT19/mzX/7I/RXb9Ocwl0V3qDnrdRxhmXCPhO1tKzYYUFLx0cDieV1DLs4KmOhgnf1kDubT/i2nfB7xS7FO3c4+n/9R4q0z/4f/ZDL//IxOF1i/Rmn4ZijVcu8nLFjI5M+MrGGyXTCiZe8pgzQW7oVNDc9vT8iyIewPuTD0x7MHLu7z6QQWm3Br9DQoUmJCWIaog6TwHgwE2JZcNJG3r0R+eTsJlevXuHq1RnXisiqV3RRcGVmeVThIYErRJr+jJfXd/gPqzU/bSo2/VXYTOAY9CgSNy0sE8VRpLwb4NjTd56kFzRGyNA8DYrrwfiMfw7GgnGEECmqOZ2JmJ0pjz57hW9+e8bVezre/dU7/OVf/juOD3fAuyzhhwwysz73fiVciKqE8wHjCx5yKxz0xVC5/4KGQv7Jjy80zhv0WJRoLHOdchAmEANFplUmqUf9htIFFhXcby0Pesd9nXCNxD4Fj5gdiiuXuP31h7j1J9/koT/5Ic/uX0H/3Y+J/4//gYNX3+K11Smv2Qnv2gV344w+7oFGjlmz4RNWZs1Kn86X2ShJ7vKJ3OUmkUITdRPYESHWJT+Lzf+Puf/utvS40jvB346I1xx3ffpEJrwnAJIAiyyyilSxVCWVWmozvdb0fIX5SvMBZq3pnjVqrVapWlUsksUiCZIgQXhDmASQPq8/5nURseePeM+9NxOORUktBdbBPdfkMe+JHds9+3n4xDdcKodcvDMn+1+vs/buS5hv/THNv7xA+5UnGPy9cN9Pb3DpowNsl3ODllc55J34MfVoQGdKxvkqYz2NuTXgcCfjhpxhh9NgFJsJYSwMHZQD2PDPUklLCJF2aIhZUphmZEAG0A0YtB26MmN/y7O3Dq9dW/DEKLI6KXlhfYOnKs+ogwuVcHEAq1Z5s4VftBk/no9583BCsz+BOysMbmSM7wAzOIxKaD3BN8xdA2UDvknK0Z1Q6IRY5cSmw6lBDHSmw5qW0nRUdUVc/ZfQvMfmyhs8/yz89//iCZ55+iGuflTz736wzy9efJRq5xx5lwEfE7lGw3UiHUkGz4JeB7kJDImsEN06km2gWYRsDn4XpMaoYo4EnywJS9SBqVLrJQw+Yyd+XvHnWNXr5O+O+Ww/K289znePB6vTv+Ko3JTQSkkS8IvWl3vkGNNjOpveq4hQlmX//Mflrc9aX2icOUskbQptE/fYMSudQciNY1I4RqFG5yn5L82YkSkZS0FYX6F8+BwPPP0oK488wprJWPzmdT786x9w8OY7DDRjTw0HCLMYqLXrdYQDnshCLDPNqTUgIklAiCQQbkmiOaLKIgb2e1Uwi2EQhcILUgUGb77LWbXkl77P2bPn2Px6wW6zwVW9xf6tiIuw5oWVuqHLRxRZScxLcI5GhTr0z6uCGiUaoFWkMj0oRugKoR0lkXN1ph/sEDCQWUULSygz4sBCCW90YOaeRwfKpdwwsTkDD1lMzB5XLPxyt+O1dsCNWU63EFhYWHh801CHiO0s2cEmpvH4qkLnC3Q2g4WgbUfoIvPWY4LFmpwgjhCFlg5Rg7EFOhSseZ+N0zVPf+0Jvven57l0boUbHy346Q8/5tXf3KSpHDEGhIrEZjDr+5oNHMH2es2Ro3ytLwAtc7h71t0tkZO8B8oXSbGfXJ9vGl+AjT0KqT/zl59+5M+osxw9/3/haPkLjXNIP9qHxRuhlnSeRKSnU1WGGNajMOpgTWHdFoxcxqAcsbqyjr98iuzrD3PfV5/ADkboz1/m5o9+wf6vX+dwXnNdPDew7CgcqGcaaxrt8D1Z/0JzFhgi8fhD1wRucIBTTZNOGBK2RTgEdrxSihK6ADe2OfTvcubB06x89TmKi+fZ+vY6kn3E4tXb6E3PeGq5L2SsxZJdN2G/mLDrMuYIs5j0ecT3DDZZm4DfiyGmSlj3ZhTxWegPXwFrcZmQ2TQH2ZWGbpjBSGFkuLq2ymqEi3VkSxwPCQxFOTSRD6LyVmX49RzeXgzYPVTiVOAAzGwO/hCfLTC2ZHA4wncOXzm6SvCNQTsDoafdN6mW7qOh80kJjXyFJD1sISsYrP2Er7zwJH/+F5d46qkh9czwm5/N+ekPtvno3Q78kEiDkTnILsoBMEU4RKlSNZaq3zX/KVXTz1qf7zX/aY95799/Xnj9T33c/3LrC41zoAYfIkYTJVDnwPu+H6VKqfRY146NCBfsgHODEWUQimHJ1qXz+D96lOFzj5KvDPBv/46Df/93HPzmFewMGpvzmp9zS4bcUmFfG6baUGNpyWhw1OR0FMhSA+PEceUAq6mIj1gykyflu6hkOIqQEW2OtkJ92DD7ya95sI5sfPUbZPddYC0ruVCUTH9xleG04pIZU2nOioz42A7YE8NClXkMtD5CGzHqidEnbsiFgbbAWyEOAwz6AyQanBoKA66AbiB0Y4UVCyNgINj1FaJRJMLQK6smMMBTW2URI5/MYcfkHAbBzw1mCtkU4lQIs47QztG6xrU52nm0a8DX6RZbYoxHzktjz8MqCjZLKPYIGMtgY41nvl7x3X9+lmefGbE4MPz6ZxU///uKK29amtkahIDGAwIzhB1U9oEpmCnoHGhSxfao4HOMX73bi33ZaNaXgd7vXfca0ZfMcX6uQ/5vwxjvXV/M+N71cgwkNrboFM2gU6WLivHKUA0TjWxiOEvBlisZDDPOXTzH1pOPwNe/AptjFm9/RPjxL2lf+i1m7xZTGXJFBryHsC+WQ5SpdkwJLESoTUmnlhAzIhmGGj1RaBeVZdRIR9oXia4o6zVE02tvcCzEMWuE8N5NSnkTsjGrXy0pLpzlLA/QzcDs3aS9YwgUWC3ZjxbbCQFPF1tC8IlNTtM0P6FD2pzoC7o8ogM94giVLmK9x1nQkdCugK4CqwYzhEEJ91nPhdywXiTGj5koCwkcCFQmolkgjy3jtsDWGbJwuEpom4LYrBIqg69bWrNHtBFvI9F61CrYxMdroiEEj3WCMYBE1MxRN0fxbJ06xSNPneev/s0jPP7ghHph+PUvan78H3d465UZh3slhIj3d4jsIbKPyj6aZIyT1zRTkEWaqQsFd7Pbwd2Nf/j9PdNnTaOcvP9PNMzP/Hefl5P+t7G+uFrrE6w9GSeoFXAkCXSfOlklyhqOLdKs5lgsFy9c5OIzTzN55knqtQ0Ob9xg/1evYX/9Om5vn0jkE13wpgrX8wmHamlDx4LATFrmFhpjiLGAaLA42qPBXABBRPAkKpPQU49IBGMtQSxRBSWjioZDbzhsDBs47lzdo/ntO5y2BaeeyRidPcvlZ4XsRsbV2YJWMg6jJW8gk4ClQ3r0i9KmKQtxIAmalhhAe17WPIWzxgs2KDEL+JUEYmcL3KphcwSnc/i6n3N5NOB0XjC38E6MLNTTiKGSjHOl5fHygPWs4zYw7Rx1naNNiW8nxHZA6Cpqc7jkukaNoFYQm0D0johxFYYaayuMmeOKmuEksLbpePorp3jhj4Tnv/Y4d64teOXFbX72dxVvvjJj91abSiO2RdkHuYPKAVCDtig9H5A0SclIDUjGca55stjSe9FP8dR+3vqynqYe129+rzD63sPhxJL/Ng0TvpRUekmUK8cN5n4oReUYTzvEMcGSqVKI4cLZs6zffz92fZ3DD29x47ev0/32PYY39sgRbmL5HfBB4dgelsxr0JDGnis8tUAwiQjKEHB4ul6pGASMOeLSjZqIoNEkMuTEoaaA6LBS0ETLPDoWwfFwVmLmsPvBNvvxbYIfcN+TQ4YrE85fOMvuJ3do5hnBK7oIZHhK05C7ms5WeFsjWQQ7BPForgloID1IwxpM7rC5gCjdENr1AFsKm4a1VeXxIVzOhD+RjtVsQG3gkxj5yHu22w5nHKdcwVlXsL7eMdWGj+o57y0812dD9sQmmYPg6HxGFwroNW0SxbxBEEQUaxqyzOLEkznPcNiydSpw+cGSx57c4KmvrHD5gQV724Zf/OQDfvK323zwumF/p0CjYOwczB1MdpvY3iKNhfXPJel56KdOVE7MYx5NedwDl/tMA733+5NgePhcw/w8Y/s87yhfZqyf9/W/3vo9plLSlIHoiUumitFUrjYkmg7BImLwIdB6T7W3T6wrtt/5mP3X38dcP6DrHFNyXsXzO1dyc33Cthhi1+Ek9vI2Sjh6Qo+lJiNQSXf0ejDHGokqJsnz9XtiponUS0yBNSPaaGnFEd2Iq8Gx5S1uKjQfTHGLdxncyZlsPEjVRsLqmGmwHFaeZuGxeAZZy0ArajPDZ1US+7EZZNpD81LtJZVwM1yWjDMUET8JxI0IG55yzXBpJDydOx5xylfyktZkvBWFd33klQpuzh1ZG3k46/j62PBoPmK4lfNI7jjrFryVCVfzyLZRDj3MKqGxLlU9Q++4iFgLeYzktBTGMyoNWxsTLlwY8+BDGY8/tcqDj6xhbc31q2/y938t/PJnV3jvzYpqfyUJCUuDyg5RroFcB7Z7eytJw6qJhE10yRULx+x5J3GsSy96b3jL3fc/BRH9HKO7yzA/g67kszygfMbff6aBnzDk/9Kl2N9jfbFxmt5zkqT8lmz2RpN40bKjNKXmEGHkSg7ahvc++oTxfM5BXcGdgNnpaBbCNkOu4PgNGW8VjltZzrzryKQlNx0hRKL0MVpURNuej8/A0jiXzH7iWDZ6FEMQQ6WBEFpaHJ4BmJzMZpSmxOQT3p9ZGjvijGQU046dgxlvXn+LyfohTXmaA7vF7cKw03jmMRBiRyYVuVtgZQ5uAbkgMkBziy+U1oHXfpJf0phYGAt+LMQVxax5snHLxQIeySOPFmMediCDVfaj45MarlSGa9WAW4uSbr9hvmgxWUcYRZ44XXJ+fZXyoXVOrUWubhtu3hJu3VZ2bjcc7OyhPhC6gDQREyJOlVygkMjqEM6dWeHhh9Z4+OERZ8/CYKRUTcMvfnGdf//Xf8P7P3+cgz1PaEZYgTbuEMIOIreReIsYbqbwVTPSeENSxxE1EJNGqS5FbOXYe4o5qkhxr7c6nj5ZDu+fvPtZIWb/s6MfxxM/P/H7u/7+s+5/iUF/Fo78v9BKvU56Sc1Pry82TkevVZoQQOIVutgbaiQQaYi0ZGzTop0y0cj0+nWy7V3EWVamDldZ9rB8zJB3GfO+eK7ScjhLVb66njLoYuqfxn7OJUaIVR/oRiQW/eWzfX5zjDbR3jgMloijxbEgTbIMJcPbAU1jELOFbwvaRomqZBqZVZbZfE61vuBwJfJhN2PPDpjmQtM1dDpHdY6xC8hqsJrEYMdjGufxsUtkrtkABhDGAuuga4Z8LWNlBOeKwFMj+MZawaMD2BD4ZZ3x4X7kjZ2G3x3C7Tpj1mbEZsjVg5LZ4T6/aw54bLLPYxdWuHzfGvefNjx0QWktVArzA8veRwX1YsF0OqepKhwwHk5YnawyHq5w7nTJ6kTIHDR15MZ15bV/7PjVL37H66++y7Xra+TXhmgMCVSie0R2U44ZbqNxNxV8juKmQFKa7lITPVrQArTph6mTTLy1UBR52uy+BWt6dr/EFbTkDNKT4a8u798b1n5R4eakMcndP/9cL3vvY33W3/+XW8cAhC9eXwx8z6BnvsfFlP+bru8vki7zIR6TzIcGz7o6ht5TaovtMjpvCGTcouQKIz4iZ8dG2jCHbp8Emla80TQHicXE1NcM4vHS4EUxcekpFTRLIdRJyBgW6SdKocQzoGXQa6CMySVjRzaIOsDFSBEDGUpQC2HIvCvY7pTbtNyxwkEemZqaucyp8wXqGqw0BCNIKTCyuEmBW8nwLsG7GUNcAdbBrSorQ3g4h2fznOcGBQ8OU235qh7y17rOLW/ZrnN2pxBnBtsoXSdMK8OsW+f69oAbtxZ8+GHLxZUbnDtt2DyfMz5fMtjK2Zw4Xnh+A2TjaFsqqXAaewjh9h14733l4ysL3nlrh7ff2uajD2Zs31JYnAe9H7o5wgIjCwKHiOyRepl1/6B5f+m1L44FVFug6fd8wZGE4pGxndTM5ERb5fddX5QLfpZhnjSyzwuRP8trftZz3Hv/v876QuOMpGIHJJrELCZ+tJyU8XlgRvKgHcICZRo6RtEwIJKJR4GFydgWy8044LaOqD3k3oG0BDvFi8UbBbXkmvU1J0310Vwhg2y2xCrZPgJK7H6qS42WDKFAKFEGRIZEM6a1Y1TGeMkJOiGGAqInEqiBNclwsWDeGHYXDdfbjju2Zj+LzFxN4yp83kLhyTMQZ2knJbJSUKyWZBvQZT211QTYBNZS6Hg5j3wty/l2CU+O0jV9jZZX2x1+sLfKwb4lHkb0MKIzg28yupZj4E1dcmVWsnMw5cN6m7HbYzCeka012JXISr7BffFJnLMUpWAzjw8V1WLKfD6lqlp2d2Yc7DUc7Hbs7wbmU0tTD6AZQpOlcUsOgBkqu6mPySHJ8LQ/oVOkkgxzkTyp9C0lXcLdhE+piElfCDgR6h57xy/b/L9PDvpF33/B+lSl97++IX7W+mLPeUTtGDEa+yAkvZEU3AC230eqLFSZaWSongFJj3OadezbjpkGplFZdIaII6fAaUnlB3S2BdukjyzQi/X2c4E2yRoIiWU8hURZn//kJJxS0RvmgNTln6CyijdJAj4yoCWnC4Y2JsTkAsuBcaznjtw5mhDYq2bcji23jWEvj3SuRfMOikiWO4rcYfKMxdjiRhkydtgVaAvSaTX2MAmUpedcDk8Mcp4r4bEsDUp/2Ckv1xU/nc65ta20hx7mPaChBaqWxLVpYZ7DIVBBVU+QJmN2OEFvH+DjlI4KG4esdKO++9tBVGIX8R3EzqDe0NYW3wrapr6vFWFFPMQDmq6m1prALmLmKPuoHKLMQNs+p8nSNlny0soClSlpsFoguv5vTgjQ3lWtPWGsn95hn/Oze3/+eR7vnu8/lbp9Xk75GTno/4W55u+7vpzg6wQDmRIJ9BTAkmZ21cpRYNsFoYpKoUJOUiHZI7AnHQ0NrdREM0Ci4MgQxgmkp4DOCbQEloeAQTVPH35UImX/igxyF+9C0YMJl4Y5Rs0KalYJZg01Y0RGCBlRAx2eRqByjmku3MkT9UcgFYF2pOXQ0gMLIpQGijzxyTrB5jkMc/zA4YdghuCHoNkCBjWToefiUHhyVPD0WLhcCi7AJzX8tobfVsI7izF+W6ASWEg65eoW5gFmEQ40MRscSkIg1TnTRrDtCrYbY3wSPVKF7VhBAN91iV3Pg4kDHDmZBowfkHVTtJui/hB02stFVWTUWBpqCUQWJF3AKWl4epn7LbdIr0hNH85K/7lhuQtbe6IWcFfF9uj7L8PN6j1/80Wh8OcZ5u/jmU+su/7tPcb8X3F9MUJIQ19o0yPge0fSr7Qm6Y8EwhFNSSdCjeD6m8Gw6JQqBFrb0khFsHnyfdEhDBOaZ/mZGaWzDSGmHwQKCGnqIaQR/R4SsTTOHO3DWGGImBHIGGPGRDsBMyawglIClihTrA10WUabWxaFkjvBGEVjoKalygJ10SN+BibxCZU5mheoywl5BpMhrBR0Y0FWQMcdeVaxVtbcNwg8Mcl5emJ5uDTkwEcKb9bw0iF8uJgwawYUuxathK4yhFmEwwYOq/6r4ipBmhzf5Wjt0Nrha0NoDLY1ZF5QPaSTD9PFU5sqp8EQghJDpIsRugMIFZaGXCqcnYHOIEyTgYpnoZEU/xyCzBMfkPjEuqi9VkSMcCS5IBxXYZdFIE2Rzl0tlM/zjH/oujdP1M8wrM/7N1/mjf/bW18sZBTAhoDRfsSG/tJLYiMQBR8CliSo1WkyUnOiL2oBE9PAbXAVXZ4hmtH5DNMNELUIvi8w1ERbEW1IGy0W4EdAidKyREHEXrZPKHrjLIECkRI1A9QMwYxQMybqIDXt1SJ2l2g7pDD4UqlzAatECUkvxURioWgeoJDeazooC7Qc4vMBUuSwvgIrOXHVoqtgVgLjLHBfqTxdwNeGlodKGEjLtodX54GXFsLbiwG3phlhkcGOIAvBLcAeBNivkP0pdlpja0U6R9u1hJihIespeCLGe7I2kHeB4A8gfgTGIDaJAKMQPWjoUN8zrbsWpSFqhegcdIbYBmc7nBN04fvCXEWaOJmm1gmJRiQV4JbEz0Lqczqg5lhewZKil+WK93z9nFD0C9eXFJD+qcOfX/r3/214zOX64rBWj8W9VTRxCQmo0aQFEhMVZCTVDgKK79/gkj1hRZN/69SnUChrUdOhHqIW2M4lnGbM04iV7XOWAKhDdIhhSGDav6SlbF/quS2/IjmJ+y9HpUAlBymIUkBIwjzBeiTrMEVOLIWQCUGUuMyTjEIJy4dMDtoieYYUBb4okWEJqyOYGGRsYAzZxDDOhfOl4eEs3c7ScdAsuLZoeeUw8PIiZ68paBcGDoTuIKHe3FSxex12t8HsLXCLBuMlHYAdaeYwtokxr6nRNjHoSdeQx8CIPjUMyUiiBkJMg9DR9ux30qFaE7SC2BNAm45gIp1AMqwlY0ENMgezLPqYVK1Nktrp+2W9XoRE2tX2eecJL7U0hGUd7z/rpv8sI/pDHv+fUj3+v359cUHIGIKkfpQxGVZ6cUbVI8XwZVQKy2AmhT+Jjt8wNxnWOFrjia6nGJACzDq4ERpLXBgilBBz8GOUhqCOEEfACimvPEinN73EHul3wgrKKug66DqGNYxbAzfoKTg0sbSrYtQQs4yQCVhPkKpHk+mR0lfMgWGGKQtcMcAUA7QYEYZj/HgEEwejDDYUPeWJ61NOjRc8ndU8bw1PULASHXtNxjsz4Tf7wjuHkZ0mp6sljUNWoIsWrQKhaYhdAmAYFbyCeI9GxTcRGwQJEWkbpGugq8E3xNChCRGS0o5eck9P6JGIeHSpA8OyDNwmY8ITYyQq2GUeqXOITRITMppoV3qCrsSsMEex6ZDuVcO0z0tzBmQ6IZKj0ZD7SBY9LgKaJ4Lxo9grVXaT/SbKG9UEbnBm0e+lY5WBI+ISPbZzQftBB+0Z++IRJKWT1EE4sZM/9VXugryd/F2/RFIk34fmnzpr6M+mz+m+LO+Gfs/GaPp3lSE4MlscnzGf49G/2DitpfMxScbbHGuK1DwOS+7RHmwrkSjLF5Tk3qR3nTNTpkkJ09Mihqx3CQYYo3YrOai4BXEDjTsE5iBKIEOlIOAQewfRLIWoDJMxyiaGUyRppE2MWce6VWw+RnNDqw3Evi1Ah2GIz4SQS//OOyQm8EMullA42kxhWCDjCXk+xmYlYTAgjkfEjSGsGVgFNiDfiKytznhqMOM7Ak/FjNUODlvh3TrjpcOCl3eFa1OT7KIBZsAiIFVFrFu8T4D6RPdu0tmjHdJWULdknWKDYnxEfCQGRWNGp45IRRvupCJML7cnR5WBDiGwlD+4iztWe/m9GPoNd4cEevQJmUXW25DtQ1YP2qBSH+eWPWwPKVAEpxNKneAxhGjIfESix6ghHa7Js6q0HCOGesGro+q7xdrDfnMn9Jn2sduSbjPxV6UzyXA8dJ92YjLUiCaY8dG614p6nPiRVXxOOGtO/O4eSN/SSD/PQJcHSsShmJ4koO80kOFcmZgHv8Dhf2mfU41BjRCNJZoEUUvWvjzRlKWAzfJ5hF6MFgEtkJD19DF5ktmSkiTfPkbjBM0H+DhA1RG1IMpBoq5QB+Qp58kuAX3RQ0tggsgqMAYZYE2JzUpsVmDyjOBM2oQhZ7kJuswmA3ACJmI0YCTgLEhpE2t7FqDICYOMbiCJ3nIYiase1jysOdgSBmO4aB1PmjW+IRMe6Znttzv4sG15fRH5XZVzszHMKpeqsnOF/QDTijBr0MZD00DVQN31LZWul07owHf4vrhDiEiMaAxJ3l3pjcz1n5QBjffsk34TSl9R7VWlwfcFnnTzaaweczRpcux5EZ+SFdOlx17upiWZV49xbiUnaPJfKgbvYGEMC5NaYsFIUsLuvbz08E9dGmeqXOBlJf2NLH8nJ56Ho9cQNO1Q08uAmF4HNPnkz9I0ubuQFMOJiu7nWYhZAl08CfQSTjzu3f/mGA+zPETS4aXL1987r2iOzph+kujzU+EvNE6vsRfjsQQRojFp+sBYjDUYq/hQc1L3QpbFAk3VVUuGaNIcizGDOEoFG50Aq2A3aPNV1Kwn3RKdQNgDvzhqgovkqKxzNB1jLJiSaIZgJyBDJBtghxOMGybNEyVBZLzvr2NOLB1Y0wdiAScBsQFfQjeyhHEGeUQmOUwGdOOMdgQ69rDWYNcNdrWEM8KFwvKCM3xLJzylMAZuasvbvuLluuKNecsnVcfBoid8nlnMQUC2p+jBDNdOiD4SO1AvR7qzYBKm2aTDJSasFEdMdhLTptEU1jkZs6ycJj3MZEwppO36MPcEfyyh96jHymrRpse963mW9+/1tsDRYXByrxiHV5uM1jpCmVPlGU1RQJ4d4xTUJi+/jOd6THKqG5jEztAf/ksZyWPHtwxvNV2HGFn+d3wBlXupN+9e/XuI4YRRfo7ndH1l82S/9uh2Ir9e9uWXn9/S6gB00Z9f/fvILDhLtIZg0iFT/CHY2plv8V2k1YAUOcVwjJqiFxhLLQin6dRNoVUPhNZUgEEttlMkHXOkAHJEjAOiLfBmgJoJbv0+NLeQVSh7xG4XrQ4xTY3rEiFUFc+mE90oamMSmc0yyAowA2I2xhcriClAHbELxMYhsUzHlYAOBpjMUqIMNWCspy0jfmKIKw4ZFkgmFKMcs5rRrUK36mElYNegWPGMxgsmay1P2wnfNAOeb1OUe9PBO53h17XllZDxCVBpuryCYGLHxDdk7QJpF1T1KLU82khoIQRBl7mBCDiDHRWYmMJDDR6NhhhC2lgaES/YJkm2qypolxBTkgI9ST6lj8bS98uyHeKOhGo112Twy426PAR6b5EYFORoU8pJWN4S32y1x8MbsBlmtIJZX8fWC2JTg40pZ9buBKBFSEOHts9lLbR6YmNznGQe2Y6e2G8xAWVkeXCk9o00scfxnlz3FH/c0Wn4GV/7zyA/cQDdBT/Uu2+flXf2RM/iDNZqEufTiMtzNDM06plWCZ98alzwWesLjdNYy9AVnD5zjgcefBBVR117fBcJwaMacdmyt0XvMXvj7L2n9gpXojFFCVKibBLcFq3dYu7OEodbxMEKtrRY0yDtISwOkOkUM6+wLYT2aYIJ+KylKTt8GQhDiKVFc0c+HDEaJzUs06UDKy4iUjdkUcmMsD/oMEYZGiV3kVAEwjjCusOtDMizkgGGshR0FaZbENZqwlpDtupZnQinSuUZV/HVbMLXFTbncP0Afgv8TIRXY8n1OKBSwXgl94E8egYaKYjYTDG5YSJjNFhi1hKyllAM0LIkDmu07ZDY0kwP02aOHRoNqh6NQoyCaiQLllE3BFmyySVZPcWj2oFEnImIBFT6HFRjKiT1G1xVCZMT+6nfiCfDNzFKUWS9UQakz0977TlElaaAqgAVg5qcwWiVB+5/iNF4hf3VTYYWTLPAxhbbGyeaHilIRpBkoM08HBnnSXC49jQrSiRoIEpETSCKJ4pPauKSvOiwiuTtSQM6uU4a4BcgjwS0sP11WR4W5i5ZEqG3WYlpf/dZsmhq+AFk5SEuI5HTxYi1lrMXz7O+tcFgmB1pgX/W+lKEUBs8e/t73Lhxg48//oS6aolRe1nAntbw6P0tQ9qiN1LXJ70Roy1GAw6HmH2iaehcZC4ddt2iHrKwQuFK8phh/QD8iNBMCbWnnK6mdLeISGzw0uKziOYpeK98RjUPabiyUZjWyLzFNSmjykWI4wWSR5pcWZhI5SJVIeAysBaVnIExqIO2hEUJYSjIUCkHymYReTCHv8wsl6xjA7g5h1828OMIL4vhToTuUJHtiNvpyHdr7HRBM1/QLCqYVUhVI7euEzshBp+qtV1D9DWxa9CuQWKH0QbRnhs29hXamDiMVAOmizRVTzp2cmQrHsu6iwRkiXPVkHrKJ+oEoFCncLRXy0y53l1yj8kr9cN50MNPjg000hSGpkypDJKTjw4ZknPnxm32bt1iJIp0C6z3WEJfuBEiFm8sXhyKYPpoY6leJ3FpCslrJ5RaINAlBgrTRwLGs8TztlXE+nt3sn4qtzyOJpe55d3L2mVRZ1luWl6TZS7cv87+uhsNyTj7A0yIVHKQ5DxMovvJ85yNjTUODg+pvRJCYKXMPtP2vtA4C3EEC21Ts7uzzd7Na/g6idWQOcSBVnOO3X3vOWNOzw0JNk+oBF1WDQXMPiIN6tLF8rWFrCaUZ2gH6+SuII8l0igxKDE0hE7wXYp6GhG89PkNBoIF71I8vwS71Io2kS5EajGos9SzA2JWEQeaUp9OoZNkiTV4KyxGq1RZ8gJxAJSGce646OAxY3hShCe0w6jnus94qYMfeeWlDnZbIcyBOx1ys4LdOX5vymI6w9cLWNSp8NMFim1BO4gaiL4j+pYj+evQQqyTXF9sQev0M+3bIgllgGqg6b3gEiKi+L4KG1IRIy4FhHqg+omQ8Ohz87bfaP311JMbsE/4wr0K1f7ETdMBlyWwB8bRjWZM3YjDqzfh9m3mRiDUWG37nDf2AXIKa1l+nif2qYS+nKLL0DFVo70mo4QGbEiGmXCLgBIChE/JFHBin957f/mEdxuvWR4Mmob7I+6eawPLw8v0rw0JCZLah8E+diciEsiGJbPpeWLbkVmhcJ9vgl8c1orQ1S02REpjyDJL8El92JgOQQmuOw4PNPaH8fJUcSlRj7E3Ts9S31NZgJ9DnAMthJRrOGPJrSUrLQwc3ahE2wXTvM+znUHynKIsMAMwpSD94EQMQoxKp0JkdAQi8JkgeV/pzQIMFR1roqksDeQF5A4zcDQTCBskqfd1WJk47h8IT+fKV3LDI5lC7Lgd4NWm4afe8Fqw7NVC2APudLAXMIeKnQb8vMEvKpjXiS29AXxGNzvsWyMxAQhClwwwNL0htr1AbQ2hgrg0zOXcZEClJZgZd0HmdKl72edhtv/dssgT49HGOZoQiceMBqhBNFVO6XuQCYi5DPt6Q5fl555CykAkekM6sQ02eEbBM4yeafTkYrCiOJWeN8EQBIKJeBE606dHYZb2TkwFL3NklEui6IjQQohE/Il+74m807r+4D657jHG6O/+3adaIpoIhJdFKRyJNq2PDliy6y6JrZfP36F9mA1gykli6+g8eI82HaFqia3HBsiyz4ctfaFxZkERsRQIxndo26BdnSp7oU/EJdwdEmibPOdymkEyMBYxBmSA4kATQN3JGs5uUFcWNMP4goilywSdgFmFkGXUcYjuV+nNhVSgkKJkkBcUTnAmXeu2hs5LL82hUBZQZGgW6GwkhhLNDAwVSsVkipMehG8M1SASNkmGuQLjAh4sha9OLF8dwCMGJgIfMeaVwykvN453ZIXbHfjbwO2I7CvsNfjZjFDP0KZO7ZE69j1OA50haxZE36EhJOP0vfKznvBI7az3lnUyyh5EIEc9zJrIHsehJ6Qq69IgfR+6nagySp9znvScIQFN6DefwaW52qOv0teMA0rAa6r8ilP6+hPiO8QLSIZYodRA0fM/QYNG04fUXV9RjkTtvZxIOsgRjM7Sxo/HminLjid9CSmnB1yQRv8Uj8auN5L0SlVOeraTqy9gxXh3zinLL9o7kDSQ35d1MHgsBtPr6i1R3tJfm5hGPwjiCXKidFQ3GOMwClEFE5O4tNNIppApd9vPifXFwPeYQooMsDFio8fo8QkV1R9HPss3qJ4ToD9sDJhoQQoiOYExsAGcBc4gnCaPZ4EtCCOiOloL3QDYEHQdYmGhWsB0nnqBbkgxHDFyQh7BtMkJt/tp/x4JJmeaCLmygNqAFiPIhzAAUyp5HigyJc8NYehYrAY4p7AG6yN4KIdnCuErTrjPKgWevdjwIkNe9YZ3o2U3QlcJsgfFdiA/DHTTlrquUN+Hqa2HheIWBjd3SGcpuoroG3wMdL4jhC7x4R6FiiF5URIPrdEGQ4PQ9rmeJ9LQUp+49ksPecIYlZRzor2nXBaFTrQbzHHxxKE4jclENZ6Y1AzL7QcE4rJoZECMIBKw2vY12ISXxnREk95LMCEVt6Tt91DoIaHLPmBKlwY9AZhKOl+T2NEyrNW+zpHuy9F/ELFH9yXKCZPsXeJRyJq+VwW9S35wmYMeWSnepr9LYAfIovS0OcsOrPZ+M+IJeNHEUinHwaN4PQqPZan+HhN5gdXEGNmzvnxqfTHwXVPzw2oib04NX+0J+ZZvkLtSEzAQ+76Vun52JCPqkMA6LZsEzgIXUS4BF3CcI7KeCKBzIQ5AV0HOQn4/DDcNbqHMdlq6eUs5GLA2MQwEwhzaA6h2oTIQK9BKISRFu8wFjEl9v3owJJTuyDhNHjGDABMlbihsRcxqxdpYeGzg+JpzPJMLFy1kBLZ1zgdhzs+qgvcWwkGwdAFkCm4vUO52uFmNXyygnUNcQFVjpx2DaaCYWaSJaDQMuwUaatrgaUNH6zu6GAi6bHUEVJveS7YYWiwdpr8JkcCJ0EzpT6Xl55BCR5EEXl82LoSUlqDHOiOxsIkHWIVcDbkaMhWy2A8uAF7TK6Gv1YblUwhHj6qEvlobCdbjbaCzAWwgOkFDi2ib3oPERIwvYMQQJRWhVmKGAkEVr5J8de/FwtFEcRopFPr2nQrH2ih9xfRej3nE+pcu0EmeoiOVMz2yy/R7lxj8jRoyDIVYSjVHU1eqkU59D1RN4IsgiiZcIUjidjbLsUuOQ3WrvdF+Zm78exjn8oUfwxCld+baH0bLD3j5KTmQkoQeTwjyHGFAQWCdjjNEzhI4B1xAuQ9vTuPcJtEUhJEhTkBXFNYi9lRk8oBl45JwsR2wdxCYzWuKYshoYtAo7O/A9Hpk7jzexjSsXAl4yFUpVXExINETB452WKAD0IHSDRUdRcxaQE8H3GbFeLDgocLwfFbyvLM8YBP/6/XY8Gac8ko9583dTfanpHGqCO4QzKFHDxf4WZXC2XaB8QvyecV4v2NyECkqi48RL4E1vyCGmsZ76tBR+446etreQ8V+UicN5i0NcnlL1VLR2E+NHG85oIdOnujBydIwObFxT2xO43rPAKUKRRRKTRXuTKWfQxCa/rPX/hXpsr6gkkJLCX17T+kstP0tuQpSKyh4VDxGIk7AiWANabIG5VR0BNIMUitKo9CI0ko80ciJRwWiFKpbEuxwWVcNR62MexLJuwx0+fVYm2VprMu7aWzOIRQYRmIYxhNgRF2yKQlNH+xGTM8gyZG3/tRBsbSfL7G9LzbOHjiYrv8SdJ5K3qkH1UPHVKDn7kFHCCMSK0HenzFDhC1SKHseOAPmNDHbQrMROnTELBLHwIYiGwG72jJc82xtFlw4V/CnWcm8zThsOzpXoIUw9/DJTWVmW6Ys0km3yBJUrrWIV2wIZP1wsptAGPa3UWLJ61YEswH5VmCy4nlgGPnqIOPrufCoCANVbrWe39HwUlfxyqJjb1dhJmAcTsHOIMxrqsUcFgtCtcDUNWVTszpr2DxoWZkrWSd0pqOxllOxIYaaKngWvmMeOubqqQg0RDye0FdFVXzySn2OlVoZKdOReJxCnETtHOdoaRfdm32IHG/KTIVMoVAYqjLSo7ScXLX3tUnGKOsN1JM6Vhr7AG9ZXJKE4gpi8EZSIXg5Q9j/jdU0PzQUoUT6XZIIwi+EdPRUGk/IJvW+2YCXJGOVXnp/MMUeiMES/L68Tsvr8umvcuL+3Wlf/52AjYaMJDkyQVghIcGG/W6nN8oGSw393FRquVS6rKF7lmelon0oz1G/9IsM9EtoStKFjUZQsURxxH4TqEiPPFlWsAbpZcsKohNERkBOS5lgeWzh5SyeM2A3oFiFUYEOAn48hUGGWc1w60K+1TE4VbG5Frg06rg8MHy1KGDDUuGY9h/aXoQBAWlrrJ+zlwX8PMdPIVSG1juspqa9ixlxVdFBJA4ExgITYAVkXRitw/lC+epqwddKx8MuZxiEnSbybu15tY280eR8shA4MDAzWGMYKzSzSLuo0WaRxrmqlsGiY23h2Zp5Ti06VppAroqKJaiwoS2BwFw9h+o51I4cT0ZgQSLYbvAECURJbZN4VLVMm3xZAFmuY4+YNtnxBjzOt5Z5mcEgkpjzxyGSqzJUGEdlBZhoKmYXpDwpiGEGDLRncVJhT4U2SK/FkkokS04n7WHox4GxQhRMFAZqmAhM1DAxjiGOUjKcGh4IiW9hRuQQ5YBIP00KSMKmkvZkH1NzRJfa/1UknPCG95ZhlzHgsWmInMCFyzL4h2EwFHBUJdlAWe2/L5P90mGoUGbALvRaPelxOzluPC1fqoHEAS4QjWLNHxjWqpUEZhZDMJYoWb81lvx7NlVjKUFGIKsYWcfoGsgYoaCxIyq3hphNsGdQu4kUowQyX4uwskCGM8xaxnhrxOpGwdoarG8azp2Dy2vChSJwOQaK/sRc9Bdj38DpoefsKeUTybg2NuzNLTuHysEcGg8L4xBjsGLwQ5+GqYsMBhZGYMcwXhEujS2PS8ZzpeOB3GJFuSqed9rIK97ydjVhZzGCaYQDkJmwImkj70076qaCroGuw3aBQa2sVspaq6yGyKp2rOIZBiWP4CTSSGRulJFEBqLkGnHEoyZ98p4JCROWhZ6jKmsK8owu6UI+yyjTVl3K6i3ri0bAmGPj3Gg9aZRAWRVYA9ZEmQgMEZxAq55DhRHa9/QS3PAQpZX+GTQjxgyNDokOEzOIDkIfYUXLQB0rwIYaNtSyHnNWTcZIMxyGR5nRAAdE9ojcQSmJPTQ+ARBnqjS6NP5jY1vCBFJj514UwslDKkGXj/ynxN5Z9iYrgqiy4YUByirKlsCWRjYEVlEGKFbA9/txH2GokTyC9INiFXAgmpxb/xLUJHofb8AbTdTQf4hxpj4URJNIm6Msh3OWIIMikegwAFkFWQfZRNjAMAYGhNEGjE6hbgPyU7hiDTc22E3Fnpmim55s07N2OuPs6SFnVkecGlrODpQL48i5VWEzh0tqk4/WZX0MpqHjQduxt16wPRxy7ZThWp3xwQI+aOB6gDsmARe8Atk+uC6VofMcmztWSuG+ofBUnvOsDnjIeEparmrNq1F5OTje6wbcrgqaA7AHEXtYYacdE+2YSMZiWjOrGzSkcSgXlKKD0guFgnORgXRs+pYLXWAtKodWqYxwaITcCDYsiy2k7W8ji+AR6QEGZlnwOHHTAKFeRmGfMtL0fz3x/74BYJLXN2mHcorIgDQ5uwlsGmXDwJoII0nGOWsbDkgYgSUAMGAwGBaaylQBR1BLCI4sOGyw5N7RBgcxUmjGBGUNwxZwBssmGesxZ6I5hVgeZ9pvdrhDZEBM3luSlzGidKEDMQlV1GNYTf/uBKU1XRpN+9Q6jjKCWV40Oa7kHhdqcSqc9hlDhDVRTgFnjHJKlDWUgSiZpOswU2VbI1kPvk81g1T5nont88/09LE3zOQ5k2f9bHzQ7yM7LyTDXBaUlxMEJKaBZJxjkDGGVYTVZKisYhhiRheI6+eQbBU3GDIaQ7kGxTkhP7+CPVNz/ol1ts4NOHfKcToTtvoM9VSEdY0MQ8OKy/B1SyY+xQ7RM5hXrLbKOTemWSnZ3TJcUTjlYaLJQzUB9pq+imtD2uTG4QyMHGxlysUcHjTwSCw4ZWBKw0dUvNx6flUX3F5k6GGB3IF8T5Gmxc1aipiTG4tZdAn541O4Z/qKnhVB+rDFiTLWwLm242wX+CS3zESRGIhG6KzQBKHG0JpIbQwSYp+n9JvK3F1YEI1I7DfhvTWHI4OMR74lPYbBnEBXiSSjHALrCJsGThthywrr1jCyggX22tB7UJgSezJNQ9PvC8HQ9mGsRIONFhcsRtMuNCgFlhLb8yMKK1g2cGzgWFXHQB3nBCqEUtOcZiQNTzdW6ZzQoEy7Fo0uNQb6TWp6ryooRjrikUKA3PXlqKK9VDO4d1xMUoxhVViXjBJYF2HLKKdEOIWyYZShKJmkzm0ZIxoSleshnjGJLi0CIuZ4LnQZifdOL0jqhHye6/ziVgpAJ2ir2C6hO7TPMSMQdAFdBXKIyw9ST4Eq9T+xCBnFYpNMTxPKjiJrKYsMMXPCwU0ubB7ylcmUr60J96+OWXcX6PwGe03OnsJ7JdTOELXk/7ktZHnOnRVPiwcLYW1CNS84rBz7h4lNUofwRAFfBzwdH8/v8EZ3h4/CjJ+srDHza6yEIYPCkQ9bLnKDvwrX+V9aYSgX+LfuPv7fDPhlCwc7oHfAHgj+AHQK7ULJdz2zOdw0JQtj8NMxdj/DHC4o2z1GzQFZM0OrGlsFTonhARu5qPuc2VQevW+T2SWPv7KNu7LDfftKESy72vAuu3wQAtthxBBlNwZmsaE7Li/0uYwSbSCUHQTIO0ehGbYfP25wtFZQq6hJDfdASAMmChtB2PApZFwpd3iitnyTgvtDhgsZ7cYG7ZMX6C6sUc1q7MtXOHezIWvm7NLQouxnsC9KrYFOAh0BDQJZTjCrtM0IV5dJq5QZhgMqOnb6zZiJYcsYzmWWZwrHxdzy1088xzNmxNaVa5zav4l1+2ybGR0dEizriwETs0JlVtklYy80aN/3ndmKIBUiMwbBU8YcZcRUxoRylFKwhecCNc4fcIcF1WqNDhU6GM4sF6uShxhxnoxnuEpDOhNPZQPOZjnnXcmFlTUmp7ZoyoxPDvfYuXOLUHsyb9HZPi1QjwbcoEEbh/P0rBMBayyDmDHUjDIY7BdY4JcY59L1n4CHoRyDpiF1oX1fKNKEeFnOEJqOttpGNceZIc2hYxEOMau3ufDIjAcenfDsc+d59r7TdEG4eUu4fjvyyV7Fza5mPmpxZ2H1dMbvBhvEkdAyJEiLAg2G20H5ZF7x0bTjVuOxZcHWJOOhjZwL44zN0XmesGM2Fwdsl5Y7i4y8hdLDCMclu8GqNUxpuVNlXDkM7FpLfSi028Buhx4GmFk4zNCZJon3heLNAm/H+EWNX9Ro3RDahraq6KoGCeCMRaPSdR6sYWNrg/LhB/jWn1/izjsfcusnrzN99ROa2YwcYYsNDmmZ0rEKRwW4KUrlFC+pR5mFVOjqgiDeJMAIqYpaI/jlCFfwCTRkhAzLkMgEWBfLSiYUIXIplJyWDKdDaltQbkxYffIyq994iuLhy1Szmn946f9FEp5PDItLDgOHJVddAtfo9TvukhxYdiaXvdfUeTdpKBuhU/qWCfzVv/5zxp1w+PJrHL4ZWNtXHm4trq24UlXcaSoKO8S6BIiYCxxoP9MZwKrFigNN5J+dJJggXZdSDmBBTC0Pm6HBwCJQemXVG0osfMy6hAAAZMVJREFUTZ/v7tqc1eC5n4wzTY5kOYuzY5qvPcr4+a8yDJb7fvYqTANXdneIAs4NaGygE8U0sa+ULwcI7g1v5POc5pcbZ/r3PczpCE+ZSuUJw6lAGr5WEk1GYh/wBOlQWrS+hRGLG53FMMRJx5lzBX/8nQ2+/SeneeSU8NEt4aO34L13a67tzrnjD9jP9/CnWjbjKpdWLvJvNxJrkPUQF4mJr3MltxQ+NJ73woxr8wUsLGv7jof2x3xlc5VH1w2nyhXuKyY0otyKHaqCtZGBNWzKGEPOmzrl6izy+qLhVjdksQvxTpti4lmXWAzmAvNAmM1hHvFSEF1GmC1gnm6hW6Bti4kpB0IhdIG6a1k4T9V6qD3m7HlOj9ZYb0tuNo4begVqz7kyp6pn3JpdQxiARFo8tYu0NtFvSAAb06BuF2wvYyGApcHgl+RkAFFSK8ALQ/UUeMbAVmbZcI6hgYtNy5oZ0myM2N9a4+zjDzD6xrMUjzyI1B3yxkdomyqo+8AUQydp0zlNVXtPxEgC0y03YpRlfSD2ft8iNoKxyTg0DTEsEKYK0yhsiofnn2Tl/jVGa4bVX75FeW2fc03NOT/lbZlzYIRD2+G1YyfWtCbR3hTeMKIkamQhntbYhHKIHc5Hhj1C+JBINAYjJadqYSMq4xjICRhR2tyz7zy35h0P5xs8GkdY39Cd22D4F19l+J2vYM+eI759g1jV5LsL8nZOxDHLlKmNtAqDKNSaikZ/yPoS41wCen0q50tIUulHRWEFk9SMdQkXWtJfSATT4ayS2Y5CDhhPPPc9PeKb/3KLF75vKErDa28qL/7gNlfedty6lUa52lVDu+mQQSRWA0btmH/QlsFUMbdr/O4ckw0wWwWzsePOyojrYrmNQzvHdgO3D5Qb9SG3q4xnN0dcXjE8aZWHiyINBve5RQAONed39YDfNZ43Z8L+DPR2GvuyB4rMA7FqCFWdyJ+nVTJWW6Vh73kNiwoWFeprRAMSIl0bWFSehY/URGah5aPrt3HScurHJePHHiF/7kk2ypzFxDF/6wOyg4pzvqXBcY2WynkK01FI2vaJsSQQNBIUspBjNWVbnlS4O+oexMDQWFajMJZArh0lDesYLvic8yKMAzzEmNY5mjMj1r7xKKt//HWGDzwIBzUHv3qV1/72H2nrjl2J3LTKoQqdCKLmuE5llu2JHlDfD2v33Ib9XhGiGKKkemaLUKkyDbDvlaFE3A9/xMVTQ+SpBzlT/gmZGbP4+zcJB3fYChkblLwVFnwSK+Z0DGLFKEIjBYUZUcaMgKPRfoTMplGuQX8oVZhUPEYoguO0Oi4AQ1IRqXUtPm8prfIYOStSsF8a3LnTnP8X32DrX30Ls5px860P2fnJy9Rvv0s93WaHml1yDn3HQiMBSxZA7MmI8+T6VJHgn2qcyxnBlDgf9dVOVrms4xhA3IctxiQJhUwZ2IJBaRivLXjoyZxv/eUKX/+uw+TKi/8452d/t82190bsbQ+pOkNYiYRBkhCQhUd3x+g1oa72kdst8VpDnAmMDMxzwimDH1vqWBLyNK4UjbIXYWEDTaip60PuWPhjN2Azz7BZCica4FaAa7Xyap3zrim52gntIcg+5AdCdijYBWjV0dYLumZBWARYgMkabGixTXvE/SO+I4Saum1ZNJ6ijcxVqK0wV+XWYSqjNP/HT3mwigy+8xzDbz7O+ihwoHPCS29zql2wmg8J7R57rmPHdIxjZOCFLih1jCyIdCRhCxVDK6CSpBrzLpGGWpSRpa8sejKJjFTZAi6qcrnzrKlyKl9l/9QQ99SDnP32s0wevkS7P2X3F69x7R9/ze7HtzmMyk0CN62yH6GNCcidBrc0sQaiHFGEaOgNcwlG16MDxaskBW9SZ2qPyG0Up8r4lbd4b6OkLAJnHn+a038+ZjotaBevM7l+hyJCE6f4pqayNbUGipgxAzprEum3z8iip9WOoC2GSN7PngYSeAQvrGnGOhljknaAimdgoCSyGYW/Mpd4v53y/qWC+/6H51n5q+9QrK0xffVd9v/+VbZffJvZzR0ONHLTZlwXZe4DzqcSWZJ1Ws7GnjTKeyZk/jDjXBriiVJzP26UOGyXZegUUh1VcG2GzS1ZbsiwrK1kPPZkyTf/bJWvftuiJvKzH93iB3/d8sEbE7pqTNNldLkQYkfsHFqPYCbMbo9T/H5tSrftCXsGZIzWZY+famHFYHPLgBwfDZ2FOFKqoeXq0DAs5lS247ut5ZQ1WJcQJVUIHC4is1ng/U74UHJqD1KBmStuZsjnQr5ISte2bhM1Za2EBmxoMaHDtB2m64i+D+nblq5t8EFpo1JhmAU4JFD4QN7B+jvXuDF5hZWtksnXH2H9uQehm7G9mFG/8h6hajlPxwGeSjwlkaW+ke1zOEHwUtJaIdj0OQ07WI3KuIewSQiojYgL5AJrmnHWG84H5T5VNjCwPuL+bz7D+PvPM37wArO9fe784g3u/Ohl5u9dI3bCdmy5lkdumshBiLTR4FEaoRdviD3tyXLz9cwEvZiRaiRoxKummVxgEYXDqOygjFQhwoXdPfZ/8QriLNaOOXX6AVa+/zyhGNG++Brte29zf2sJfYFlIIYDcexqxi2UPYkgJSUZLhq0VQweZzytjUST8GrD6NjCMaBHF4lQGMOaGE4Hx0WEcxTsXhgS/vIrrP6bb9Oe3uDOr99n8YPfor/6CHN9xm7b8XEBH5vILR9ogQLbo5sC8VMm9uUe8/c0zhMIjCUtvy4nCTiGUOFIWNoBmBLJcrIioygdkxwefHjEH/3xJl9/YUhWTHnxpev88P/Y492X70OrNerW0BkhmJbY1dCGpA5UF4SDnCoqp1pHPXd0cUQ3GhKCSzAho4gXipEwKAytga4gIYBWhVDmdCbQipC3SSSwk0CMEbpI2RikhoPGMzf97l+AWwhaKVJF7DzA3BMqj3QxFRfqCK5BtEbaJgEQfEMMLTF0RPUEY+gE5ho40EhGh4sRF4Wqarj+7ofsrRrOuoatxy+z9dT9lM2cPVOz8+b7nN6L+BBwIXBNlB0DUwEJQhZ6o5eCaJUuU2yElU45Q2C1DycrDdR4rFXWnOFsNJyPsBUiG0XG6dGY+bOXOfu9bzB46lGm+zvcfPltbr34OvV7N/DTmkNruRE910zktkYaTQFrR6RWaI0msrSwDGuXw9QJ3bQ01KCBJPFqqAXmCc/BECg10X5+3C7IrhnsP7zFHV3DfAfWL11i8C+eRSdKLvucu1Lh5h6jHStYdqVgIJagSogdlZYYMkqNOPUEyZjbyCwXjBHGjeG05GyqpQBEIpko6wgXNOcycN5Y9lYdF7/1HOf/+Xcwm6fYfuMjFn/3Evz8Hbi2x7xuuY3nY6t8pB3TkOL7gKGSyLyf/b8Xy/yfzzgRTnIDHSMy4/Hv6LlkGYEZYGyOLRxZabhw2fLVb4147hurrK61/ObVq/z4P7zBB69v4g/X0c4QoxAtxKw74rRN0gIF2oBEZfXOiAzDYjDBly5hoxqFLKnA20wwWSLeK8agY8XlyikbOCeWizLEOGXfwD6BEAOjaCiMY90Kg9imQ6EyUAmhhrYJuKYlWzSYmScsBO8Nqk1iWshb1CRaEfXpFmOLjw0tngbbo5EjQ3oCSA0QlZs2UB5OWbzyLqae4/b32Xz2QVZeeASTVyzsjNFLuzw8iwyjUpiIyVLfNIsJabtACEeSiJFMldUYWCNBzEJfWXcxMAxwHst9UTgdAgMBuzkgu/8sZ/75txg8cpnqcMb1l97kzotv0r13GzvzTAl8EmquO+GGiez1mY5Be0bcNIVxjNDRI5xtqlMkJFMqCCUqyw6DUWWhS0S2UqSSIq/S8kQrnPvoEPFvsN9Z5C9h8vBF5M8eZaB7+L9dcPajgF905KoU/dRoSyAPkRt4ohjWFIZYWnWoQmsMqLIWDKecYxghJzDQjg0C56NwyeScyzJWRiW3v3KZZ/70a2Sn72f62/e59Te/Yvri24RPdpjXFZ9IwzUb2VZlEZQQk73MCRyaSFsIroXjiZiTxvmfnHMm/UuNDo05qgVE00/pLKdRSsRM0DgGHWPcBLE5JjOM14Y8+rWSZ75j2TynfPTBlJ/8xxu88VJHc7hGJjk7e4HBxGJNDws0OeIsxqXRId8AtWDuDJBB4tANDcdMESWggjewcODGynglkpeBjeh5xEeecI5LmuMzz4c28kkMeK/c54X7CsNF4Pwi8Lumxs8HsADtBN95mqYiaxpcFekWGZ1XcLvQJQXRYDtib5iElqgNUVs0dEg0RyRwJQZHIEpH3UWcVNwXM87cOqA+mLF/cEAeF4z/9AnGLzzIqXjI/OZVJlcOyeeJv7YzinOWuQheEtB6IZZSFe+F3AfWNOVPy+GqVWtxUVlvA/cDDyCsCtiRIzy6Bd96lLUXnqG5s8PVX73C1Z+/SvP+TcxuQ+09N2m5Qss1k7GNMFd6zvLj2f9lAWo58aK994zaG6dJ2GA0QfmlJ/iqMcxJUx55b+g7Rc6ks5xrYfzJDu3PXmU7a1mYZ1h/+CL5nz9NXBxQZhkbb3eEdg7qerqWwGnrCCYwD561ACMsLTkhOGyXYQisEhi5SCmRgXpOt4FLAe4zGZu2YLAyIt63if5Pf0R2+SK8v43731+m/Nlb1Lf32fMtH0jDh7blppUUwEVLJoYKYUrLwinkjthFzEmG677FFGNfRP2CZsqXGGealYvBEUJBDAXaw+iQNL8mMiErtmjrNYhj8uE6nXpcYXjosft45o83OP+E4fbOgr/9j3d46WeRavcBZoeWPNuDmBPCBKwho8BIhmhMHZkmJhBEgLmOUotgCLZQNFe0BFNCHEA9AlaUchJZySoudjOeVvgqYx6iYF2Fm5nlNfG864W2gr1a2VyDy6vw0O2WN+c1N2cWnRU9YrmlaRZkTUNsoF3kpDlVD20kSEtoW4JPIW0/TAo0BHw/mbCcl/d0VMxjRVm3eDtFasuYgpVKqN7+hJtZw4abs/WNhzn1jSfxd7YJP36L9s1PONc2hE5ZEcuBtRwCNgqNzSCm6ZtUiDAIgSiCU8OZYsim7zjTtlzCcs6UuFWHf3idze89y5l/9R3irYZrL/6WD3/ya+or28S9BfOu4TYNH6PclIxr2nEQHBptj0STI3ovFESXXAqJ/099S+dr1ARwinZpzE37/7ckIGiGMCMhiBYETLnCG21gXTrK4Bl8cEBb3WExv03zr/6IzWcfZ/P//s8I62cYzYCPrlGESGTGAE8xLFiI4U4DExWK6AhYHMp6q1inFFmLo2JiI2dC4BGxPGYHnMoG6PqY5uGzuBceZe2FJ+muVoQf/prDH73KYOeAafTsEbju4GOr3NIOHwwmGIIqc5TW2R6Tp8TgUzp4dIYpMQZC6FuP8jmT1l9unIllL23InDR5EhKeUUHE4twGGicQx+DWUC2xrubU2TUeevwc9z02pnGR19494LU3pty8tkJoNyBGjJkzWPNEcsSWGCNYSSxlqgEJHTGCV8veOEPHEPpZTJN3kFuktMQR6CrYdWU4abnPLXihrfhGzHlcDZMWYqf8w6jhZSe8F3Jab+hquP9QeXwNvjLMeD8esl9Nqbq8jzr6PmWMECwxFgl7ZSJHuu4akHjcckpS0R1qPR4BNT2cL+BIULzGRE4ZYT8GbtHhxDCZ1mRvzPBaUeJZ+eaTnPt//BumRcGOb1m/sks+rxm0VRq3yoaU5RhtlazzDPrSQ2WEfasEGxlHw1rV8KgWPMiIVQGGhvLR82z9xXOs/vGTxCJj+nc/Z/elt2jfu0V7ULMIgdvAR1iumMjHGezbjKAJjndM89WHaj21bQptUxi7LBrq0VzGklITltXbTpS6hzpKGsGm6EZ8aFsy9aj3PKUdmzcq9CXHbJRzPRPOP/91+O6zjPZB/v1LuBs36bTBsWB+uMPZ0TqZLYiS+vAFOUMsGgO0HS4zDAaOSTPlQR95QgecF8Hmju78Kdb/5I/Y/Bd/gu7c5uov3+CTn/+KuHMDFyN7BOYojVgq49gjJKilJErWEOMxhVNiJTiypU+tLxHs/eKplH7GO0HxCtK8pibULoriiDpEuwJkQj7YwGYZxQo8+OhZvvK1FVa2Vvjgk1v8/Fcf8rsrBzTxFJm1aIjM65psIESzwOQ5thRcIYhL6l/04jngma9fTiDQVUWGHbZosEMLkwImFjOC8SByOet4zgT+yFqesTlj67jj4WOv/KqqeZmMG01OPBQ4VC4fRC4YwzObK1y5Mef9dspHbYGGcZoTDAbfKaGLeK9prACfcLQ2ICHx1xA9xLYHanQ9ea4QrKXxqRBlTIcaTysB33XcwTOn4rZJvbZze4H85StMu8Bg0ZH9j99j8s+/yeXBgFv/4deUb95idT7mdIxc9y1OW8hK8i718UDYJxBtxDnLfd7woCiPaMFWVuJXLM2Da4y+/1VWv/dNwHP1B79m/je/ZP/D68ybfQ6I3ET4yMCVAq5lll1NrRMbDOJTuh81md0xrclylG25En3lUmtlSaWZ8pFAJODF0Ihg+9npDsXNHTdNR50lIjHpOh7XivWPr8HfdiwWLQdmhYuPP0PxfzvFzjzQ/vBFzswE10WuNXe4FDsmJmPPKrVYcjUMgusPgUjmhfJwwRMu5yHJGMeAm2QMn3mQ8Z9/G/2j51C16P/2ErdfeYl3bnzMwjXENlBRsU+g8okFY57BdpYoTXKgbFONJKuVrtOEbjf3GuGyD/zF60s8Zwuy5BE1vfeEozhZLaEScDkmW6EsJpgycursgIefPMelhwt2d+GXv6h5/a1D5n6GHRW0C6HTCXQZkpdQCDKoYTyAkUFLITohWCGaBtwMVjVVOVYiOmoIhUdGkWLNMh4LoyxyVlueCZGvk/GI5GRkfGCFn0vHK9rwq8Oaa42hXSjM4Nqh57eLKQ+J8t0nN3huY40X7XU+8VNCk0FjoHaE2iBtAF+nPl5f6cUExHUY73s6S58IjVgyDYKKxYuhlYCTFpEOLx0H1FjgFh23QmBmc3JTsLaIHLxylf3dPdZnh5z/X/4V6//y+zSLyE3/G+yNKafmgbIyDENgnDJ1MjwNnizCKMJKzLgcHY9kQ1bV0K3l8PQ5tr7/DGf+9FlwGbP/80W2/+2Pya9MsU1LB9wm8i6Rdx1cLx37uaNtlWIBWSO92UErAVUlJ5D3xSB/cuPJya+9RETvPZcHflRLJ0JlIlEjrSrWJ5dwYIQPhw7nlVkND3nP1o19hj94h+nNQPU/W4pvPs/m//ynxFFk+xe/Ibu64AyrjFrDGM/IWaZ5IgsbaqSMaVJkpMImhq/4AZvWMJsY9CuXcX/1TfTbL1Dvzfnd/+9vuPS//ZSq3aV2ygfDwM1uvyf9csw0cqiBymsSvzJQm3QNCnpi2CA09xrlEjfwe6wvMc4GMQ4xARGDHMXHPe3T8jlkgLMDVAwmi1y4vMkjT2wxXM1587fwxmuOO9slnhkxbCeuW/s4mDUoJsTBAlYb/KqgkxItLJ01tC5LfKh5DpMFjB2sCowdOlLsECaTwKmBctFFHgOe1oInZEIhkSsoPwP+1kR+k0fqmMGhgQMwFXRz5cPdht+GKc9e2ODBUxPuX8957eqC6aJEFznMC3SRoW2TaBtjC9qlSrF4xHmM94jv+pExnzCG0vUFOk9Ug9dAazqM1kQ6rtIxKhIHwMJ3SJiT0wE599WOtZvC7k/e4fz5B+Bbz3LmW1+jNZZr//hbwrs32Aw5G5JhqhkZ2oeFsA5kMWMSMtY9lOLxq0OKJy9y6s++xsp3nsE74eqPXuLg3/+C0et73A6RXWAHx3UiHxnPJ1bZEUvQ1LqRNsVPqYMZ+jGoJCN4cuslMq4EQkjBa2LqMwm/RBruir3vDD1MId13knqzQzW4JuMgV14dwY2BcGsOX6sij28vWHnxE/YP/h1xPmPzv/sepzb/kjoPTH+4YHjbURzMGXllLRrmDjobyFykiAmcseLhATlFrlOYrLP+nWeQP3sWHr1Ic+MqN37yW+783c8ZzA84bGbMmLOrM67R0LoCzXNmPrDXRXxIIJXgkj14SQWfpYEeDa4t9TLvWl/sPb/EOKvkOY+0KOCI8brn8kQGZHkJYuhixyiHi/evc/5yRuV3eP+Dkk8+zqiqMdF3iY3ODsnHJUEyvK2QIYQxMIFupMQcopUEjSvXkcEIXZ0mufe1AawMYFxSjiKbw8ADLvCkg6eznPuNYyhwzRh+o/DLCG8Goalj4hY6sLgdKGowrXBnLrzuF7x5bYevP77J5bNjNt6+Q1XX2IOCOC3wVZ54R3UPwiH4CG1AxGPziO08JiQOVWh677k0zjROFQmE2BA0edePC2UkLZOgrGkat7qDkNERVdBaWbs6493/74+4uDtj+N3nufhnf8rK+ga3fvwS1ZsfI7sLzoV4NMuYUWJJBF02WkJpWAwtkycvsvbd5xk/8yTdAq798CXe/Hc/JH/jOg+YEa/4q+zQchu46mAXYREioU65o2nAqjlqoaV2SUo0U3EnUUOfpEk5HpjooZy6DG1jP0ruSFQiSxyRpyOQGU8RAq0qdZXEfXcsdKKUpmMtWDbbhurNN9j/32vcumXl61/l4l9+l2E24qOf/ZaVd26QzSpqArUPBNOB0V7bRyhEaESJkzNMvvN15F9/D3nkHNObV7n69z/l5o9/g1y7w5ulcqeuqKhwCIaMbafsu5bWmSQh0cAwQtdC3Ys/BzH4kKhYjqrXf8D6cs8pA+RI2KY3zuWMmhqMKzEuR1XIc8fKesn5+zZZ2bBc3/6QK9dy9g4nqK6CXwWvmCLHFjnRHEIR0VEJgwGhzJM+RQZkkgifR0PcsMSvXcdNBui6Q9fATYTh0LKVGy6L8LBGLimUXrntDa8E+KXCuwrT2qIzC/OIOYiMtgODylFFYd5lfNIpb36yw1ce2+T8mXXWilvs1g12bvDzAm0cMQYIBxC2oRtBG7A2Im3ABo8LqXVA7KX6+hM0lcsN2it9RW2R2DF1HYedp42GoSlR6+gUpkG5oZ6m3ePSwZjB2wuwGQ/lQ9zzT7Hy9FOYPOfK2HH48u94OBgW9RyispqVTIJBQ6TNMw7OTBg9dz8rLzzJ8JGHkEbRX7xN/OHrTN7bp/KG903DK0XDvm+ZGcOetdQhOf6sS7VVq2aJo2GJk7VAZ5TWRDqUMipZXPbF+78SOIKAsiSFTnmf9IiiJbmkJ2DUY0LFlJiq0Z1QLixD62g19S9fl5ZgDxjFDvvBB1z///x7sp0Fg298i/U/+TZ7gwnrxduM371KvX+btp1iXETyQBt8eubxmMP1CSt/8g3sn3wDOX+K8PFtml+/SfPrd9GPr1E3h7xsIuIijU99O8ksC2k59A0tFquGkiSHC9BEUNcbqEZClM8xzN8PwvclxtmxlISTE275mM7BYJ1LFV1jGQ4HrG2M2dxaIS8sO/s32D0QfLyMkzW6dgxdjuSRNuxhhnOGmyWL3EOWo7afInCx704LMjS4EbhxwI4NjCBMBDeGQZ6i3FNYtmJk6FvaRrjaOd4MjndFuB2EOBXYS/AwO4+Uh0oxh0qEkFn2MHyyO2PhhbU1x8hB4T3SAI3Fepfk6aUGnaaScQBCxMSAxGPaUDQZJyYSdFmtO1bmSoTOgagt0SjB5rRRmPuOIgaG6lhgiNRs2RVKDM21XW7+6CW2pjOK559gdP85VrNnUCes//BjrK9pm5ZVY7HqIFTYIqc+t87wm08zeOJ+tPEsXv2A+d+/yvCNm1z2I96xgV92n3DzTMbBwlP1UxSxn2cvTpQDj4ee+tBsCdUzaV5UgxwR/h9vvhN/20tAmL4De0y1kgpEaApvCxp2CLRYnBRMfMFWyFiz0OUNH0lFJzMeFcP9TY197T1uhYyzg3XKrzzDme99i+IwJ99pcfMDQnOA1Qhi0NBRYVgMLFvPP8nqX3yTcP9Fbnx4lenPfgu/fpPsox2GdctMa25EzyQrqbxnl45aM8RaCIr6kBQgThBMp2GP/i1b0891/2Fe80uN07AJ3ZioA0ImiZi5yyGWOM0RU4Ju0oVL6PhhDtw2XL7B+mP3UzWn2H3vOZrbU7RxieRo0EFuiOIo3AalWyVYi4wVXQspryx9ohLJNeWWGwXtao47tYbZKskmymox537T8dXO8XwoeQzHIGTcaizvCbwcDW964U4jVHPQww6mnvFuhjvIab2l0kDVBJgOEX+Jj+sZH297Tp1tuLxec11K9qOhzhq6uI36XaQdYOr7Cd0hIKhEWm1pqOhsQ4w1yhzReZ+b0ksbGCKeRmo6mSNSY0OOiFAD2+IJEvt6a8rHxlh2MyELkdHulK72dB1kIWKfvcSpyxcYjVc4aNbY/j9/xAON4GwAv+DKluHmMyuc++9eYPK1xzG3duh+9jL+pbeIH99mR2veM4bfWuUdu8HBvKPqMhbRU8dAE04eJR2ddEcol4gSevLkJKelIBxRegZxIEn2cdBE2jYS1BCNpcVg4zGbkSNVfSOK9lKDu+uWemZYbQyrmtQGDiTRco5iyRYZhXXcaFtGjXJpZhm/dptF+SNmckD2zccIf/kQ+6uG2U/Avho4PW8wapiGlo9PD5HvPc2Fv/gm2eY6+sonrP7D6wxfuUJz85BrswWvSMUn6xmL6QYLFQ6p2aXlICixieSkvm6USKUtLSkuIGpSGyDxT9Qm1Q7NpyxLTtz+YOOcILFANUdtH8qKoJphdIChpPMFwawh2VmqfA93qmZ4uqWeK9NbFwizXUTnqftSeFCDkmHzIaYQOgc6DDBooOygaJCsg4HAGuhWSdgQ3MaIfMOxVkQuivLVKHxTDU9GYS0Kd4LhQy+87gxvAFcDzOYQ9zWpSVeB7E6J1I46KLUPxEYxiwLpHPtd4M5+w8XLns2xUlhLIBUTgq2gqzCdQ7ohxP10YU0i4fJ4ogk9A0SHUoO2vRRcdlTLDNKkQXGpyWMBxtBpZKFKRqKJHKE97aLlZtdgA6ypoh1U71/HG0+ee/KNx1l78BKzfz5kfOMmg9c+RJuKODS0z1yE7z/N8NtfQacNzavv4F98FX33IzQEDo1wpVOuhZyKAV2bYIAhtnhtSfMkfZ4sy7wwHO2LY5+4LAr2RJ3LCi19O6GnJA0qIDaNs7H0xMeb8ygmE5j3M5hLhZYOOFTtPbplpBl1LDjoLDt4TpMxPKiZvvUu7WbLeGXOyhPfxv3JE5TikQ78Ox/RthWHp0/j/uhBVv7ijykfvEh4b5vqJ6+gv3iP/PYBla/Zjp4rBK6EiIYJtXYcIswxVNrgfey1aSGIJqb3/roocPSNSSCNz1//icaZ4HsnHkzs0aVdyo6HGBJhlBW0KFgZr5BnBV0jVIuaoB6bC06FGPtikhPiQGhWoBsLFDYVnjSAcUhpkDWLniqRUyWyIRQjz4YLPKjwpOY8K4bLmcUYw40Iv1PlTRv4nRiueTiooJ2C7kdkNyLzSJwHYmPoPMROoLVJ6auDVmsWM8EyYFCWZBn9jGoqtWi0aGiT7uUyHNOlutcyt9RjHGU/rXOSYCvlAtrvRoWYeEwDQozp4E3KIglncye0lCqcJ0ODEg5mtFc6qlXDYMUxcBnjx84z/ld/ipIzffd99PI6p777Aqe+/hhF41m8+Ary01dx799CDzu8cYn6xUcKHxlr0wvjCscAvOPNI/0eWFJq0r/0JU3t0Z/q8b/5sj312d+nr3YqhCjMbOqKDmNiMM1D4rdFlQVdP/Uh7KB48XQHNea1j4ldoNIzjC89yqknHiJWkUYjOzs3kCfOcvH732D88KPItW0Of/EK+6+8im7v4oPnjmm55QI+OHRW4/VY2aUj4lG8pu8TC/2JhsW9b3P5Wf8nrC+F76VT8phQekmJKWIQm/hKnbOpRuQMo+GY3BXMWmibOdF02DwJuCQNEyGUil8BXYMwAimlzzczJJcENtjKMGcy7BmDnSgrUnOfZDwTMr6uGQ9bYWSEbRN5h8hvTeDVTLniHbcboZ0B+8COkt2Jifi5aXtAgUuyd17AJ/RQ19VUU8hYZTQoyV3swQWCaJ7wxaFCaeDIi5zII08UPu4erj1Zres/TQEJiXgrSj/SrpKGj5F+FtAwKAsO6pZp8HgyChX8QU3z7lUOfU29WDD+3reYvPAkUYU7Z0fkD57lwjdfQAew/dNf0vzoZQavf0y+vUBxNKFkFqCOKRizBJQiHYxH8namf82JtDkVcHr5g35JpGc6SO/n+Fe/z9i/3HN/mahBWRvmFtpM6FSwHlZCz0wrUBnlQDyrIixU2BMlmki58Gx8sMdkO3DL/Izumw2DC49gvv4YZiD429dYffJ+Jo89Ars1/scv0/7jr5EPrxKicmCFG9qxJwFnRqzGkhtEWpKB9rwe6b5qGllbfpjHmfjx0s812997/R5TKamckVoqGUmu3GHEYozFSYbNLNFExECRDTGSE3wghgXBRGLmyDw4kybT64Eyn2ga6xqC5GDypGGiq464JchpQ7ZlyFdgaJX7uzlPmRHPx5wnvDBSuOUir0nDL7XlVVE+kpyDVvsCEOm2C7InyFSIcYoPBbEZJz3PlC5hQ0JD+Tpg1VK6Amc7NLZosCTuVQvB9/xIsbezwJFGx1HB7KSBLssoJz/A9P8jSb2e2rFDWGDJJPWQoyiuGBPrKTM8MwKbJmcQFbc9o1nMqaZzFnlG+Z3vwnefwz57P8X6Kj6zVC/+goP/80VWf3eb8azBkNMyYEHJIjYsiMylZSZJJ/OoRdY3ZtKo9jHm54QJYUjUpFGVGJLRHHME9esItnZvxvVlm3XZSxesGvKY4H2dgM+gdopEYSsKbZtmSSfGMQnCuRmUdeTOi29SVwuqbweK557D/NULbM6fYn00QXdmxP/4a5q/f4nhlU8omznzTNgLEGJ67KEdQlFwpVrQkarRTW+cbV93PzbGZbRwfLWOfvef5ji/xDjV9HxNkjaoZkCWgAnOYWyGWZI2O8VlFmcLjOaJqkNqvBN87nCmF3RxATsMyMijoywhAjOQAcQNB2eAcyCnlGKibFjYUOXbreeZgePZzDFBuKqe32jFT6Xl16J8gqVpJYEMdoA7JAruQ4ufWXThsaECH5JYri+ARNrggMwpOYl+XzRl8ho7YuBYlS+G3kv6PsTvlbPw/aDxElea4r7jn/Wu5Si2TYN3jiV/u6ERh7EOMRYTDQOv6MyTB0sEdmgpg+d0VFajsOENBx8f8MlPX+H2ZJ3yf/hLht9+ltwrt/7dD9j7m59x+oNd1g87nDfUlFSMWZicKkJFy0EubA9AZ8vXsbzZozxQpReuIokHLTVIljzuSyMN9KjOL9lPx+szQmCBuU3GaRphVYVx/3fzDJqBJtqbTmm6JKYUFXJy1lRSX1Ec57b32X39Xa5PCsYPbTF57lvk+f3IjQp98QMO/uZF1q5u9xowLdN2jsExYcgqJXUwiLN4kxgeuh6q6Jef15JHa/keTogkLd/hiVjpD15fbpyksFYlAylBCpBkoBiHYgjqcS6SF0mXU4NgrGCzBoocb1zCZqpgCoExuCH4AWgBFBBXgdPAOeCUkq3CRhZ4OHou+cC/1AkXGDERuJ4rL1PzD7T8gsD16BLcbt8gtyG/ocidJAkYDyOxSsUf6iYBCLoeG4sgvfh2mVnGpcMKhFp7IWdFvYe2SSx2S4k96e/3RrrUMTkiPTviz7HcPWi7/D1YlozlJkH8nKWxllwyIpYMhdaTkQYBWgIz8UxQRkHIMMQmUh/uUy8WDJwFTdQhftHQHVZo1ULn8REaIi0cAQCS6rhJo7oCqoZoUr63FH0IxqBHOiuxP2aOwQhHPLEsm0V35493e817Q9nPseRcoIWxpglhBWY2QeTUpoKZ8YHoEw1IFIuLQrakqe2U0kaknjOd7tE0h+A8gyKx4FLNmR4eMmwX5Hns33vEEin6A9MTWfiW6Ja9akhiTb0clJFUc9F0HZax/fJ6kK7u8hP/g9eXk0ovW1VYlKyPQd1SXw9jBjREnE3kyIuF0jWQZRmDMWQjS+xKWpKzyXKBoaUYGYoi6XA2Y+AUyTC3FFmBSeF5ODY87yNPevgaExoPHzvl57Lgh9LwosAtnxEWBvYM5o6hvKmUtyHsKGHqiQsPVQtVaqeo1zTaFUqIRaL3GKQB7fEgNderacTPE4GVhBrtZkldmkTcpS6RR4n4XhvEHxtt38dMX+HTYV3vVREiFm8s0VqcsWRYBtEyDJYCZWRKTEy0zROXs+aUjI4ggWAFOb/K+Ptf5aFvPEvcrbh59be4vOD++y5w4V//GXf+ww+oPrhJfqfC1oGSNj1+T3x8ujOMFxlvkehEVNNmjSRB29iPBaZo3fRsxRzJ6Z70CrL8/6ck7Zbh8knDvff+ib/pJAlwoxwCIYOYKwOjbNSRs23krBdyoyyylKPHuPRUgpqC/fs2yJ/e4PEXvka+dZ7D313nxvQDzHCdyTP3sfXf/xH7P32R4tatRAwQNyAoCy/Moqclo6YjM4m2cynbtxyV5CSJWjh5FfRT7/AP73L+PtSYR5cxFfuRHDWWaARjM7KipIqRjgbxNdP5kEULg0IYrShubKHJiQYqF+lKoSgdrlcJbEfAKgkUugIMYWJa7m8rngwdX1XhKXFkzvExwi9izQ+k4iVruE2ObxzsC2wbzLajPAA7i8RFQKquZ8ZroGrRGUj0CAs0DCAUPeBJcVqTZyVWwS8yQm0xwSFao/EA4iKJn6rgpQO1qHqWQrGJUWfJ2bvMRaW/n8Lakx9jQGitoctStFdEYdUbznnDJkmjxI4GhCqmIWoPaz5iMmV2umRx/zr6rceY/E//DCaX4d+9SPvT1xg/8gD8mz8l+9ffJ7M1hz9+mfK3VxncnDHyC9bp2KDjFB2uM8Qu413r78owT/r6o82oaXDcHZUIjwtEy+D95G75rO7epz3pPYasMAypwr0AYqlQRpwIm7VyX61cVmUDi4kxcUVhsKGXKHQ55eYqe89PGPzZVxg88jWoDO5//Qfef+ctzL/4Dit/8W2GG9+jOivc+A8/IbtyhyI42qZj7muaLKJZpFnMych77qYkveBIwLXIcjBreRjdnYH+51pfapzWgs0NNs+QrEwbWpLKU2IyyyjHYxqTujqHM+XgUNk8JWyeLxjcGWDaAZIpwXfEUUa+Ygkx4NbAjwKsedjIMBPDlvM8FD1fM4ZvFkOeNRlnVfjZVHnLtPxj1vFaXnJTM7qZTbnlLeCWorda5nsRnXbovIOZJ5s16LxBG0/eDOiqQ9RNIRuDJtkU44WNtZJBHpgdKB+/v8/h7ggNILRga7At+KTrnJpnDT7kGJshJhJik9gPzHIGNvX6lvnIXWUhVSoaghUoBzjrKCuY+IZ1GrZ6uffZfI9T62NWK+VMY9jIHc2k4+DhVeTPn2D9n71AtnoGfvhL5D++yKXXriJX9xPP2nceZ+tPv8XtrGBqX6J+5QrFjX1cs2CFlgdYZXU04cr8kFKULvqEdsJjDP//9t7kS7LjOvP8XTN7z6eYMiJyRGIeCIAgAJIASIqSiC6yRKml6uo63Zve9aL/kP4zet2L2lS3dNTSqZZUVDXnGQQBYgYSQCKHyIzZ5zeY2e2FvefhkcTASae0gAF+wtPD3eMNdu1eu/e734exgohpuIhjmghR8M0ClUy0nZit6EOiASFE1GiSW2/0WIiJ5GvZa7a1zqQFY8FEelEpEWLXJpkzl0jLzka4Sy2XsaybjLkWdINyT3eVu7orxFBx8+5VOp9/kO1//ySDy+eQq8fwo3foff9Vntq7wa3hf+Y1f8Rjf/GnbP6Hr5N3B9z+2x8wef0GfS/cneX4OKeMBfedW0WLyNF8lkAX1jIrC6ZaNQFRcx7LpcbUicxyQer3GZ+gz7l8LS1qchBHNKlNDWvAOLwBzZSYOyaV5Wgk+LMw2MrJz2QwkoSTxRBzZeIUkyvVmhLXPVzO6G4Il7qBz6A8GS2fE8cDkjzPdQq+P9jgbXJ+hXCjNtRzg+wL+Q7ku6AHkXJYUc09WhbIvKI7K7HTmjit8LUnq7fBDAhxTqxmGPG4LGVte13P9sYZZkNPPe0Qqw7iYwqBmSEUGE3qWr4JY4UmlG3D2QbquNhbLk3fNE50S1rFL5VU7u8hbCCcBS6QYOGoYVWTVO0oBlY7K3QfvET+lYfQrzyG7Q4o/uYFDv/pB/R+8gpblUA9w//fh8yPDun/xVc5+8zT7K1kHK7D+MU36F6fszZSpmHGbKaMiaw2KtOp6NPqRwpqUkmHqAnqIpAIrCJJTbrN5sMJ2bg5mTu0O7E2rF1+tG9K6tspwWJIPTsm7du90qsjWxWs14IjsbzX0XPe5lyMwvZ8zpxIvG8b8/wTuK8/Re/sWfK3dwnffhH93kvYazfYjnPygz12TeDV8YTHvvl1Vh5/lPxWoCxfI165xfp0gtUK9RU3DqasdNeo6oKKSBkiffXUgLOW2gg+KA3xCq1w4Clpwd/TQD+RGlMQrGgK3yQlgcQq6oToHGpTQEdXMJ0OowJ2j6FQWD+/ytb5Lv0o1Lkiedps17bGrDv0TIDNQOeM4Xw38hjwTDR83mTcb4Rc4IDI+7HiR1a45uFK5ShnAoeQ3xZ6N8HuRapRIE49WpQwLmBc4EYVdlpTlDXeB7SyONfBMaMKMyQvcLaHyydsbTs2N9e59lbBfOjQGjQWoLMExYseUd9gKH1zbZpMLclQdcGqE5rXTlLsrSJ0u1/JG34h9ZGuDfRE6FlhEIRNhHUCXRU2vDLo5wxXAmsPnCV7/mmyLz7IxAjlj99m/e9epfvuLnnpk3ebjrDFHH50haPOgNU/f4b1xx9EBjXH64Hj771EeG+OLR15HckDbErKw5g7gtNWJNmzlJ0USSuzcAK8WJSRpLG95bD2xBCleU1Ovb48hDnJ63a9sOKVzRjZjsqKGIIVZgRWgud+ucBj2SqxmjJZd6w88yDrf/IU9tH7yH51SP2Dq8xfeA+u7bNWezrAeijIXrzJzSgc5ptsPvI4nWeeJSv6UP+K/vvXcEWEWGDDlON6TqDC46lipEtNRZI+jDEBERqd92apPVmOT/K3v/v4DRjfU84p3RsHJkNdSMwlLkNd1lDWWuhaJmVg5yAyrpWVrRUuXnJsz2uGwVP3c+YSkyDshoPVFNqeyQvutcpno+MJLPepYaDCgUbeUHjZC68p7BdQjCWBC/YFdwvMLuiREiYendcpIzsq6YxKskmNFpE6pmZeX8XEjm4sYiJiC9RE1jbH3P/AGfpdx433C0ZHSl1VhDhNBhpTt4nREiuLusppT0nbedE+D81+xJ7ylonPIvGmEgxSRrpWGYghs0IWDX2NXCByNwPmswlsb9F54n6yz38G89RnkMwxfeFNxv/1ZTbfGLMShbK/wqGf4mqlE3LCzWP2v/MSIyq2n3+UM3ffhf2jJymLEVO5Srju2TiEJ+wKpR7Ti61AraYEpCTYXUAb/OuSwS3I3cySYeoia3mSFJJFiN/8c/GeZV/TvpLyToo1sBLhfIxsa2QNpW8hc0JfhUuhw10BNg2Mz63jn7mPzW9+ke7d55le2yX84E38z96huDVC1DCXjEwjOV3czFK8fcTB3/+Ywddzuo8+jn3mUXDgV8C8U7F1OCVjnR0qnIBDQFNNNaCo+kYt6HTZicXPhXLQkh/97ccnGKdv8gGxEVq1aXVugUKZQ7MMMgeZoHlGEQ27x56jqWN9PefCBcOl0ZwwnDPvBnzuCE4wG2AGge2+8ECmPOEMj6vlbmPIg7Bfw5sefqHwUnDcBsoJcChwAGYf2IdwDGEU8dOQNEiKGjupyWceUyq1T1nR1JUAQZN4rjgDdgr5IRfuFh76zDlCCe+/UzA89Pi6JoQhGgrwBgkGQ4mVWWOQ8cQwFy11J0AEbWqcJwGdIMbQKNcyEEcWBVsHujGyZiN9ETpG6IWkAXlP7vggTMjuPcP2N59h5ZF7KD1MX/+A+odvIb/aYVQY5lIz1MhUFWPTDiKr5vgdT/29l1ihZPBHD7G2fR79ky+Tr5zj5rdeZ3V/yJPS40Y8phtTeN1SW8bQ6LOSPESQRs18yUiTDbalI5Cm3EAjynsC+EuLkixC4WWDbD1q+oxD6SGsRWVDYQNlFeijrCNcNo5HeqsM5jVlN5B94UG2/vIZ+p+9D7k9pPzeLwk/v0q9s8dkXlAJ7KJYIutZh9W8gzuqyN+8xXH+c9YEeo89hP3TRwgbgdLN4NU5WzPHttwmE8itw2Cp6qT60qpfzzWBR9oluaX6Th22IdVDfw/3+Yme04giEhEjiLGItan+7hRxDrIMOnmS5HMWa3OOp4H9kXLhYmR7E+4+H5lRsm8Ddb9PGHRwa4aVnuXBXHgyE540hvskI7fCXhW5UsEvA7wULG+HHmWlMFTYVey+ITsU5Bj8OFJPYpJIKANmHrHzSKwSeXFN0xgewDZ1PLSDtQaTzemvH3L/o2e5eFfO7i3l6jsVo6Oa2h8T9QgNZUITRQdUGDMkZVya/kRZBh+ctEYpLadOs/eURknaGMRaBnWSNM8VBkE5o5FtIYW0Aj0R4opn7exZVr/6OBtffJQ6eA5//iblj94gf2UHe1zylvXUVUXhPTPjmDsQp5xxNWdV6N84QH74Ot5XZF96mK2HHqe7dhflrlJde4Xzx4HzNjFE2Sb4TgYpqQDPooqLF9BWBlJa/9DqSQdOFeZbA1zsRZuQl2UDPXm0e9OVJmpaMQlX21fDBspWFM564R5j2e46Qgb+sbMMvvEk3afvpxwN8T9+Bf32K4yuHzOZl4x9wUQCEwcljvXMcMFEBrOajTLn6NW3KPKK1VXP2mMP4J57gI7xVNYwef0Dtsc7iKZmDW8tYzEUqsRG31RUmCsLgHtolpy0PJ/ONvyLGKcQEdHGg9rGQLUxUAvOQTdP/YtiMJ0Bs0rYPS45LgsGgx73XEwnNi8q6pUuZsORd4XL3YzPOvi8wEMEVtRzSOQdo7wshl9pxpU647B0SVTjwGN3obvnyIYGnQjlJOKnNXFeY6oARcDXIfVSikNxSG0xtTQ0GxZDhrFCZ1Bw1/3Co0/2MHnFm6/XXH+/ZjSsqf2QEI9SIiQkgmuRCmNGIJucxtA2RrnsPe9AA4mQpN6bRweli9DDsAFciJH7VLnfCJcyR94z7F+2XPq3n6f//FNEIqOX3ub4+78ivHiN1ZszxnXJL+2INenQp0MRlf0QKTJh4jw21KwFg3l/l9IHgmTY1W16l+7lvq9+hfHtwOhn73B+7ujGgGhsDFFbHsGG/lKZayIdDJoSRdoI1kZJQIWTRux2mEYiZMl7ngpi7xjNCxsYepJw010TGXhhW5V7onAxGjYt+DyQPXyJ/l98ge5zjxDmBUff/jnVt16m/9Yex9WUXQ1MI0ycZZp1mJKz4ysOyhl3q6fjC8LxiPHrE8b9OV5HbH3mMTa+8hSx0+cDUS699B6+mlH4ioHmrAEjkpREsA6v4H3TKwpEYrN46emT+h3HJ1JjJg+RsmlpYlmMSZ5UrQFrMd2cpOULrtunjp6D0ZCD8ZgLg20uba8wND32j6cUHcjWDX0HD3YtjwNPCGyEiiOdcSWWvBCEl+jzbnTsz0mc/dMSjjzdfcNgXzHjnHJO6jSZ1lDWxLomlr5potPUbVFbOmVOdy6YbkCsw5o+zglntmqeeKrDo4+vc3i0y4s/P2JvxzCb1IR8CjqG2GlgTA6RGmMmwAYniZAI0qbOlzzlwnM2t0mSF2kN1BJxOHJrWRPDxRh5WJVHsGz2ekzu7qDPP0T3f3iKcqPD7NsvMPzHl3Gv7CC3J0zKmmtS8D5j7tVtunSS1wuB0sNhmOPmY1Y1w04NtqrxkmE058yffJ71p55gzVhe4pizP6rIaRoAVBKGVJRKEnQtoHhNTPwGiNESSbojrX+I0pRXdDndIycnv3wh2r1p40UX+1KBnhH61tKxQkdhLSoXgnIfhosYXCcnPniW1X//LN3/7inKsmD+3ZeY/cPPCK/dwJSBI8Yc4JlKl7H0mLucYCyhCvgww1JQTvbZtIo7mlK9MGVvPEEngc1nvoT7o89hVh0PHL5PeM8zmx1TC6w6y0oQZsZQG0MZlXlz7m3OtrEaWsz0v1izdcJLJsk2tULbnBKtwVjBGEt0gs0c0QiIYnODN4bhvOZwXHL+TM3ZFcNovcu1WDE1kdgNnHHCfVa4G+USEIPnsJpwJcx4VR1vR8PRvAvHFvaB6GEScGPFjUGmisxJyJ+iQso6dadXIfHJCgtKQuMj3RJKF8HmOGfp9ZSLF3o88dkB53uOn7x6nddf3Wd8fC9VVaNuBnHaXOkcWpCBeGThKRQxqe1LUETTQ7WVvmt2aNKsFTTUaCp0CeRAzzrWxXJOhUvAXTant7GGf2CDc//j15jcvcbOT17m8B+/x9pPbtM7qpmq58jAcWYwnS6zSWRMjaVLRgZ1RdUR5rnh1nyKj5HOtKJ+J4Vh270uj99/Eb78GG72AauvTmAyYaaR9WgS944ocxLRc6HKNMbG+GjqkzY1HDeTc9EA0Bpg82i3pa05NrmVpVbExqdq6t80FpxR+gJnMJxT5SJwHsOas9hzm6w+/0V6//aLFBs93v3r7yD/8FPOXDmgqgKHzCiJIBmFCPt1yTwIK90N+maAhoJDJozkmDIod1crrB9B9cpV9gvDNDi63/hjLv/V1xj88lfcTeD43YixDm9hVnvmGvHOUYRI5j1t35FHmy6xtL828i8I39uRVSqBG92LHG2uUmwdEmMGdhVMh7zbJ1udEQb7sHYGVrscdgLTMxnRXubw9mXuC4d85eKQz5wZ8PCm482j27jZMfedOctFceRVxVsOrriaX9DlxarHO0WP41k/gdiL5i6+vgoVDGcwjEOo92A6w0w9nUJwhSFOlGpSY8VhcijiCNMtqS/V3K4n9EZ/yqC7wur22zz89A2++Vdb/MkXH2Pn6oTv/vWMnfc7TOa3kVig42NErqJcBzclBsc8rlDO72WVERO61DKnOHeO0U4BMqcjBSZMqJngTSS4iJWMQZ2xGgODKtCpIs7AN3WEw9OvHHfZAZckp585di+tsfXfP8el//l5uPcy2V9/l5X/+AK9V444ruAlK7w+gKsDpQqWtb119oGXmFPKHC+NrNQYVrXHcX+bMx2lW83pVmNWr71N+K/H+PF13Fe/yGe/8jzyv2ww++4P6b59hQe94V4N7NQT3vJDxEyZZAlnWpATvSOr+3RDH7RLpYYSUGaIzBNgwUHsZkieQ1SkDlgBrzEBL2xjuBE6QTkTDGe1y5rCML/KucLxnOY8zyaP0UeoOV4Rdh8+S/ebn+fc//THEC3yNy/T+T9fpPzVDXYRrqPcJONdu8KRcalsZxLDRKiPEAHXFXJd4+zKOW4UY16r5pxV5bwWXHzjCmv7h5x76wp85Uv4//1/Y/If72Hr//h77r2xS6mRn+oBMzOnXhOMVVbnERtgBtwiYWIsHVYYsKYZNxguGPnasVD81tMbgd/KOPuaIEudkOBlVpN2iiE1OeMMmlmkk0HPwcDBikX7UHehzOEtW7IePVvaZSNf5XMrCas50D4Fwl7e5dXpkHd95Mpc2ZkJxSzAuILjLHWYjAKuyIlFJM4rmPkkjFJ0oAL1AR9KoinJ1gVMhxCBqksMa8Q4gCyns2boD3a5/+Eef/SVZ3ji8bMc7ZV875/f4JUXbjM8WEdCniB4mjxluoqyFKYoC3b3RZa2zVaeTnFYLB0xdI1hJQprKF3jyHKDLUec0x4brkcvyynWBuT3XeTMl57gzJ88i25dYP5332P3B6+wd/U6ZT1kTGQ/BI4Lz9goVUOK6YGiAbbHxkNHTama27NjpnjOoGx3crpGuHZ7h8PvH/JMLBlkDv13z/PoRofwvZz9t9+n3D+gEzyX1EDsknuHCSW3sqRCjUSMifiYmPeStEI4Fca3I9GppuSJNCrYNGB6p9DTlIkdKKyocok+97qMe+ouBuEWFXZ9wOrT9/HI179I78ufI5bC8Acv8ubffpfivQ/IBY41cgPPsYWRekY+EW/WGvEkzLAYMDGSEWBUMoglMdbkGslCJM7HlLNjYj3nQjXHPfsw9335Oagy3vnbb3Hw3ntshjWeMR1ux4pbdckeiYysBjaazcoxwoiaoQXflKhEZGGMp8pLv6txrgeoJMnKrQTFxpSpMya11Ghmibkl9C2s57CRwRmhXoVqBYo+vNZXQuZ5QmueNF0e669jKhh6eC0TfgL8srvKtUo4nEE5UWQ/sHIYMMclTD2x8MgwEksIEyGMlDh26AyoIPoCawTbd8Toqeokj0NvG+I2xBUwwur5H/Dwg8qffO0hvvqVs/Sc8p1/Lvn23+9x/R1HPc0JMaA6RpmgWqX4a9GE3OwxqUkm0BrpklUqODFYI2TGsiKGdRE2gTMirDghzwwbZeRe02cl6zPsC8P71+l88wl63/gquAH6nZ+w8399l9Eb17h9sMcxgRGwQ81+7RlOInOTM8YRSX2Gvrn5jkRmXBGoUcbMGeMpfIeq7OHKiv3RASrK5+Zztv7Xu+H5p3j87lVe/S/f5vqPXmT1xpzz1Sr3amTbT3FEeiLcaljaoyjeBLyVNPE1po4fWrRPU3rTVHox2ASYV8Fo4g/qqrKGsomyJcoZVR6aRx7tbXJfr08o5uyvZ2w99xCDbzxH75knQBz1//cTbv7Djxn+7E2CN9y0hvf8jFt4SrEcqWWqCfCSklux4d8FK5EcZaRjNpo72NZ1Kw0U84pi5xZDhNX/9C3u+vOvwV9+mU4+of7HgsFbN3j40HO5ttxUyxUC7xOTtLwYJBoKlGHuYUWQcVNi+gQv+Vsbp6k9XevoBaUbhVwMiEWsQ51DM0edGbRroC+wJrBG0jQZ1Pi+ZbbWYzQwzEyimTgr0BEwRilDxdujQ952q+xqD18ZTAHZ0GH3DZ2hISsNNmYMhwVSQZxGmClaGmJtwKcWtVBb1BdgMggG8h7S3UBrC07Y2BSeembKH3/5Ik9/bh1nhB9/e84//c0N3n9tAOUZtK6JcQgco4yBkkXLg0agRKhIIp5KaqGrl7xnKgk4ybAmXa9VhY0Y2UA5p4F1remp8jBnOeN62I0VOo9fJvs3n2Pt+aeoNge89r1fcfSf/pn1Vw4ojkcMiew42Bc48MqRBsoQmcfArqtSIijqguA5xzSZ4EAlhr6apD4dCqq5Z6vrWMu7HB4M+cn3f8b21lm+8Of/Bve5+7isz4LUjH/6Gu7aAb0iksuAQmuch65VjqMyweONJjYMB4Rmr9/2sEqrnJKovEzznwUyTaWbgUY2o3KByCVVNgWeoMMFBeMCk62M1afv5+Jffpn1Jx+hGB+z+/1fcPNbvyC8fRtTK/sEXvdjPrDKkYWJL6ka8aLWMP1SBsABObFZ0hIUs4yRCkPtDLXNiM7gZ3M2/+675Cjb/+GPuevPnyNbyzj4m+9Sv/AmK1WFxVKIZWoTD654paJOBGC5RXNdAl7QYAXk157/TsYpDdehNYptEkBiXQIf5BnaccQc6GiS4usq9CLZINAZBDorytlOh7uynE2TY4GpUWpbEqxhQMmmVgyODuiHM8zGfeLEohX4YNDaUMwztFD8vEusIdQ1PsxJtJ1ZUy6xDSYgktkuNg+IrdBySNQx5y9u8sTnLvBXf/kQjz5yhnrS44UfTfgv/88t3vjFlNnRGloH0GNUd1HZBR2CFikR1fIGiTYh2bxhnStR0wr1NCEL4EToiKWrhkGEleDZJLBNzZb39F1gs3+WKrf0HznPpW9+mY0/fpppDu/+88+49p9/SH5lh2I4Y0TNjlWud4XbEhiVkaoWRC1qhNtZjcZm6mlMsvMYcoQukalGVgU2jCVqJGpFqD3GdJEKyvmM/JevcbWbc8+zn2P97rP0/uxL7HQt177zc+qre/SyLnfPcjRCHj03UG5LoHBKhsHHiGhqRV70V9HWOFPUkTynJYtKV2BAZF2Vs0QuErlE4CxwX/8MwzBnNrBsPf0w93/tWVYfvp84nLL/o1/wxj//kOrqIWFacIznfUquUjLqDJhmlr1JsWAG9I2Stm/vjhGsQEagG11yED4wpWYWlUlt2AiOY42M1HLX7j7v/L/fYbdX8Ni/+1POfulJzhQ1t2Jk75dvEI6PGAAXxDXEGoFpHRJO2hsm04q4ZJh/0LAWG6Bh6PAu0UR4Z5COJXZsIubqZAm6lylkkU5HWenC1kDYWrU8ovDZCs72HBWRK1rg7RgrOT0cX1wfkBUlV6Zzrg5L9kYZRdnFSwfJmt1cnTiIAqSmbxvBNYBsLIaE4LBGMaHChAk9GbN1Zs7le+CpL2Q8/TQ88OBlhodzfvGj9/n+tw557UVPOeqBj9TlHnnvkKq+DuyCHifQu1ZACVKCKRHqdEGMgKlAKjBp7ykN1tKpIYvQIdKPgTUiW0TOEzhvIgOrxL5j7fH7OfuNZ9h4+mFMWVP/8DXmf/cDzMvvIt7yjh6zB1wX4SbCnkRmJuBEWVGLFzi2Dc43KlYUp+CJlAiFUfIYmGlkFlMbViUQfYQwpTYZay7HvXOT3aJCpmMu/dFTdO8+x7k/e5Z6Rbj6vV9w9N4eG3WOqz0WIRCZaWAcI6sIxidS6CCt52xskhbg3yqtmXRNFFZQ1lG28JwlcIHAWVEmWcls03HxK4/wwJ99jZXLd2Fv7nH0wmscvfAqXD3geDjmSJXdPHIzRI6CYVZFphFqtZRGCcYnw9QU0ia+a8GKkAmUMRJE6UjKOQagVpiFwFChkIpuFSmuXGX89yUrHcddf/os+VeeZDsTJisGfvkGK4djLigEiVS5YWItK75GypozFexg8bZpWr/Dc/5+xplFKoEqS53oPhe8E8gNklskt9iew3QcmhnEwWoGW13D+YHlQs/wSAkPeAhRuC2eHT9jFkpWYlrN77arrKz0uFhVbOYF72QVt7KaaebxWQfNHNEp4ooEinKawqcIqMVI4mt1oSbLC3ImrORT7jobeOKxNT7/+U0eeqDH2hq8f6XghRdu8tPv3eStX1WM91aJlSX4Y9TcJMp1sFdBR0BB4idpwliZIGaKSAVhDSOGKBWtilYLQBBIJNMomQjdGFnFcAblPIa7urDWNfQ/ew9bzz/DyhceI0TP0U/eYPitF1l9eQd7HNh1gasU3BRhzxhuBeVAU29hB8GjFEBo1JoxkRBaTKfBmCRhUGXKPHpmwVNII8Knkso9MRAjnDvcJZRTDtXjCJz98mfp3XeeC19/hpAr1/7pZ/TeHbJSp33sLoGORDKBlZD2jhPjGUmERqYB0j4ulVxMkyBLepxdTcJCqygbhKa/NHnOo03DhS9+hvu/8RwrD92F3Dpi74cvsPeDlymvH5JVNcflmB2XcyMX9qMwrgyzUDKPAtFSWU8hvi1+LejXjBiMCBkQtSQEQw8hSoYzqeZaa2QughHDETOyqsK9u8fxt19k0O2w8eXP0nv6AS66gAw6HLz4Nr3dEeV0ziQ3jDow855MI5nCvmnUAOW333d+rHF6k6TFKxepHMSMVO90gjpwTsi6GSa3RCs4C6tO2MyFsz3hghPORcNA4VaIvFcH3qyUKT0G4rgsHR7oZFzqZaxuOzbyjPOrgff3PTt7U4Z+QjEXYlepZ8eJvScYgsvQhmbT2IjTip6rObMaObcB99/V56HLKzz2UJ8H7xlQTEpe+9Ub/PSFyIu/2OODd6dMj3K09hSzG4R4G9vdoS7eSEj6UHCC/vEgM0SmiBklIAI5iE1eUxpW/AYlJKpASOTfImQa6WFYxbDplHNdy8ZA6T37WfqP3IsNkeNX3+XWd39B+fK79IYFRoWjesYIOHLCoVWOJTCKgTIk71jgm9atvElanWSNIykP421KFNlMiLnDori6MUoaEpXoORTP2hTsezcg1KAVZztfYHDvRS5/8Um6u1P2rv+UnECfpNQVXUKO9ULihooaknEuI6VEGqWApuyMNJKB0JFIT5UBkVUiqwTWBIpHLvHA177E+iMPMLt9m/0fv8zhL1+luH6bMCyYGaWIgYlGdmvPzRjwJscH8DHisHgCc/wCtJ/qzoYQE5AmAEEDRhteJGtwxqIopYd5k9B7jSEX6HJWc/yVHa7+1x8zkYrzTzzE2iMPYGaR/GDO3ug9jocTzmAZGuGwWSR7GGzjLZcN8zf1np8AQmhWHYFgYyMhftKNoRIwoqjWSPQ4MjKUnjOsZgkfWebCTlCulpG3J5G3i4yhdrDBciNm7Frls5vCapZzeTNney3yyJmavTNz9tYKhqsz5sOScb+mKAPl3BBDQNVhxJBlSiePrK9aLp7vc/lCzgN3r3F2pU8WlGu3D3n95du89MKrvPbLFXauBeYzRWIg1EfU/ibITURvEcJ1YJhW/0UfYiAlgArQklRqLlF1YGqsbYAI2kirN2B3K4ITwaqSAT0xGAp6Lmf9/Db5o/cjIVL+8m0mP3+N4SvvMj08hAgjIrdohHiAiUamopSajK00qUMC8QnwGhS8YrXF5DShXFSCRKxIUnDUSBOANoaSGqKsq7kUgVFArpQci9LJM7bKwGqvR+fe+xlmL4CBOkYqIj5vAB5BcSExQaQZp+n6qW/mRkQlJBYJUluaJUEpHUnsp2ugbyyDDO597GE2774HOZhw8/s/5/2fvcLs2j5azPHqmYTIjEgZama+5lgCRZYaMpyHLpEqempN4IATo9AUMcS4wMKWDZIrvZ5ipFzTQ3zgXamp1WBjhTmsmL8yozCRzrxm++GHWemvoZtbzPt79DlkrY6si6GrCdRWNcihVjPnRDvnDxDWthRUoopERTSkBEn0iSYy1sRQUpcGqS02OCpfJfrJKFQqvGsEXys358q7E9iZdtgvc6pg+cDDG2XkyoFwfzfywJpwV194bNDhiX6H+ZZnfPeY8WTK7HjAZF5SVBEViziHzQ2dnqU3sKysZKyt5PRyJTfKZL/g3ddmvPzCFd5+9QP2dkYcvh+ppxlRPRoLYhxh7B5RbhP8TcimUI8bCItroGYB0UZ7U7WBqVVEzcBEskzAKmjd0JYkRnDnDE4MVM3NcMK8Lih9JNtcpyxK9O2bjH/+BpM33mOye8DNWLDrIsPomcXIlIqitsyiMneJk0wRohWCadKAZY1oOoQWgaSQJqGmX/igeB8pY2zqbilzLgRmwIGbMfcdnHfkk5rqyk1mWLoHE3qXzuNLBSNMM2VUBmYmEFzqNAm14mOg1tAE9Sm0Va2bXo32+VLXiyRPpi2SzxhsDlnHspoP4MYx1ZX32fn+y+ze2GE0K1IWFghY9vFMYiQg+DxjaAOK0gsG1dSMHfF3wAabnycZGkKz2BGTE6oxdLHUKsQ6sOcss7rkeHbIOdthEB3u5auMZjDYmdPNe1DERNdju3T9nH6l5Fgm4tnPAmVMXjPJzP+69/ydjTPT1H6bByX3ivFNVi6kpIgNWaPs7FENVCEwrWqOZ8KtkaFeNXyQWSYBRrVyWBiGU8ukFIpaGUW4XVmu7QQuR+XRTHm0D/evKRc2lLV1WN3sYy72cdMOdUh9vsFCsCkBoY1Wh69hMiq4fk25+X7F1bf2eP/NXa5fPeTodsl8bLGzaVpgtESZonIMegC6B0wglM1sCaApRE0YWd/UOnNEmwYhDU0o2TZat6x8AZFIFKGWJGFXEamso6qF/WLGudu3OPyn7xNvTamu7HB8eMBemPGeC3zQhVFUZBYpgBmRQqGKMYHONU0sjCS5hygLo2xUU0mBNQgnjPSIEgXKhow5bxI1FYZ5FsjUs0ZitxuMZ8zf2eF4OGe88QFehIn37NmaAwJFw1IQraEwSmFgpm13ZivWlCIss+h/TcIFIZkNtSR67jnJE46jshKE8It36b874uD6Lcr395lNZ+xpzW2tmBiIklEEZUpKcM0JVJLwkWoUghA0niphpKEnL7SXZHGtknRC1VyTaNLCc9VEMhs5JDDRistTT28WqabXmOzMma70OSpn7I5HzAQijsTpK4wd7PVA5vwmIta/vXFSCx0L3VrpVgFX18RQIbZERTC1hboAbwkhEHxgUnhujTx1VIZTZdwdMNKMeuwpJzXFRCkKB1UOpYVCqMaG6xOlmhXs1TPecnM2V0tWtgPdbSVbs9wX78PlgsmSkE6lE2o/oygryjkMDwM7V+cc7ig778842JkzH3pC4Yh+ndzXRF5DOUoKXzoj6hSNE9BJClklhTgJyO5Tq5y2V9Yg2mswpK1ecWPENFy2DaY2EPANMGAuhgnKRKDrhFDMqW5cp3sddBKYlXP2YsGOCexa5RaBQ414G6hDZIwwFqUKbXjUGGfTFdJpeistJ8SUkSYoV03kcBFo2NkDSmEMY5IXLkQQDwfBcx3o4bBUhMmQ8WyGv2WZdg0jK+wYz4H11CGSlYJxwkwiR5niA5iY2gtbkjPan9QEqfBaUxEoxTbXBYYaOQDWVDHBc/nVW1wztzk4HjKeTSlVmRrlWIQDq0xNSIYpypDADNOk8SNeLbNmeWhVL4DGCk8nY5b9VmyW15rUfdVmG3ZCwBgYaSAodMk4o5HZ0ZQ4qplnsG8CxwTGkirj+0RmCMGcdty/y/h44wwp7nA1OB/IKk80NdgyTeBC0JlLmppFBYVnPrNEAr4MjLLANM+ZqSUUNWE6h3kJhYeZhbGBcRfCFjIyjIddimnkalWhJhB6U0J/jnY9D03mdHKHMTW+muLrglB66pmnnAaKYaAcQT21hBmYKiMXSx4Mvoa6DpSddwnmVmrtoWHKi40aNa2SVusx2/W0vaktEcUSSK0VDIkhPZr8YK1VksMzGRmOQ624FQxBI0chcHA84cnqmCmGHafc6DhuC8yCR+eBQmp2nXLUUbyaFM/WJ+RYToUsSMOxkBaPdCTpyMLi1SR6m1q6ImgqxNcSmRmDN4ozygNFhg+BW5qMukQZ4hnEgPEZM3XshJpdqRg1u1brDcZD1VXqLNUztTppMk+MhDUwhwVeqaQyCURuxOGiSSXyGMklUnlha2fCEQX71BwgDDHMYyKDmWnkttTs94SRU2JUqJrNogIa8CINYKu1DG3/X2SRoSlr6MnV840fVYmEZq84jEJuE9/trZiavlcaraBuCExCwR4lY5txJLBHyS0ih9aQmQ4rdYoofntsUBofa5zaUOMHEvokRo9ohals2uSXUE9TJpBJleT7sJRlRHNP5VIoE0Mk+gDeQz2HsoBRDQcKx13MeIwUa9S+RxEsdVwnSi+9d1yAlLwyfhNnemjdwY8NWvRxdY6UCmWJVAUulthQkPkC42u0rqjVU1InLTC9hsZdNBq0FSlRJcHxSqDANF6woSzmdCtYax4JtK1IUzZJsn00n63UU8WEShEROjHQq+bMqRdYjQ2O2cdxJTfczmFeK9EHJHhElHEXvGuSK61yVYvhZaFY03TiL3WXyklvpSEZZ3Mzm29I5YUCpWyQWgPfYUbJjlFGWWRPPds+shojeXD4Oue2lAw1UmlaAkqSuE/tIbqGHUjhhLbELxloDabGh4pICq+jSU3aCkhQNETGATrscUDkEMsBkSElBZE5ac88DpGRMUTXFCdJFpbqryHVn5M+xJJ53smG1zD9NHFtCyFJcU8yTi9C5nOMcdQoRxRcoWQGXKOm11zxmlQb3bNw3UQODFTO4aKwNq8pG0me32V8vHFmqWg9N5FSArXWhFjhgsXUEVMKMhHEdtB8DqYH84QWqvKA2IgJNSYUxFChwUMNrjDYkWKPasyoohweE+IRFX0ieUrGxNZjKERDlc2pvMIswnQFSkf0lixAFgNa1ZTFHpkdYRihcYzXeTMV015CwwwVj6qlSV+micMcmCRonrRg9wQ3S7ethkaFMaXI1kg0kO1cTA1DaV9Vpxsc07+QSE7AUVESWEmVKEpqhuK5hWXkIdSKCSkTOsOchKPNwzSTTEk3uyQlgVpQt2/5tNqfzeedRlwzUdsdstdITWyYy5UjImOgcpB1DSOBwyKyUnq6MfEyHUtkbAy+WdM8MMagXjDFCYVZ2ouHhkGggkZpJFISSK7ZG8VLpJaU41VVao0co+wzYoJhRIeJgyLEZmGxBAy9GOgXMIkpEmhZAUPbmCDyIftNli5Ke53S8/Q12tRBIwHbEEinSEnUYSWFyjUVY2puUNMhNKrWjgrhWODAGobOoOII83SNl5f033Z8rHEObUKSTjJh6pTaBGJMhMpZiEhtMMZi5wX+uAA/Sd4zE8iVkCk1E2KooIpIEXGFozO3uJklTif4Yo6vmuQMkkJp7zClo1Nm9CqL9bBnPfgx1BOIx0gNVJ7QwuvijMAQmIGZ4s0xwUxAx6kWaYA6IH6VFPQoUIHMG3DBCEzZ1NAzjCbijkXKoFEtNgLqExNAMs72hqd1tx1pp6VYiRTOMPKJf2amCVD0znqaGVJHQqmUQZmQWESnEtHSYBr69VSGSP2UwTSLZpb2nVJoylWlQuLJxGyM06K45nyVFJQHTDOpUzj6DnVqa7IJwVMh1AYqo/QDmJBA9yMTmDpDaYS6Th0pEUPHJ+3NsHBVKYw2CzMORBPwDQl+LUrV1NBD0MZfpcblq9ikttaJzJzgxRF9xNZKHgwDtXQqz7yCIYGhcJIJI5Feq5545eaAlh7NK82GUNtQV9s7GBr7jkAOAYKDjnOU1lBJZBoDmY9kMeKogcAsOkpJ7cQFbTeMSQvS7zg+1jjn0uwaLBRGiZLUfIMGbBQIARMDpvSQNTC3UhryrzSJ1JkEip4DE4ubOtzcYEqLLz2lFqhTkCmECVQVTCN2IvQmjtVZRlY79lYtxAoxBd3MI2ZCLWNCmBGjxxjB5IKnJmhC9JAfgjmGbJL2yUf3Qug3O8dEaZlSninJJdJk2mONkp8KaRvSvjShWzfVdv0v9NZTKsE06L6g4EWpjaEOiQi5BgjwWi+wOoNzdWrJK4EjA4dZcsS2jmw1sy4pXDXzTyA4QXtpcdD2F00j/HK6Vht32ZbEFrkhYCGyKcqw01pVoKw9IQBekcaYLCluqCJMTGToLMEk9GJHhV56e+LCEJqEWns92nA/tlRO0IS2bejdaAkgRA43BtS1Z+4TDWWVOSqJ4CvWEM7j2CLRgnSJVCrMXVNHCpD7ll5laSw5rkUGQZLHPOXUGuebtgaJWW9OpPaR3Ea6moD0FQFLW7dN+QkflTpaakKzZTBEl2Go7wipf/Pxsca5oo66hntMn+3JmL3JAVXoEKSLd30sGUYsWYxIPYZODS6HLPV6ijUIQ6QpkmsdE3LfR4hJkrQTPeVoigkefI3UHq0So8FUlHmuGAd50QICamLVhExaJn1Jk+T66mqGSkWaSmUqbUgOxSrIABNu0/KkLSZNrFOh3PdJLDChCXdTSCbt+9osi0CVWTTWbAxgI4wJruSoL8Sqz7x2tPhSIylbehxKJkaxZInoS8EfZwwjzATEaRM2JYwHqmBT8ihNqIZBENCgaetQpmMxsbmFrZO6Y5RG21Jr811LBlqFFE200yAm7zpDqAQO3IkzbmlIvKZAxWiaPZU2RKExx8ceKhasQ3WG7QcKW6HdLqUbEKXGhIit2nUkecyREybYBIksI1GFiEO9pDybWpAuU6dcjdrMnUaCAbu4FmjCyTbL6dJJC6etEMICDb80ToIgQAk2LkA4NYaZgtXEQYXRBj988tEWJhgR0LQg5lkPX1c4axO7oM0wkmFMRllUWNNLi/6HjI/vSglCKMF6Tx4qrJ9jQgQreO+oiwJRh688wZVQdhIbX5a4hTAGGwUTFY2akD0+pA4QnyaGDUqcl2iIiI9I8/vUQB3QGJEYsb7pDNElCipJUDORihgLNM6gTUBI1TxvpqIIGucspfZY1AC1JRRpXVBcek/7fOmHsDgW6gL1FTH6RLtpTHKZIdKK/STDa/6CKEYhVI1eyvL306zmnMDwmjtxega1ySyWwrKPGF4/6vdtQoWE/Fr6S1FO7HwBNWs/5e881va5ARrJsqgJpCKhgRhq8sYxZVhTNnyxS01gBNOE3bX/kO9Oz1u0za9dl6WI9SR3vTw+ZM/3cZet+V2IYfF3TXsd9MMBBKq6oOuNenKE0TY0oWKIMaKaRL46eQdr3ceWWz4eIdSERc4q/X6GkcTnGoNClkRwIBJshxjyBL4NWUIJ2GaDFjJisOnGhICGmCT4QoQ6QFC0qtCgyThDPDHgECCm9HzUCdDobbSCmZL0hkVrVEuSUbbG2dbYWhb2uMgV0KyubZh4srIuP5o3LtjLtXllKdvQ7K0Sz2tAQ2japFjwCKXPnKzjpygqpF3h9dTv2n/L0t9NLyyO+uSl37eYBqc0TD52zt5h6Kf+rUsW0sarqidaKb5e3MuT66GtkyLqyStJ6v6jFgFdKpP8y47lvxubrpK0luup6764p81zPf0lGGMIIeCDp9Pp0O/36fV6WGt/d+N0BrodOLe9xsMPXubatRuUN/aZ12OMJA1ONR6jJZCjuBSCaPKaakB8Hwk5xIgJMfUe+qYx10dMUGJVJCMNMRlvQjE3jc4xhYk6bE72JMmgmgxRF94yYV9TOFuxkOJrQtlWQfKUYS4SJSwu8GJ8yIUTAY3t92nTFZPIrogRsS2P6+LufPjXLQHC75jyH3NHTv/uN2nY/U1Gy5i3PFM+7Hvb1z66u6J5XUBswkCbBm2TVIh//b1pbbwjMvm1xerj/uZHjE+IKD5xfNTHTybO0mun7+Lyv1o8bQgB5xxb21vcf/99bG6ewVrDx41PACFE8ky4fHGNLz/7JMPjIcIb3N4f4amRvEKtEEwgGo8am/Qcpd2pJKCz0UTbqC2VpEneRprOhtoUqLY1xXjynhhTiKQRS9GcbKSFybV6wy2IQGnl91q5hHjqplp1i1W39VgLvQ+WuikWgVMDA1sKpBSDNzki0MkzOnlGv9+h2+2k7Kxtih4hGaxIWhCssujQAHCSnbr/7XHoUkh0eoY0x/lr8+L3N864pDgtpwwUPmyFWvbw7VNpVM/VCJLnuH4Xa4V+r0PodlFTpwSKKlZjIznYXFlRomnOVpc3YCfff+fzTzij37V6cXpotnh6isHgw97KHVFRM1JHn9Ltdtna3uKpJ5/iueee49y5c9CU3D7KSD++ZawOiFhW+sIXn34EDZ4zG6u8d3WHaRGJklOrIYgjGos6k7hsjTTbPMGEPuLzdMDa7DmiojFiokJUfDVIcnl3PjQuPpdJF9ouB213877pBEkGGjWltWUplNWTLToJZ9KEmkr6vcJi83VKUkE5pQPSjIihcGuIwNmtLba3tplNz7J9ZoOiKOi4Rs06hMW+KuX9Eu60vcleHCyFb8koTxtjaBJCJ8dy53T4w3hOMSfT4M7vu/PfH8kcFzMkZqmlMLe4fpcz5zY5d/4sx4eHhLKgZwyZglXFRl0Qwaso0TY5zfjhf699vtzZ8dHjD2Oc1nSaZ61h3vl8+TjhwxaQGALGGtbW1njwwQd49tlnePbZ5xgM+ngfEaMfaZzycSeq6lWjpJqQCMNRzY2bR+wdjCirSBBHWQeisQksbFLHROvmVcDEDBPcwsjan4scREzCNZL0vxuj1HYpWpy5lXkKF7SBiC267tskUUBjOJ2N1WXsR2rjWr6QJ7vB1mDbPeOyUZ42TowldNdBlbzTYdDtEXzNZDQmBE+eNXyu3jdpdmlKGclPLIoW4pbC32UvfuJFQwgnm+QP86Kn9scfPn4T4zX2wzwEp7774/abqoqow6gDa4jOILkjX+kxKwtm0wnGe3IMTlM/Z2pv08QeT0z1W0AaL/5Ri4DqCVfSR5/0ndfrtx8igiVLUOsP67+Upe3R0p9aPm7RFN4bYxgM+ly4cIFLly6yutpPn13sJj78Jn2sccZqrEUdCCHS7a1inaNF4WHAOElbw2aOtIveQhaDO488peAXrzTXOLdLK9GJPZ4aTpcMq7HjRcaSlrx56Rx/LfRSBHOyb2L5rUv7BYHTbQSnJ4ICMcsW60gTJBCbdcKaRq0rLsv4tApeLPYskaXzuPOQl4/7Y46l/fZPGp9ooHLayE/NwY85xuXn0pSMxaYysDcn1Z0YFSeJ2MuFZJiNCbZAK3ThOU9/9+/CWveH8pxmOcRuLpE2zz9sqi2Cm6XbZOzJ+xdZ56BUdbW4L71e50OP9hNVxnq9nFAHrPEIgmu0UmJQTLAnNZrmwPWOP5MA5PGOE2zOwrQ/WlA5J8mBO77HcLK6t/VzlhYBkZQgTm/g5Inw65Z+x9DlgxYartV2nC5CRVKBpv36GJNkTGZTBSWGtOW2pjldaaKCO87JLP37wye8NNf2o4/lDzXispF9RBJseXzY8ab2NVCTOKM9DVa/+XzS/0yTVZbOETlJUTSsJnf8jV+n97D2kyzvD3CdlFN07csJ/fhrc7yp+7aPpXMMzQIOaa6EkELZfr+LqjKbzYAOHzY+1nN+Oj4dn47/duOTY6JPx6fj0/HfZHxqnJ+OT8e/0vGpcX46Ph3/Ssenxvnp+HT8Kx2fGuen49Pxr3R8apyfjk/Hv9Lx/wOb5K4v7PPA7gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m\n", + "If you have never playes SUPER TIC-TAC-TOE write help for the instrucctions\n", + "\u001b[0m\n", + "Choose the tiles you want to play with. You can choose \"O\" or \"X\".\n", + "X\n", + "You have choose the letter X. The cpu will play with O\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "1\n", + " | X | O | - |\n", + " | - | - | - |\n", + " | - | - | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "3\n", + " | X | O | X |\n", + " | - | O | - |\n", + " | - | - | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "8\n", + " | X | O | X |\n", + " | - | O | O |\n", + " | - | X | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "4\n", + " | X | O | X |\n", + " | X | O | O |\n", + " | O | X | - |\n", + "\n", + "Choose the position where you wanna play (from 1 to 9):\n", + "9\n", + " | X | O | X |\n", + " | X | O | O |\n", + " | O | X | X |\n", + "\u001b[1m\n", + " --------THE MATCH END IN A TIE--------\u001b[0m\n", + "\n", + "Do you wanna play again? Insert 1 for Yes or 0 for No\n", + "0\n" + ] + } + ], + "source": [ + "# ----------------------------- ENTRAMOS AL LOOP PRINCIPAL ---------------------------------------------------------\n", + "\n", + "print('\\033[1m' + ' -----WELCOME TO SUPER TIC-TAC-TOE!!!-----\\n\\n' + '\\033[0m')\n", + "\n", + "# Con estas funciones mostramos en pantalla una imagen que se encuentra en la misma carpeta que este archivo\n", + "img = mpimg.imread('tic_tac_toe.jpg')\n", + "imgplot = plt.imshow(img)\n", + "plt.axis('off')\n", + "plt.show()\n", + "\n", + "# Mostramos el mensaje de ayuda para el jugador\n", + "print(\"\\033[1m\" + '\\nIf you have never playes SUPER TIC-TAC-TOE write help for the instrucctions\\n' + \"\\033[0m\")\n", + "\n", + "# Procedemos a la definicion de variables basicas para el juego\n", + "comb1 = permutation([0, 1, 2])\n", + "comb2 = permutation([3, 4, 5])\n", + "comb3 = permutation([6, 7, 8])\n", + "comb4 = permutation([0, 3, 6])\n", + "comb5 = permutation([1, 4, 7])\n", + "comb6 = permutation([2, 5, 8])\n", + "comb7 = permutation([0, 4, 8])\n", + "comb8 = permutation([2, 4, 6])\n", + "replay = 0\n", + "user, cpu = choose_letter() # Llamos la funcion choose letter para que el jugador escoja con que letra desea jugar\n", + "\n", + "\n", + "while replay == 0:\n", + " game_table = ['-', '-', '-', # Definimos nuestro tablero de juego\n", + " '-', '-', '-',\n", + " '-', '-', '-']\n", + " user_win = 0\n", + " cpu_win = 0\n", + " tie = 0\n", + "\n", + " while user_win == 0 and cpu_win == 0 and tie == 0:\n", + " user_imput(game_table, user) # Recibimos el imput del usuario\n", + " user_win = check_win(game_table, user) #Comprobamos si el Usuario gano\n", + "\n", + " if user_win == 0: # Si el usuario no ha ganado entramos y la computadora puede ver si ella puede ganar\n", + " winner_move = cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu, cpu)\n", + " \n", + " if winner_move == 0 and user_win == 0: #Significa que no hay jugada ganadora, y verifica si puede bloquear\n", + " block_move = cpu_move_block_win(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, user, cpu)\n", + "\n", + " if block_move == 0 and winner_move == 0 and user_win == 0: #Significa que no hay jugada para bloquear y juega random\n", + " computer_move(game_table, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, cpu)\n", + " \n", + " winner_move = 0 # Volvemos las variables 0 para los proximos loops\n", + " block_move = 0\n", + " cpu_win = check_win(game_table, cpu) #Comprobamos si la CPU gano\n", + " show_board(game_table) # Mostramo el talbero de juego\n", + "\n", + " if user_win == 0 and cpu_win == 0:\n", + " tie = check_board_full(game_table) # Comprobamos si hay un empate\n", + " \n", + " # Mensajes de victoria\n", + " if user_win == 1:\n", + " print(\"\\033[1m\" + '\\n --------THE USER WON THE MATCH--------' + \"\\033[0m\")\n", + " elif cpu_win == 1:\n", + " print(\"\\033[1m\" + '\\n --------THE COMPUTER WON THE MATCH--------' + \"\\033[0m\")\n", + " else:\n", + " print(\"\\033[1m\" + '\\n --------THE MATCH END IN A TIE--------' + \"\\033[0m\")\n", + " \n", + " \n", + " # Le preguntamos al jugador si quiere jugar otra vez. Si escoge 1 juega otra vez. Si toma 0 el juego termina\n", + " while True:\n", + " try:\n", + " replay_input = input('\\nDo you wanna play again? Insert 1 for Yes or 0 for No\\n')\n", + " if int(replay_input) == 1:\n", + " replay = 0\n", + " break\n", + " elif int(replay_input) == 0:\n", + " replay = 1\n", + " break\n", + " else:\n", + " print('The number entered is not 1 or 0')\n", + " \n", + " except ValueError: # Si el jugador introduce una palabra obtendremos un error y con esto lo atrapamos\n", + " print('You have introduced a word not a number')\n", + " \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "062813a6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "cb1eaefe", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f81244f8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/your-project/tic-tac-toe_proyect/meme_monkey.jpg b/your-project/tic-tac-toe_proyect/meme_monkey.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7be584a97a80b4ac95e8df2e798d59abb97ab14 GIT binary patch literal 92530 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Ĝ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 IA-~@LAI6VFeEz|o1<|Ugy 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

n<7GvJu@71asmL4={9=;DnH~ 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 A>;M1& literal 0 HcmV?d00001 diff --git a/your-project/tic-tac-toe_proyect/tic_tac_toe.jpg b/your-project/tic-tac-toe_proyect/tic_tac_toe.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eccd03ba58da1fa146fd7bb88fc5c912cb3b3c5b GIT binary patch literal 8703 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