lab6/lab_6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "HyBHi8H-_Nll",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Podejmowanie decyzji\n",
    "\n",
    "## Wstęp\n",
    "\n",
    "Celem tego laboratorium jest zapoznanie się z kilkoma metodami wykorzystywanymi do podejmowania decyzji\n",
    "w kontekście, w którym dwa podmioty mają sprzeczne cele, a konkretnie w sytuacji, w której wygrana jednego\n",
    "podmiotu oznacza przegraną drugiego podmiotu. Wykorzystamy do tego grę w kółko i krzyżyk, która posiada\n",
    "bardzo proste zasady. Zaprezentowane metody mają jednak znacznie szersze zastosowanie i mogą być wykorzystywane\n",
    "w szerokim spektrum problemów decyzyjnych.\n",
    "\n",
    "Zastosowane metody to:\n",
    "\n",
    "- losowe przeszukiwanie przestrzeni decyzji,\n",
    "- heurystyczne przeszukiwanie przestrzeni decyzji,\n",
    "- algorytm minimax,\n",
    "- algorytm alpha-beta,\n",
    "- przeszukiwanie w oparciu o metodę Monte Carlo.\n",
    "\n",
    "Na końcu laboratorium zrobimy turniej graczy zaimplementowanych z użyciem tych metod i zobaczymy, która\n",
    "metoda razi sobie najlepiej w grze w kółko i krzyżyk.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U5dPgzQCVNco"
   },
   "source": [
    "**NIE WYKONANIE TURNIEJU SKUTKUJE AUTOMATYCZNYM ZEREM**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VC7kUZoV-Mmv"
   },
   "source": [
    "# Gra w kółko i krzyżyk\n",
    "\n",
    "Zaczniemy od implementacji gry w kółko i krzyżyk. Możemy podejść do tego na kilka różnych sposobów. Jednym z najprostszych jest gracz wykonujący losowy ruch i liczący na szczęście. Trochę bardziej skomplikowanym graczem będzie gracz wykorzystujący jakąś heurystykę (można taką znaleźć na Wikipedii), nas będą bardziej interesowali gracze oparci o przeszukiwanie drzewa rozgrywki np. algorytmem minimax czy A\\*, a w bardziej skomplikowanych problemach znajdują zastosowanie również algorytmy probabilistyczne typu Monte Carlo, a w prostych - klasyczne grafowe przeszukiwanie.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "roh7tiIlARnf"
   },
   "source": [
    "Na początek zaiplemętujemy samą planszę i metody niezbędne do rozgrywki takie jak sprawdzenie, czy ktoś wygrał, wyświetlające stan planszy itd. Poniżej znajduje się implementacja gry, która wyświetla stan gry w fomie tekstowej oraz informuje, kto wygrał grę.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-02T20:40:22.203166Z",
     "iopub.status.busy": "2025-01-02T20:40:22.203166Z",
     "iopub.status.idle": "2025-01-02T20:40:22.765327Z",
     "shell.execute_reply": "2025-01-02T20:40:22.764312Z",
     "shell.execute_reply.started": "2025-01-02T20:40:22.203166Z"
    },
    "id": "tKivv0kMflUd"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numba import njit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-07T15:46:44.169680Z",
     "start_time": "2022-11-07T15:46:44.140069Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-02T20:40:56.943579Z",
     "iopub.status.busy": "2025-01-02T20:40:56.943579Z",
     "iopub.status.idle": "2025-01-02T20:40:56.980488Z",
     "shell.execute_reply": "2025-01-02T20:40:56.979495Z",
     "shell.execute_reply.started": "2025-01-02T20:40:56.943579Z"
    },
    "id": "EdN6KydUAf3N"
   },
   "outputs": [],
   "source": [
    "PLAYER_1 = -1\n",
    "PLAYER_2 = 1\n",
    "STRIKE = 3  # same as SIZE, difrent require changes check_for_end() and consequent\n",
    "SIZE = 3  # same as STRIKE\n",
    "CHARS = {0: \" \", PLAYER_1: \"O\", PLAYER_2: \"X\"}\n",
    "KERNEL_D1 = np.eye(STRIKE)\n",
    "KERNEL_D2 = np.rot90(np.eye(STRIKE))\n",
    "\n",
    "class TicTacToe:\n",
    "    def __init__(self, player1, player2, size):\n",
    "        self.size = size\n",
    "        self.board = np.zeros((self.size, self.size), dtype=int)\n",
    "        self.player1 = player1\n",
    "        self.player2 = player2\n",
    "        self.chars = CHARS\n",
    "\n",
    "    def play(self, verbose=True):\n",
    "        self.print_board(verbose)\n",
    "        for i in range((self.size * self.size) // 2):\n",
    "            self.player1.move(self.board, PLAYER_1, verbose)\n",
    "            self.print_board(verbose)\n",
    "            if check_for_end(self.board, PLAYER_1):\n",
    "                if verbose:\n",
    "                    print(\"player 1 wins\")\n",
    "                return \"win\"\n",
    "            self.player2.move(self.board, PLAYER_2, verbose)\n",
    "            self.print_board(verbose)\n",
    "            if check_for_end(self.board, PLAYER_2):\n",
    "                if verbose:\n",
    "                    print(\"player 2 wins\")\n",
    "                return \"loss\"\n",
    "\n",
    "        if (self.size % 2) == 1:\n",
    "            self.player1.move(self.board, PLAYER_1, verbose)\n",
    "            self.print_board(verbose)\n",
    "            if check_for_end(self.board, PLAYER_1):\n",
    "                if verbose:\n",
    "                    print(\"player 1 wins\")\n",
    "                return \"win\"\n",
    "            else:\n",
    "                if verbose:\n",
    "                    print(\"draw\")\n",
    "                return \"draw\"\n",
    "        else:\n",
    "            if verbose:\n",
    "                print(\"draw\")\n",
    "            return \"draw\"\n",
    "\n",
    "    def print_board(self, verbose):\n",
    "        if not verbose:\n",
    "            return\n",
    "        str_line = \"---------------\"\n",
    "        print(\"\\n\" + str_line)\n",
    "        for row in self.board:\n",
    "            for cell in row:\n",
    "                symbol = self.chars[cell]\n",
    "                print(f\"| {symbol} |\", end=\"\")\n",
    "            print(\"\\n\" + str_line)\n",
    "\n",
    "\n",
    "@njit()\n",
    "def check_for_end(board, player):\n",
    "    return (\n",
    "        check_rows(board, player)\n",
    "        or check_cols(board, player)\n",
    "        or check_diagonals(board, player)\n",
    "    )\n",
    "\n",
    "\n",
    "@njit()\n",
    "def check_rows(board, player):\n",
    "    conv = board.sum(axis=0)\n",
    "    return (np.max(conv * player)) >= STRIKE\n",
    "\n",
    "\n",
    "@njit()\n",
    "def check_cols(board, player):\n",
    "    conv = board.sum(axis=1)\n",
    "    return (np.max(conv * player)) >= STRIKE\n",
    "\n",
    "\n",
    "@njit()\n",
    "def check_diagonals(board, player):\n",
    "    conv = np.multiply(board, KERNEL_D1).sum()\n",
    "    conv2 = np.multiply(board, KERNEL_D2).sum()\n",
    "    return (conv * player) >= STRIKE or (conv2 * player) >= STRIKE\n",
    "\n",
    "\n",
    "@njit()\n",
    "def can_make_move(board, row, col):\n",
    "    return board[row][col] == 0\n",
    "\n",
    "\n",
    "@njit()\n",
    "def get_possible_moves(board):\n",
    "    res = []\n",
    "    for j, row in enumerate(board):\n",
    "        for i, cel in enumerate(row):\n",
    "            if can_make_move(board, j, i):\n",
    "                res.append((j, i))\n",
    "\n",
    "    return res\n",
    "\n",
    "\n",
    "def print_board(board):\n",
    "    str_line = \"---------------\"\n",
    "    print(\"\\n\" + str_line)\n",
    "    for row in board:\n",
    "        for cell in row:\n",
    "            symbol = CHARS[cell]\n",
    "            print(f\"| {symbol} |\", end=\"\")\n",
    "        print(\"\\n\" + str_line)\n",
    "        \n",
    "def opponent(player: int):\n",
    "    return PLAYER_1 if player == PLAYER_2 else PLAYER_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funkcje ewaluujące dla tzw. \"sanity check\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_outcome_distribution(\n",
    "    N: int, player1: int, player2: int, verbose=True\n",
    ") -> np.ndarray:\n",
    "    outcomes = np.zeros(3)\n",
    "\n",
    "    for i in range(N):\n",
    "        game = TicTacToe(player1=player1, player2=player2, size=SIZE)\n",
    "        outcome = game.play(verbose=False)\n",
    "        match outcome:\n",
    "            case \"win\":\n",
    "                outcomes[0] += 1\n",
    "            case \"loss\":\n",
    "                outcomes[1] += 1\n",
    "            case \"draw\":\n",
    "                outcomes[2] += 1\n",
    "        if verbose:\n",
    "            print(f\"Completed games: {i+1}/{N} - {(i+1)/N:.2%}\\r\", end=\"\")\n",
    "\n",
    "    return outcomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def plot_outcome_distribution(N: int, outcomes: np.ndarray) -> None:\n",
    "\n",
    "    percentages = (outcomes / N) * 100\n",
    "\n",
    "    labels = [\"Wins\", \"Losses\", \"Draws\"]\n",
    "\n",
    "    plt.figure(figsize=(4, 3))\n",
    "    plt.bar(\n",
    "        labels,\n",
    "        percentages,\n",
    "    )\n",
    "    plt.xlabel(\"Outcomes\")\n",
    "    plt.ylabel(\"Percentage\")\n",
    "    plt.title(f\"Outcome Distribution over {N} Games\")\n",
    "    plt.ylim(0, 110)\n",
    "    for i, v in enumerate(percentages):\n",
    "        plt.text(i, v + 2, f\"{v:.1f}%\", ha=\"center\", va=\"bottom\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LG3l858uNpxe"
   },
   "source": [
    "## Interfejs gracza\n",
    "\n",
    "Skoro mamy już zdefiniowaną grę to teraz potrzebny jest nam gracz. Poniżej zdefiniowany jest interface PlayerInreface. Należy go wykorzystywać implementując swoich graczy. Interfejs ma metodę `move`, która reprezentuje pojedynczy ruch gracza a także metodę `name`, która zwraca nazwę zaimplementowanego algorytmu.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:47:39.708616Z",
     "start_time": "2022-11-08T12:47:39.697099Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-02T20:42:49.370451Z",
     "iopub.status.busy": "2025-01-02T20:42:49.368451Z",
     "iopub.status.idle": "2025-01-02T20:42:49.376983Z",
     "shell.execute_reply": "2025-01-02T20:42:49.375989Z",
     "shell.execute_reply.started": "2025-01-02T20:42:49.370451Z"
    },
    "id": "9jjdHPZTJT04"
   },
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "\n",
    "class PlayerInterface(ABC):\n",
    "    @abstractmethod\n",
    "    def move(self, board, player, verbose=True):\n",
    "        pass\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return type(self).__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J42IHI35OpJI"
   },
   "source": [
    "Zobaczmy, jak wyglądałby prawdopodobnie najprostszy gracz do zaimplementowania, a więc gracz losowy. Wybiera on losowo wiersz i kolumnę, a następnie sprawdza, czy pole jest puste. Jeżeli tak, to stawia tam swój znak.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:48:27.405379Z",
     "start_time": "2022-11-08T12:48:27.392789Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-02T20:42:51.894494Z",
     "iopub.status.busy": "2025-01-02T20:42:51.893493Z",
     "iopub.status.idle": "2025-01-02T20:42:51.900774Z",
     "shell.execute_reply": "2025-01-02T20:42:51.899780Z",
     "shell.execute_reply.started": "2025-01-02T20:42:51.894494Z"
    },
    "id": "MZj-A7-VKeX7"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "class RandomPlayer(PlayerInterface):\n",
    "    def move(self, board, player, verbose=True):\n",
    "\n",
    "        moves = get_possible_moves(board)\n",
    "\n",
    "        if moves:\n",
    "            move = random.choice(moves)\n",
    "            board[move] = player"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LdJ3LAc2PGqE"
   },
   "source": [
    "Sprawdźmy, czy wszystko działa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:48:42.288896Z",
     "start_time": "2022-11-08T12:48:42.275525Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "execution": {
     "iopub.execute_input": "2025-01-02T21:01:43.522230Z",
     "iopub.status.busy": "2025-01-02T21:01:43.522230Z",
     "iopub.status.idle": "2025-01-02T21:01:43.531555Z",
     "shell.execute_reply": "2025-01-02T21:01:43.531555Z",
     "shell.execute_reply.started": "2025-01-02T21:01:43.522230Z"
    },
    "id": "tpmJkAoqJNos",
    "outputId": "fec813bb-ea1f-4417-cfe6-e04be5ea4097"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "|   || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "|   || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "|   || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "player 1 wins\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'win'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game = TicTacToe(RandomPlayer(), RandomPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y3jmIj-MPSpe"
   },
   "source": [
    "Napiszemy teraz kilku kolejnych graczy, podejmujących decyzje nieco inteligentniej, a na koniec zrobimy mały turniej i sprawdzimy, który jest najlepszy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XswYIAZOPzT-"
   },
   "source": [
    "# Podejmowanie decyzji oparte o heurystykę\n",
    "\n",
    "W każdym nowym problemie warto sprawdzić proste podejście heurystyczne, wykorzystujące elementarną wiedzę o problemie. Sama gra w kółko i krzyżyk, jak wiadomo, nie jest zbyt skomplikowana. Jest w niej najwyżej 9 możliwych ruchów, mniej niż $3^9 - 1$ możliwych końcowych stanów planszy, a naiwnie licząc, grę można rozegrać na $9!$ sposobów. Dzięki tam mocnemu uproszczeniu istnieje tu strategia optymalna, gwarantująca w najgorszym wypadku remis:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cwayvozxWmAW"
   },
   "source": [
    "Dla tej gry istnieje [optymalna startegia](https://en.wikipedia.org/wiki/Tic-tac-toe#Strategy) tzn. w najgorszym przypadku zremisujemy.\n",
    "\n",
    "1. Win: If the player has two in a row, they can place a third to get three in a row.\n",
    "2. Block: If the opponent has two in a row, the player must play the third themselves to block the opponent.\n",
    "3. Fork: Cause a scenario where the player has two ways to win (two non-blocked lines of 2).\n",
    "4. Blocking an opponent's fork: If there is only one possible fork for the opponent, the player should block it. Otherwise, the player should block all forks in any way that simultaneously allows them to make two in a row. Otherwise, the player should make a two in a row to force the opponent into defending, as long as it does not result in them producing a fork. For example, if \"X\" has two opposite corners and \"O\" has the center, \"O\" must not play a corner move to win. (Playing a corner move in this scenario produces a fork for \"X\" to win.)\n",
    "5. Center: A player marks the center. (If it is the first move of the game, playing a corner move gives the second player more opportunities to make a mistake and may therefore be the better choice; however, it makes no difference between perfect players.)\n",
    "6. Opposite corner: If the opponent is in the corner, the player plays the opposite corner.\n",
    "7. Empty corner: The player plays in a corner square.\n",
    "8. Empty side: The player plays in a middle square on any of the four sides.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C6vDkBNIWnL-"
   },
   "source": [
    "Implementacja takiego bota byłaby jednak niezbyt ciekawa, a na dodatek specyficzna tylko dla tego konkretnego problemu. Dlatego my zajmiemy się eksploracją drzewa gry, a więc możliwych stanów oraz przejść między nimi. Na dobry początek ulepszymy naszego losowego bota trywialną heurystyką - jeżeli to możliwe, ma wybrać ruch wygrywający, a jeżeli nie, to losowy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pyf6g0Yk_Nl0"
   },
   "source": [
    "Można by też zadać pytanie, czemu nie wykorzystamy tutaj ciekawszego problemu, jak np. szachy. Odpowiedź jest prosta - nie mamy na to czasu, a konkretnie wieczności. Shannon obliczył dolną granicę złożoności drzewa gry na $10^{120}$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "vTFRQSKP_Nl1",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Wygraj, jeśli to możliwe w kolejnym kroku\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "YGzaz4P8HEt2",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "source": [
    "## Zadanie 1 (0.5 punkt)\n",
    "\n",
    "Zaimplementuj ulepszonego losowego bota tak, aby wybierał ruch wygrywający, jeżeli to możliwe, a jeżeli nie, to losowy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:52:07.330742Z",
     "start_time": "2022-11-08T12:52:07.322516Z"
    },
    "editable": true,
    "execution": {
     "iopub.execute_input": "2025-01-02T20:59:21.702009Z",
     "iopub.status.busy": "2025-01-02T20:59:21.701004Z",
     "iopub.status.idle": "2025-01-02T20:59:21.709770Z",
     "shell.execute_reply": "2025-01-02T20:59:21.708774Z",
     "shell.execute_reply.started": "2025-01-02T20:59:21.701004Z"
    },
    "id": "jzvSXtGQNmm5",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [],
   "source": [
    "class RandomPlayerWinIfCan(PlayerInterface):\n",
    "    def move(self, board, player, verbose=True):\n",
    "        # your_code\n",
    "        moves = get_possible_moves(board=board)\n",
    "\n",
    "        for move in moves:\n",
    "\n",
    "            board[move] = player\n",
    "\n",
    "            if check_for_end(board=board, player=player):\n",
    "                if verbose:\n",
    "                    print(f\"\\nPlayer {CHARS[player]} takes the win with move {move}\")\n",
    "                break\n",
    "\n",
    "            board[move] = 0\n",
    "        else:\n",
    "            if moves:\n",
    "                move = random.choice(moves)\n",
    "                board[move] = player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "editable": true,
    "execution": {
     "iopub.execute_input": "2025-01-02T21:02:18.247479Z",
     "iopub.status.busy": "2025-01-02T21:02:18.247479Z",
     "iopub.status.idle": "2025-01-02T21:02:18.257320Z",
     "shell.execute_reply": "2025-01-02T21:02:18.256320Z",
     "shell.execute_reply.started": "2025-01-02T21:02:18.247479Z"
    },
    "id": "FV4COOFCfwm-",
    "outputId": "cfe29a70-90bc-4e4c-ab8f-9bb8d8353282",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "\n",
      "Player O takes the win with move (0, 1)\n",
      "\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "player 1 wins\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'win'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game = TicTacToe(RandomPlayerWinIfCan(), RandomPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n_9YHPHnhzsu"
   },
   "source": [
    "## Blokuj kolejny krok wygrywający przeciwnika\n",
    "\n",
    "Skoro w poprzednim zadaniu wygrywamy, kiedy możemy to zrobić w jednym kroku, to spróbujmy ulepszyć naszą strategię wcześniej. Możemy to zrobić, minimalizując swoje straty, czyli sprawdzamy dodatkowo, czy przeciwnik może skończyć grę. Jeżeli tak, to go blokujemy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "VHNF5ladHIeW",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "source": [
    "## Zadanie 2 (0.5 punkt)\n",
    "\n",
    "Zaimplementuj ulepszenie bota, w którym dodatkowo jeżeli nie możemy wygrać w danym ruchu, a przeciwnik tak, to go blokujemy. A jeżeli ani my, ani przeciwnik nie może wygrać w kolejnym ruchu, to wykonujemy losowe posunięcie.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-07T15:57:48.581936Z",
     "start_time": "2022-11-07T15:57:48.568842Z"
    },
    "editable": true,
    "id": "8PDreIKxhzM1",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [],
   "source": [
    "class Blocking(PlayerInterface):\n",
    "\n",
    "    def move(self, board, player, verbose=True):\n",
    "        # your_code\n",
    "\n",
    "        opp = opponent(player=player)\n",
    "        moves = get_possible_moves(board=board)\n",
    "\n",
    "        for move in moves:\n",
    "            board[move] = player\n",
    "            if check_for_end(board=board, player=player):\n",
    "                if verbose:\n",
    "                    print(f\"\\nPlayer {CHARS[player]} takes the win with move {move}\")\n",
    "                break\n",
    "            board[move] = 0\n",
    "        else:\n",
    "            for move in moves:\n",
    "                board[move] = opp\n",
    "                if check_for_end(board=board, player=opp):\n",
    "                    board[move] = player\n",
    "                    if verbose:\n",
    "                        print(\n",
    "                            f\"\\nPlayer {CHARS[player]} blocking opponent {CHARS[opp]} with move {move}\"\n",
    "                        )\n",
    "                    break\n",
    "                board[move] = 0\n",
    "            else:\n",
    "                move = random.choice(moves)\n",
    "                board[move] = player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "editable": true,
    "id": "4WcJ9OcvjyDP",
    "outputId": "51e4d3a9-de1f-4c12-f08a-7043a3781ca8",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "\n",
      "Player X takes the win with move (0, 0)\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "player 2 wins\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'loss'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game = TicTacToe(RandomPlayerWinIfCan(), Blocking(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yWzDAt-rkdzG"
   },
   "source": [
    "# Algorytm minimax\n",
    "\n",
    "Zaiplemetujemy teraz algorytm minimax. Minimalizuje on nasze maksymalne straty lub maksymalizuje minimalne zyski (maksmin). Poprzednie 2 kroki nas do tego zbliżały. Algorytm wywodzi się z teorii gier o sumie zerowej (gdzie wygrana ma wartość 1, przegrana -1, a remis 0 - w takich grach wygrana jednego gracza, oznacza, że drugi gracz przegrał, czyli nie ma strategii, która prowadziłaby do sytuacji _win-win_).\n",
    "\n",
    "**Twierdzenie o minimaksie (minimax theorem)** mówi, że dla każdej gry dwuosobowej gry o sumie zerowej istnieje wartość V i mieszana strategia dla każdego gracza, takie, że:\n",
    "\n",
    "- biorąc pod uwagę strategię gracza drugiego, najlepszą możliwą spłatą dla gracza pierwszego jest V,\n",
    "- biorąc pod uwagę strategię gracza pierwszego, najlepszą możliwą spłatą dla gracza drugiego jest -V.\n",
    "\n",
    "Każdy gracz minimalizuje maksymalną możliwą spłatę dla swojego przeciwnika – ponieważ gra jest grą o sumie zerowej, wynikiem tego algorytmu jest również maksymalizowanie swojej minimalnej spłaty.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VD2j-ZOUcj1D"
   },
   "source": [
    "![obraz.png](data:image/png;base64,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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "enBwAeNS_Nl6"
   },
   "source": [
    "Powyższa ilustracja przedstawia fragment analizy końcowej partii gry w kółko i krzyżyk. **Max** oznacza turę,\n",
    "w której gracz wybiera ten spośród dostępnych ruchów, który da maksymalną spłatę, natomiast **min** oznacza turę,\n",
    "w której gracz wybiera ruch, który da minimalną spłatę. Inaczej - _max_ to ruch, z punktu wiedzenia gracza,\n",
    "dla którego chcemy, żeby wygrał, a _min_ ruch gracza, który chcemy żeby przegrał.\n",
    "\n",
    "Minimax jest algorytem rekurencyjnym, w którym liście drzewa możliwych ruchów\n",
    "oznaczają zakończenie gry, z przypisaną do nich wartością z punktu wiedzenia gracza, którego ruch jest w korzeniu\n",
    "drzewa możliwych ruchów. We wcześniejszych węzłach - w zależności czy jest tura gracza max, czy min, będą wybierane te gałęzie, które maksymalizują, bądź minimalizują wartość spłaty.\n",
    "\n",
    "Przykładowo - w pierwszym wierszu mamy trzy strzałki i gracza _max_, dlatego gracz ten wybierze pierwszy\n",
    "możliwy ruch, bo daje on maksymalną spłatę. W drugim wierwszu w środkowej kolumnie mamy dwie strzałki.\n",
    "Gracz _min_ wybierze zatem strzałkę (ruch) prawy, ponieważ minimalizuje on spłatę (0).\n",
    "Analogicznie w drugim wierszu po prawej stronie wybierana jest prawa strzałka,\n",
    "ponieważ daje ona wartość mimalną (-1).\n",
    "\n",
    "Poniższy diagram zawiera to samo drzewo analizy ruchów, gdzie pozostawiono wyłącznie wartości spłaty dla\n",
    "poszczególnych węzłów.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EhcLPgilck3K"
   },
   "source": [
    "![obraz.png](data:image/png;base64,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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e8jeFFz5pniS"
   },
   "source": [
    "Algorytm _minimax_ jest następujący:\n",
    "\n",
    "1. zainicalizuj wartość na $-\\infty$ dla gracza którego spłata jest maksymalizowana\n",
    "   i na $+\\infty$ dla gracza którego spłata jest minimalizowana,\n",
    "2. sprawdź czy gra się nie skończyła, jeżeli tak to ewaluuj stan gry z punktu widzenia gracza maksymalizującego i zwróć wynik,\n",
    "3. dla każdego możliwego ruchu każdego z graczy wywołaj rekurencyjnie _minimax_:\n",
    "4. przy maksymalizacji wyniku, zwiększ wynik, jeśli otrzymany wynik jest większy od dotychczas największego wyniku,\n",
    "5. przy minimalizacji wyniku, pomniejsz wynik, jeśli otrzymany wynik jest mniejszy od dotychczas najmniejszego wyniku,\n",
    "6. zwróć najlepszy wynik.\n",
    "\n",
    "Algorytm ten wymaga dodatkowo funkcji ewaluującej, która oceni stan gry na końcu. Uznajemy, że zwycięstwo to +1, przegrana -1, a remis 0.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "2VgIulyIHRYn",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "source": [
    "## Zadanie 3 (2 punkty)\n",
    "\n",
    "Zaimplementuj gracza realizującego algorytm minimaks.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funkcja ewaluująca"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval(board: np.ndarray, player: int, is_maximizing: bool) -> int | None:\n",
    "\n",
    "    is_finished: bool = check_for_end(board=board, player=player)\n",
    "\n",
    "    if is_maximizing and is_finished:\n",
    "        return 1\n",
    "    elif not is_maximizing and is_finished:\n",
    "        return -1\n",
    "    elif not get_possible_moves(board=board):\n",
    "        return 0\n",
    "    else:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu minimax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:56:05.603012Z",
     "start_time": "2022-11-08T12:56:05.576605Z"
    },
    "editable": true,
    "id": "8mpF72tLkdR-",
    "slideshow": {
     "slide_type": ""
    }
   },
   "outputs": [],
   "source": [
    "from math import inf\n",
    "from copy import deepcopy\n",
    "\n",
    "\n",
    "def minimax(\n",
    "    board: np.ndarray, player: int, is_maximizing: bool = True\n",
    ") -> tuple[int, tuple[int, int] | None]:\n",
    "\n",
    "    opp = opponent(player=player)\n",
    "\n",
    "    state = eval(board=board, player=opp, is_maximizing=(not is_maximizing))\n",
    "\n",
    "    if state is not None:\n",
    "        return state, None\n",
    "\n",
    "    best_move = None\n",
    "    best_eval = -inf if is_maximizing else inf\n",
    "\n",
    "    for move in get_possible_moves(board=board):\n",
    "\n",
    "        new_board = deepcopy(board)\n",
    "        new_board[move] = player\n",
    "\n",
    "        current_eval, _ = minimax(\n",
    "            board=new_board, player=opp, is_maximizing=(not is_maximizing)\n",
    "        )\n",
    "\n",
    "        if (is_maximizing and current_eval > best_eval) or (\n",
    "            not is_maximizing and current_eval < best_eval\n",
    "        ):\n",
    "            best_eval = current_eval\n",
    "            best_move = move\n",
    "\n",
    "    return best_eval, best_move"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MinimaxPlayer(PlayerInterface):\n",
    "    def move(self, board, player, verbose=True):\n",
    "        # your_code\n",
    "\n",
    "        best_eval, best_move = minimax(board=board, player=player, is_maximizing=True)\n",
    "\n",
    "        if verbose:\n",
    "            print(\n",
    "                f\"\\nBest move for {CHARS[player]} with score {best_eval} is {best_move}\"\n",
    "            )\n",
    "\n",
    "        if best_move is not None:\n",
    "            board[best_move] = player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "editable": true,
    "id": "iwrRdk8DRbFP",
    "outputId": "e878f500-4c49-4195-e227-cf474532dbd0",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Best move for O with score 0 is (0, 0)\n",
      "\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "\n",
      "Best move for O with score 1 is (0, 2)\n",
      "\n",
      "---------------\n",
      "| O ||   || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "\n",
      "Player X blocking opponent O with move (0, 1)\n",
      "\n",
      "---------------\n",
      "| O || X || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "\n",
      "Best move for O with score 1 is (2, 0)\n",
      "\n",
      "---------------\n",
      "| O || X || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "\n",
      "Player X blocking opponent O with move (1, 0)\n",
      "\n",
      "---------------\n",
      "| O || X || O |\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "\n",
      "Best move for O with score 1 is (1, 1)\n",
      "\n",
      "---------------\n",
      "| O || X || O |\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "player 1 wins\n",
      "Wall time: 5.05 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'win'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "game = TicTacToe(player1=MinimaxPlayer(), player2=Blocking(), size=SIZE)\n",
    "game.play(verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed games: 10/10 - 100.00%\r"
     ]
    }
   ],
   "source": [
    "outcomes = get_outcome_distribution(N=10, player1=MinimaxPlayer(), player2=Blocking())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_outcome_distribution(N=10, outcomes=outcomes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tIylZm4rYfsI"
   },
   "source": [
    "Wróć na chwilę do implementacji minimaxu i zastanów się, co się dzieje, jeżeli ten algorytm wykonuje ruch na pustej planszy i jak to wpływa na jego czas działania. Może coś można poprawić?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Tworzy całe drzewo stanów, co w pewnych przypadkach może być nieoptymalne. Niektóre gałęzie można obicinać wcześniej, jeżeli nie mają wpływu na wynik (pruning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n5sntoLbaKhT"
   },
   "source": [
    "# Alpha-beta pruning\n",
    "\n",
    "Widzimy, że nasz poprzedni gracz jest właściwie idealny, bo w końcu sprawdza całe drzewo gry. Ma tylko w związku z tym wadę - dla większości problemów wykonuje się wieczność. Dlatego też zastosujemy ważne ulepszenie algorytmu minimax, nazywane alfa-beta pruning.\n",
    "\n",
    "W przypadku klasycznego minimaxu ewaluujemy każdą możliwą ścieżkę gry. Alfa-beta pruning, jak i wiele innych metod, opiera się na \"przycinaniu\" drzewa, czyli nie ewaluujemy tych odnóg drzewa, co do których wiemy, że nie da ona lepszego wyniku niż najlepszy obecny. W niektórych wypadkach, np. w dobrej implementacji dla szachów, potrafi zredukować liczbę rozważanych ścieżek nawet o 99.8%.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U1_6NI9-s3DM"
   },
   "source": [
    "Do poprzedniego algorytmu dodajemy 2 zmienne, $\\alpha$ i $\\beta$:\n",
    "\n",
    "- $\\alpha$ przechowuje najlepszą wartość dla gracza maksymalizującego swój wynik,\n",
    "- $\\beta$ przechowuje najlepszą wartość dla gracza minimalizującego swój wynik.\n",
    "\n",
    "Dzięki tej informacji możemy przerwać sprawdzanie danej gałęzi, kiedy $\\alpha$ jest większa od $\\beta$. Oznacza to bowiem sytuację, w której najlepszy wynik gracza maksymalizującego jest większy niż najlepszy wynik gracza minimalizującego.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lJ7JYyxRw6VN"
   },
   "source": [
    "![obraz.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAlgAAAEwCAYAAABrKQ92AAAgAElEQVR4nOzdZ1hT1x8H8JMBCTtA2KAoQ0URRakLreIsjrqtVeto615URXDgoFZba9W21to6W1urdWuto666rXuhIqiAe4HMyPj+X1DyhzKSAMlJwi/P83lh7sjv3ISTr7n3nsMYYyCEEEIIIZWKewGEEEIIIcbm//8InzcXi9etJoQQQgghGnqnR/eSA9ah65eQCAUhhBBCCNHQpDlRFLAIIYQQQioTBSxCCCGEkEpGAYsQQgghpJJRwCKEEEIIqWQUsAghhBBCKhkFLEKISlv+Pojlm37ViX2X/uHeXkIIqSgKWIQQlVp36qCzAfk+DhvPvb2EEFJRFLAIISq17tQBjRs3RlxcnFbJZDIKWIQQo0ABixCiUutOHRAcHAxtP+zt7SlgEUKMAgUsQohKFLAIIUQzFLAIISpRwCKEEM1QwCKEqEQBixBCNEMBixCiEgUsQgjRDAUsQohKmgSs5ORkREZGwtfXFxKJBLa2tmjZsiX27NlDAYsQUmVQwCKEqKRuwEpKSoK3tzeEQiFCQ0MRHh6OSZMmoXPnzoiOjqaARQipMihgEUJUUjdghYSEwNraGidOnFC5LgUsQogxo4BFCFFJnYB18uRJMMbw6aefAgCysrKQkpJCAYsQUiVRwCKEqKROwJoxYwYYY9iyZQs6dOgAgUAAxhg8PDzwzTffUMAihFQpFLAIISqpE7B69+4NxhjkcjmaNGmCNWvWYNWqVWjUqBEYY5gzZw4FLEJIlUEBixCikjoBq2PHjmCMwcvLCwqFQvl8RkYGPDw8IJVK8eLFCwpYhJAqgQIWIUQldQJW9+7dwRhDVFRUsWXh4eFgjGHXrl0UsAghVQIFLEKISuoErLFjx4IxhuXLlxdbtnjxYjDGsG7dOgpYhJAqgQIWIUQldQLW+vXrwRhDZGRksWVhYWFgjGHv3r0UsAghWtO1Xx8wxjB80sRiy9p2fgeMMYybHlFs2cZD+8EYQ9d+fYo8fy8nAwFBjdG1b+8iz194lACZnR3mLP2q1FooYBFCVFInYKWkpEAmk8HV1RXJycnK51+8eAG5XA4bGxukpqZSwCKEaE3Xfn3g6uEOB2cn3M1OVz5/4VECTCUSOLo4lxiweg58HwFBjWEqkeDay8dFlh26fgmmEgm+/32D8rn2XTuj6dutkJCXVWotFLAIISqpO9DounXrwBiDt7c3oqOjMXfuXHh6eoIxhlWrVqncngIWIaQiuvbrg679+sDT2wtrdm1TPj/9i/lo2/kd+AXULxawYlKeQWpmhl1njsPHrw4+/XZpsf1GLpgHewcHXHqahK/WroS5hQVOxt8qsxYKWIQQlTSZi3D37t0IDg6GhYUFzM3NERwcjN27d6u1LQUsQkhFFASs8E/nILRXD+XzPn518P3vG0oMWPO//xa16tVFIhSIWvQF/AMbFtvvvZwMNGzyFlp36gBrmQzzlhUPYf9FAYsQopImAasiDwpYhJCKKAhYZxLiIJFKceX5Q+w6cxwyOzvEK1JLDFgN3gpC1FcLkQgFLj1NgompKfZfPlds33vOnQJjDEEtmpd5arAABSxCiEoUsAghhqAgYCVCgZbt22Lu14sxaNQIDBk7ColQFAtYB69dhImpKS4/e6B8rnPvnvhwwthi+/5g9EiYmZvDTi7HxSdJKmuhgEUIUYkCFiHEEBQOWN/++hPq1PeHja0t9pw7hUQUD1gffzIBjDGIRCIloVAIO7kc8YpU5XobD+2HWCzGthNH0OCtIHTu3VNlLRSwCCEqUcAihBiCwgHrTmYKrGUy1Pavp1xeOGDdfZMGuaMDZi9ZhL+uXijC3sEBKzb/hkQocDP1Bdw9q2NU+CQkouS7CktCAYsQohIFLEKIISgcsBKhwI3kp7iZ+kL578IB68etmyCRSossL/Deh0MREtoJiVBg0Mjh8K5dC3cyU5TLI+Z/CrmjA648f1hqLRSwCCEqte7UAe7u7pg6dapWmZmZUcAihJTbfwPWfxUOWO26hKJ9ty4lrvfTnp0QiURY8tNqiMVi7Dj1d5HlBQOQdnuvb6mvRQGLEFKqy88eYPaSRbC1t4dYLIZYLIZEKoGFpSVsZDLIbG1LJDUzg4mJSanLZba2sLGVwdLKClKpVLlvsYkJGjVrgqO3rnFvOyGEVAQFLEJIEbfTX2HxulVo1yUUphIJGGPwD2yI2UsW4WxivFr7GDRyOFzc3dR+zdiMZCzf9CvadQmF2MQEjDH4+NVB5IJ5uPAogfsxIYQQTVHAIoQgIS8Lvx74E70GDYC1TAbGGNw9qyNs1gwcvHZR4/1pGrAKu/L8IRasWIagFs0hEAggFAoR1KI5FqxYhpiUZ9yPFSGEqIMCFiFV2N6LZzFs/Bi4eriDMQZLa2sMGP4Rth47hPu5meXeb0UCVmGn7sUicsE8eNXyBWMMEqkU7bqEYvmmX4vcQk0IIfqGAhYhVcz5h/cRuWAefPzqgDEGE1NTdOnTC6t3bi1yl0xFVFbAKuzgtYsYPXUyHF2cwRiDtUyGXoMG4NcDf1YoDBJCiDZQwCKkCoh5/Vx52k0oFEIgEKBluxAsXreq2MzxlUEbAavA/dxMbD12CAOGfwRLa2swxuDi7oZh48dg67FD3I81IYQkggIWIUbr7ps05YXjEqkUjDHU9PVB5IJ5OH3/jlZfW5sBq7A7mSlYvXMruvTpBRNTU+XF8WGzZuD4nRju7wEhpOqigEWIEUnIy1L+uiOzswNjDHInR4yeOrlcF6uXl64CVmHXXz1R3v0oEony735sFIjZSxapNW8YIYRUJgpYhBiBv29fx+ipk+FevRoYY7CwtFRen3QvJ0Pn9fAIWIX9k3QXs5csQlCL5sp5xgpOiZY0ajMhhFQ2CliEGKiLT5Iwe8ki+DcKBGMMYrFYeYddbEYy19p4B6zCDl2/hLBZM+Dp7QXGGKRmZsqL+u++SeNeHyHEOFHAIsSA3Ep7icXrVqFluxDlabCCMaLKmhNL1/QpYBW259wpDBs/BnInRzDGILOzUw5LkZCXxb0+QojxoIBFiJ67m52O1Tu3otegAcq75qp71UTYrBk4fOMy9/pKoq8Bq8C9nAzlwKoWlpZgjMGtmgdGT52MwzFXuNdHCDF8FLAI0VNbjx3CsPFj4OTqAsYY7B0cMGz8GOw5d4p7baroe8AqrLRpesJmzcCpu7e510cIMUwUsAjRIyfibiJs1gzlIKBm5uboNWgAVu/ciris19zrU5chBazCrr54pDwFW3iantlLFuHyswfc6yOEGA4KWIRwdvnZA+Udb0KhECKRCO26hGLxulW4kfyUe33lYagBq7AzCXGYvWQR6jVsAMYYTCUS5ftyO/0V9/oIIfqNAhYhHMQrUpWnpUwlkvwxmwIbYvaSRTibGM+9vooyhoBV2MFrFxE2awY8aniCMQYrGxvlL4t3s9O510cI0T8UsAjRkYS8LOWF1dYyGRhjcPesjrBZM3Q6CKguGFvAKlAwTc+w8WNgJ5eDMQYnVxeapocQUgwFLEK0bO/Fsxg2fgxcPdzBGIOltbVyaABjnaTYWANWYXFZr5V3d5pbWIAxBu/atRA2awb+vn2de32EEL4oYBGiBecf3kfkgnnKi9VNTE2Vg1veyUzhXp+2VYWAVdiN5KfKaXrEYrHyTsTIBfNw4VEC9/oIIbpHAYuQShLz+jkWrFimvFhdIBAoBwG99vIx9/p0qaoFrMLOPbinvGlBIBBAJBIpPwcxr59zr48QohsUsAipgLtv0rB651Z06dMLEqkUjDHU9PVB5IJ5OH3/Dvf6eKnKAauwU3dvI3LBPNT09QFjDBKpVDmdUbwilXt9hBDtoYBFiIYS8rKw9dghDBj+EWR2dmCMQe7kiNFTJxvdxerlRQGruIPXLmL01MlwcHYCYww2trbKCblpmh5CjA8FLELU9Pft6xg9dTLcq1cDYwwWlpbKL8h7ORnc69MnFLBKV3An4oDhHymnPnJxd8sfpf/8ae71EUIqBwUsQspw8UkSZi9ZBP9GgWCMQSwWK0/xxGYkc69PX1HAUs+dzBTlKWYTU9Mi0/SciLvJvT5CSPlRwCLkP26lvVROlyISicAYU06Xcv7hfe71GQIKWJq7/uqJ8nMnFAqLTNNz6WkS9/oIIZqhgEUIFLibna4c06jgtE11r5oImzUDh29c5l6foaGAVTFnE+OL/HIqEonQsl0IFq9bhZupL7jXRwhRrdSAdfDwb4i/e5wQo7Zp8zIMGdoHTk75o3Lb2ckwZGgf7Ni5intthmzAwO5wdnbgXocx2Lf/J4yfMBTVqruBMQapVILQ0BD8uOpz3Io9zL0+QkjJIqaNLTlgXbu+D7mIJ8ToxMYdQdSsCfDzy7913tzcDAMH9cCOnT8iI+sm9/qMwYiRA+Du7sy9DmNz9txOjBs/BI6O9mCMwd7eFh8P74+jxzYhJy+Oe32EkP+bPWciBSxi/J48O4/FS2aiRYtGyutb2rZrgbXrvsTL5Mvc6zM2FLC0601OLPYf+BkDB/WApaV5/int6m4InzoSN27+xb0+QggFLGLEMhW3sHHTt+jcJQQSSf4dWg0b1sXiJTNxP/Ek9/qMGQUs3UnLuKH8nJuY5E/T4+fng/kLwpH08DT3+gipqihgEaOSkxen/J+9TJZ/sbqnpzuiZk3AlWv0mdYVClh8PHtxAd+vmIcWLRpBIBBAKBSiRYtG+H7FPLxKucK9PkKqEgpYxCicv7gb48YPgYeHCxhjsLa2VF6bkp17h3t9VQ0FLP7u3j+O+QvCUbu2V/40PRJTdO4SgrXrvkRq+nXu9RFi7ChgEYOV9PA05i8IV16sbmpqgt59QrFj549Iz4zhXl9VRgFLv1y5tg9RsybA09MdjDHIZNbKGzsU2bHc6yPEGFHAIgYl+fVV5SkQoVAIgUCgPAXy/OVF7vWRfBSw9FN27h0cPbYJ48YPgVxuC8YY3NycMW78EBw9tol7fYQYEwpYRO9lvbmNHTt/RO8+oZBKJWCMwde3BuYvCMfd+8e510eKo4Cl/zKybmLHzh8xcFAPmJubgTGGOnW8ETVrAm7FHuZeHyGGjgIW0Us5eXE4emwTPh7eH3Z2MjDG4OQkR/jUkXSxugGggGVYXiZfxtp1X6JzlxCIxfnTQzVqVA+Ll8zEw8dnuddHiCGigEX0ys3bhxA+dSSq/ztqtaWlOQYO6oH9B37Gmxy6VsRQUMAyXIkPTinHjCuYpqdgzLjk11e510eIoaCARbh79OQfLF4yE40a1QNjDGKxCJ27hGDjpm+RlnGDe31EcxSwjMO1G/sRNWsCfHw8ldP0FPxtZr25zb0+QvQZBSzCxeu0a1i77ku0bdcCIlH+KYkWLRph8ZKZNDiiEaCAZXwKpulxdnYAYwy2tjbKX5dpmh5CiqOARXRGkR2rvKjW2toSjDF4eVVD1KwJuHZjP/f6SOWhgGW83uTEKq+PtLKyAGMMHh4uGDd+CM5d2MW9PkL0BQUsonUFt4W7ujqBMQYHBzuMGz8EZ8/t5F4b0Q4KWFVDemaM8g5fU1MT5TQ9UbMmIDbuCPf6COGJAhYpF1UXnMfGHUHUrAnKQUDNzc2UAxtmZN3kXj/RLgpYVc/zlxeVp/0LT9OzeMlMPH56rsRt6MYVYswoYBGVrlzbh+hPJ6FlyyDUqOEBicQUIpEIbm7OCAqqj7BPPsSRvzfi4eN/lHcfCYVCCIVC5d1HL5Mvc28H0Z5HT/7Bih8+Q+cuIfDz81FOri2X28HfvzbeH/AuNv2+DK/TrnGvlWjf9ZgDmDFzHLy8qin/gxXauQ1mz5mIli2DULNmNWU/4urqhKCg+pgYNgxH/t5IoYsYDQpYpFRnz+1E23YtwBiDUChE48aNMWzYMERFRWHu3LkYNWoUQkJCIJHkD/5pYWGuvK5qZtR4xNw6yL0NRLsePj6L0WMGwcQk//RQ9erV8f777yM8PBzz58/HxIkT0aNHD9jb2yunaJm/IJzuDq1CVq9diGrV3JT9SKNGjTB06FBlPzJ69Ogi/Ujt2l7YsnU597oJqSgKWKQYRXYsRo8ZBIFAABcXF3z33Xd48uQJSnukpaVhy5YtqF+/PhhjaNuuBZ4+P8+9HUS71v+yBJaWFpBIJJg8eTKuX79e6mckJycHJ0+eRJ8+fcAYQ7Vqrjh9djv3NhDtUWTHYuy4wcp+ZNmyZXj8+HGZ/cjWrVvRoEEDMMbQJqQ5njyjfoQYLgpYpIgXry4pr6GYMmUKUlNTS+0QS/oSXbFiBSwsLODlVZ3uDDRSOXlxmD5jLAQCAdq3b487d+6o/RkBgGPHjsHX1xdmZlL8tvEb7u0hle/Fq0to1z4YAoEAkydP1rgf+eGHH2BhYYGaNavhKn0XEQNFAYsoKbJj0SakOSQSCTZu3KjRl2bhx4ULF+Dq6gp3dxeaZsMIzftsChhjGD16NLKzs8v1GXn58iVCQkIgEomwd9867m0ilUeRHYu27VrA1NQUGzZsKHc/cvHiRbi5ucHNzRkPHp3h3i5CNEUBiyhNmDgMAoEAP/30U7k7xcKdo6WlJYKDg6DIpotWjcWeP9dAKBRiwIAByMvLq9BnJDU1FQ0aNICdnQx34o9ybxupHGGffAjGGNauXVvhfuTy5cuwtLRE8+aNqB8hBocCFkEu4nH+4m4IhUJMnjy5wp1iwWPz5s1gjOH7FfO4t49UXEbWTdSo4YFGjRohMzOzUj4jCQkJsLOzQ/ceHbm3j1TchUt/QCgU4pNPPqmUzwcAbN26FYwxfLc8mnv7CNEEBSyCXMSjXftgODk5lXqtxMOHDzFq1Cg0atQIcrkcEokEnp6e6NevH86ePVtq59i2bVs4OzsgJZVuzzd0Xy6aDsYYjh49qvJLMSUlBdOmTUOtWrUgkUhga2uL4OBg7Nq1q9i6CxcuzN/vsU3c20gqpkPHVnB0dMTr169L/FykpqYW/sIpQiQSlfp5at++PZycHGiyaWJQKGAR3Lj5FxhjWLRoUakd3OnTp1GzZk307dsXkyZNwvTp09G3b19IpVKIRCLs2bOnxO1OnjwJxhhWr/mCeztJxdSsWQ3t2rVTEa2ApKQk+Pj4QCgUIjQ0FFOmTMGkSZPQpUsXzJ49u9j6mZmZcHJyQt9+Xbi3kZTfzduHwBjDwoULS/1sFASsoKAgREdHFzFv3rwy+x/GGFau+px7OwlRFwUsgs/mh0MgEODhw4cqvzz/+zh48CAYYwgNDS11nRo1aqBrt3bc20nK78KlP/KD8urVKj8TISEhsLKywokTJ9T+HI0aNQqWlhZIz4zh3lZSPgs+nwqBQIAHDx6U+j4XBKwRI0ao/dkoePj4+KBzlxDu7SREXRSwCNq2a4FGjRpp3OEBwNOnT8EYQ/fu3UtdZ+zYsbC0tEBOXhz3tpLyWfjlNAgEgjLHMQL+/4tldHQ0ACArKwspKSkqP0e7du0CYwxH/t7Iva2kfNp3aImGDRuW+T4XDlgvX75EYmIi3rx5o/LzAQDjx4+HubkZsnPvcG8r0V99+3UBYwyfTPqo2LLQzm3AGMO06WOKrB/auU2x7RcvmVlk2x9+nA97e1uNaqGAReDt7YlBgwap1cmlp6fj7t27uH37Nvbu3YvWrVvD2toaZ86cKXWb5cuXgzFW6nxkRP+NHTcYcrlc5edjxowZYIxh8+bN6NChAwQCARhj8PDwwJIlS0rd7u7du2CMYd1Pi7i3lZSPr29NDBgwoMzPR0HAKhi1nTEGMzMz9OvXD0lJSWVuu2LFCjDGaOgXUqa+/brAw8MFzs4ORe48ffDoDCQSU7i4OKoMWFKpBA4OdkWuHaaARcrF0tIC4eHhKr88AeD3338vcmGqr68vLl++XOY2O3bsAGMMFy79wb2tpHx69wmFv7+/ys9H7969/52DUI4mTZpgzZo1WLVqFRo1agTGGGbOnFnidgqFAgKBAPMXhHNvKykfa2srlXchp6WlISAgAFFRUVi7di2WLl2Kjh07gjEGNzc3PHr0qNRtC37lPHdhF/e2Ev3Vt18X9O3XBd7e1bFz10rl859/EYHQzm0QEFBHZcDq0bMjatashlmzJyifp4BFykUqlWDatGkqvzwB4MGDB9i2bRt++eUXREREwNbWFg4ODrhw4UKp2/zxR/71O2fP7eTeVlI+3Xt0VHn6B4Dyy9LLywsKhUL5fEZGBjw8PGBqaoqnT58W2y47OxtCoRDRn07i3lZSPubmZoiIiFCrH/nvY9q0aWCMYcyYMaWu8+eff4IxRlMskTIVBKzoTyehZ69Oyuf9/Hyw6fdlagWsvv264Of1i2FlZaGcrokCFimXmjWrYciQIeXqGK9fvw6pVIqgoKBS1/nhhx/AGKPRmA3Y6DGD4OTkpPLz0L17dzDGEBUVVWxZeHg4GGPYtm1bsWUJCQl0t6mB8/b2xAcffKBZB/LvQ6FQwNTUFN7e3qWus3LlSjDGkPjgFPe2Ev1VEJDuJZyAVCrB0+fncerMNtjZyZCpuKV2wMrJi0NAQB1MmDgMuaCARcqpZcsgvP322+XqGAGgZcuWEAgESE9PL3F5REQEJBJTujjVgM37bAqEQqHKOeXGjh0LxhiWL19ebNnixYvBGMOqVauKLTt8+DAYYzjw13rubSXl8/bbTdCyZcvydSIAPD09YWtrW+ryadOmwdTUBG9yaER3UrqCgJSL/PEdl349CyNHDcCYsR8gF/FqB6xcxGP3H6shkZji7v3jFLBI+cyeMxEikQjPnz8vV8cYEBAAgUBQ6ujedev6odM7rbm3k5Tf6bPbwRhTOUfl+vXrwRhDZGRksWVhYWFgjGH37t3Flk2aNAkWFuZIy7jBva2kfOZGfwKRSIRnz55p3Ie8fv0aIpEIfn5+pa7j7++PDh1bcW8n0W+FA9Ivvy5F/fq1YWtro7xERZOAlYv8HyAGD+lNAYuUzz/nd4IxVuYchDdv3ixxYt/NmzdDIBAgODi4xO1iYmLAGMO3y+Zybycpv+zcO3BxcUT//v3L/KJMSUmBTCaDq6srkpOTlc+/ePECcrkc1tbWxYZtyMnJgZeXF7p0bcu9naT8zl/crXIOwri4uGJzWL558waDBg0qNZgD+f0PYwxffzObezuJfisckNIzYyCTWcPfv5ZyuaYB69iJzRCJRJgYNowCFtFcTl4cAgProVatWqWOSTN48GC4ublhwIABiIiIQFhYGNq0yR9TxMbGBhcvXixxuz59+sDKylJ5oSAxXJHTRkMkEuH69eulfoECwLp168AYg7e3N6KjozF37lx4enrmj8S9cmWx9VetWpV/bdb2FdzbSCqmcWN/+Ph4l9qPjBgxAjVq1MCgQYMQGRmJ0aNHw9fXF4wxBAQElDpmWr9+/WBpaYFHT/7h3kai3/4bkF4mXy4y3IKmASsX8ejarR2kUgkFLFI+e/etK3O6nH379qFv376oUaMGzMzMIJFI4OPjgzFjxuD+/fslbnPs2DEIBIIit7oSw/Xi1SXY2cnQoUMH5Obmlhmydu/ejeDgYFhYWMDc3BzBwcElnhp89eoVPDw80KxZIPf2kYrbf+DnMqfL2blzJ7p27QoPDw9IJBKYmZmhfv36mDt3bqnXcJ44cQICgQAzo8Zzbx/RfyUFpMLKE7CuXNsHoVBIAYuUX89enWBiYqLWZL6qHg8ePICLiwtq1/aiCVqNyI8rF5Q5npUmj5ycHLzzzjuQSiU4888O7m0jlaN3n1CYmJjg8OHDFf6MPHz4EK6uLqhVqyb1I8TgUMAiSimp1+DvXxtyuRzHjx8vd6eYkJCA+vXrw8bGCjdu/sW9XaRyjRo9EAKBAF999VW5PyMKhQKDBw8GYwxr1i7k3iZSeV6nXUP9+rVhb2+PY8eOlfszkpiYiICAANjYWOF6zAHu7SJEUxSwSBHx946hbl1fSCQSrF69utgFqaoex44dg7OzE+zsZDh89Dfu7SGVL+vNbfR/vxsYY/j4449LPbVT2uPhw4do2bIlhEIhFnw+lXt7SOW7e/846tWrBYlEgpUrV2rcjxw/fhwuLi6ws5Ph0OFfubeHkPKggEWKeZVyBe+E5l/A3rRpUxw4cEDlNTdXrlxBnz59IBAIUKeON27FHubeDqI9OXlxmBv9CYRCIVxdXbBixQqkpaWV+Rl58uQJZsyYAQsLC1haWmDrtu+5t4NoT/Lrq8rJdZs0aYL9+/cjJyenzM/I1atX0a9fPwgEAtSu7YWbtw9xbwch5UUBi5QoJy8Om35fBl/fmmCMwd7eHsOGDUN0dDTWrl2L9evXY+HChRg3bhx8fX3AGIOJiQlmz5mIjKyb3OsnunHh0h/o9E5r5aS93bp1Q1RUFL7//nts3LgRX3/9NSIiIhAcHAyRSASxWIyPh/en0biriJy8OPy++TvUqqVOP+L77zq2WPjlNKRnxnCvn5CKoIBFyvT0+QV4eLhAKpXA1dUJIpGoyGTPDg72eLd7B3z62WRYWVmgefNAClhV0NlzOzE1YiTq1asFqVRS5DNiYmICsViEUaMH4k78Ue61Et3LVNzCW00aQCQSwtnZocR+pNu77bFm7UK8TL7MvV5CKgMFLFKq7Nw76PZue0gkpjh2YjNyEQ9FdiwSkk4i/t6xYkFq2/YVEAqFGDykN/faCV/v9e+KatVc8SrlCpJfX0VAQB3Y29si5tZB7rUR3Zs2fUyRuSbf5MTC378WOnZqRb9UEaNFAYuUKnLaaI0n4J0b/QkYY1iyNIp7/YSfIUN7w8urmvLfiQ9OwcPDBV5e1fD46Tnu9RHdWf/LEggEAowdN7jI84GB9dCjZ0fu9RGiLRSwSIlK6xRVycmLw3v9u0IkEuGPPau5t4Pw8d+AlYt4XL66FzY2VggObky/WlQRp85sg1QqQad3WhebpJkCFjF2FLBIMWV1iupIy7iBoKD6sLW1obuAqqiSAlYu4rHnzzUQi0Xo3ScU2bl3uNdJtCch6TJDcMwAACAASURBVCRcXBzh4+OJ5y8vFltOAYsYOwpYpAhVnaK6Eh+cgpubM2rVqokXry5xbxfRrdICVi7+Pxp8+NSR3Osk2pGRdRPNmgWWOUgoBSxi7ChgEaWMrJto2rQhZDLrShmB/fjJzZBITNGhY6ty/RJGDFdZASsX8QifOhKMMXzz7RzutZLKN3BQD4hEIvy5d22p61DAIsaOAhZRUqdT1NTadV+CMYYp4SO4t4/ojqqAlZMXhwEDu0MkEmH7jh+410sqz8Ivp4ExhvkLwstcjwIWMXYUsAhyEY8vFkaCMaaVqUvCPvkQjDGsXPU593YS3VAVsHKRPzZS6zbNYGlpjnMXdnGvmVTczl0rIRQKMXRYH5XrUsAixo4CFtGoUyyP7Nw7CO3cBlKpBCdObeHeXqJ96gSsXMTj2YsLqFWrJlxcHHH3/nHudZPyu3JtH6ysLNCkSQO17hKlgEWMHQWsKq6gU2zatKFWb51/lXIFfn4+cHZ2wP3Ek9zbTbRL3YCVi3jciT8KJyc5/Px86IYIA/X85UX4+taAu7szHjw6o9Y2FLCIsaOAVYWVp1OsiJhbByGTWSMwsB5S069zbz/RHk0CVi7icfrsdlhYmOPt1k2RqbjFvX6iPkV2LNq1D4a5uRn+Ob9T7e0oYBFjRwGriipvp1hR+/b/BLFYhF6930FOXhz340C0Q9OAlYt47Nj5I0QiEYYMpamWDMnEsGFgjOHn9Ys12o4CFjF2FLCqqAkTh0EgEGDjpm91/tpfLpoOxhg+m1/2XUbEcJUnYOXi/5+NOXPDuLeBqLbih8/KPaYZBSxi7ChgVUEFneLUCH4DPX708XsQCoV0i76RKm/AykU8xo0fAoFAgLXrvuTeDlK6Q0c2wMREjC5d25ZrVH4KWMTYUcCqYiraKVaWrDe30arVW7CyssDlq3u5HxdSuSoSsLJz7+Dd7h1gYiLG/gM/c28LKe7u/eNwcpKjXj1fJL++Wq59FAlYmTHI69oWeV9EcG8bIZWFAlYVUhmdYmV6+PgsPDxc4OnpjsdPz3Gvh1SeigSsXOTPZ9m0aUNYW1vi0pU/ubeH/N/rtGto0MAPcrkt7sQfLfd+lAEr6yby3m0PCATIWxrFvX2EVBYKWFVE4U4x7u7f3OspcP7iblhYmKNlyyC6e8yIVDRg5SIej5+eg7d3dXh6uuvkLleiWk5eHHr07AixWIQDf62v0L4CA+thQNe2QMsgwESMvA1L85fRJODESJQasC5f+ROKN7eJEch6cws9enSEqakJDh7awL2e//pt0zIIBAKMGj2Qey2kcgwe0hs1a1ar8H4uXdkLW1sbBAbWw4tXl7i3q6qbNXsCGGNYvGRmhffVxr827sisAakE2dtXQPHmNt5c/hN5tb3w5vQ27m0lpKJmzS4lYB26fglJUBAjMGlOFBhjiP5mCfdaSjNhRv5UPfOXf8O9FlJx/YYORnWvmpWyry1H/4KpRIKQ0E64l53OvW1V1fKNv0AgEGDgiI8rvK9HD+7hjlSKDLEYzw7tRxIUeHryKHJlMmR7e+HRvVju7SWkogq+eylgGanK7BS1KTEvC1379obYxASb/u1wieGqzICVBAWWbfgZAoEAA4Z/xL1tVdGBy+dgYWmJZq1b4d6btArt61FCHLJr+SJVJMLkt1siCQo8O/An8iws8Ma/Hh49SuDeXkIqAwUsI1bQKTZv83aFO0VduJX6AnXq+8PW3h4n7sRwr4eUX2UHrCQoMHnuLDDGELXoC+7tq0ouPUmCe/VqqO5VE1efP6zQvh7H3kBO9WrIlcvRr3YtvNOzO55v34w8iQSKt4Lw8MUj7u0lpLJQwDJSldkp6tLpe7GQOzrA168OYlKeca+HlI82AlYSFBg0cjiEQiF+2Pwb9zZWBXcVqQhq0RwWlpY4cPlchfb15Mp55Dg7IcfVBY9vXIZ/YEPMa/IW8kxNoWjeDA9fPeHeXkIqEwUsIxSf9RpBLZrDytraIN/HrccOwcTUFJ26d0NCbib3eojmtBWw7r1Jw9sd2kEilWL7iSPc22ns+g0dDKFQiJXbfq/Qfp6eOY5cOzvk1PDEo/hbSIICM6tXQ65AgKz2bfEg7SX3thJS2ShgGaG+Qz6olE6Rp0WrfwBjDBNnTuNeC9GctgJWEhS4+fo5/ALqw9beHsduX+feVmMV/c0SMMYwaU5Uhfbz5Mp55NrbI6d6NTyOvYEkKJC8ZBHyGMNJVxc8yHrNva2EaAMFLCNTWZ2iPhgyZiQEAgGWbfiZey1EM9oMWElQ4PyDe3D1cEd1r5q4/DSJe3uNzW9/7YVYLMa77/VFYl5Whfb14PVzpA/oj0cJcUiCAslfzAcEAuyzlaFr927c20qItlDAMiKV2Snqg3vZ6WgR0hpSMzP8cfYE93qI+rQdsJKgwMGrF2BlY4O3glsgLjOFe5uNxfHYG5DZ2aF+40a4k5Fcqft+PXUywBjShw1BQMMGeKdnd+7tJURbKGAZiYJOMSCocaV3ijxde/EInt5ecHJ1wfkH97jXQ9Sji4CVBAXW/7kLYrEYXfr0ouv1KkFM8lN4164FBydHnLl/p1L3nTL/0/xw9eFQJOVkwD+wIQUsYtQoYBkBbXaK+uBIzBVY2digUbOmiKfrNQyCrgJWEhRY+ONyMMYweupk7u02ZPdzMtC6UweYSiRauYHgydULeD09Akn//rpOAYsYOwpYBu5+Tgbe7thea52ivlj/5y6IRCL0/mAg91qIaroMWElQYPTUyWCM4dNvl3Jvu6EaEzElfxqctSt18noUsIixo4Bl4Aq+WJasW8W9Fm2L+CwajDHM+moh91pI2XQdsBLzstBz4PsQiURYvWML9/Ybmm/WrwVjDB9NHKez16SARYwdBSwDxqNT5CkxLwvd338PIpEI63Zv514PKZ2uA1YS8gfFbN7mbVhYWmLvhTPcj4Gh2HX6GCRSKUJCO+F+TobOXpcCFjF2FLAMFK9Okbe4zBQ0eCvIYAdRrSp4BKwk5N8U4VXLF44uzkZ5PWJl+ycxHo4uzqjp64PrLx/r9LUpYBFjRwHLAPHsFPXBhYf34ezmCq9avrhB02voJV4BKwkKnIy/BQcnR/j61aHPRxli01/BP7AhrGUyHL15VeevTwGLGDsKWAaGd6eoL/acOwUzc3O0at8W97LTuddDiuIZsJKgwB9nT8DM3BzNWrfCXUUq9+OhjwquWftl3x9cXp8CFjF2FLAMDO9OUZ98/fMaMMYwYtJE7rWQongHrCQosGbnVohEIvQbOpj78dA30z7/DIwxzFi4gFsNFLCIsaOAZUCmLZgHxhhmfvk591r0xagpn4AxhoU/LudeC/k/fQhYSVAgatEXYIxh8txZ3GvRF2t2boVQKET/D4dyrYMCFjF2FLAMhLJT/GgY91r0SUJuJtp1CYXYxARbjv7FvR6ST18CVhIUGDpuNAQCQZUYykSVg1cvwNLKCoFNm3CfXogCFjF2FLAMQOFOkUYyL+7m6+fwresHBydHnP13QlnClz4FrITcTHTq3g1iExNsOPAn93p4ufLsAarV8ISrhzsuPkrgXg8FLGLsKGDpOX3rFPXVyfhbsJPLUbdBAG6nveReT1WnTwErCQrcyUhGYNMmsLK2xl9XznOvR9fuZaejZbsQmJmb680YYRSwiLGjgKXH7mWnI7htG73qFPXZhgN/QiwWI7RXDyT+O98Z4UPfAlYSFLj8NAme3l7w8Kxe5f6zMmz8GAgEAqz4fQP3WgpQwCLGjgKWjpxLuovqNWtoxMOzOszMzSF3ctR42xN3Yri3uaKCWjTXuN12cntYWFqiWg1Pjbb77rf13Nurz/oO+UCj42ltYwOJRKLx+1e9Zg2EfzpH7brGTZuq0b5d3d1hYmICM3NzjT8jH4wawf19uPDwvsbHU+7gAJFIBJmdrcbbHo+9oVZdMxYuQLUaNTQilUr//VvVbLt33+vL/X0gRB0UsHTk9L1YMMbQpk0bDB8+XGvat28PxhiOxFzh3uaKcvVwR506dbR6vAYNGgTGGL744Tvu7dVnrTt1gLOzs1bfi+HDh0MqleLjsPFq1zVg+EewtLTUel1yuVwvfm05mxAHxhhat26tk35E3e+BcdOmQiQSoXv37lrl6OiIJq2Cub8PhKiDApaOFASsn376Cdp8/P7770YVsEaMGKHV4/X48WMKWGpo3akDgoODtfpeAIC9vb3GAatatWparyswMFCvAtbatWu12t4tW7ZoHLCkUilOnz6tVU2aNKGARQwGBSwdoYClOQpY+oMCFgWsslDAIqQ4Clg6QgFLcxSw9AcFLApYZaGARUhxFLB0hAKW5ihg6Q8KWBSwykIBi5DiKGDpCAUszVHA0h8UsChglYUCFtEX3fr1KXWO2rad3wFjDOOnRxRbtunQfjDG0K1fnyLP38/JQEBQY3Tt27vI8xcfJUBmZ4e5S78qtRYKWDqibsBKTU0t/IYUIZFIVHaMVS1gPXz4EKNGjUKjRo0gl8shkUjg6emJ9957D+fOnVN5vChgqUeTgJWcnIzIyEj4+vpCIpHA1tYWLVu2xJ49e1Ruq42ANX369FL/ptT9uzK0gFXRfkRbAWvHjh3o06cPPDw8IJFIIJPJEBAQgDlz5lDAIpWiW78+cPVwh4OzE+5lpyufv/goAaYSCRxdnEsMWD0Hvo+AoMYwlUhw/eXjIssOXb8EU4mkyDhy7bt2RtO3W5U55iIFLB3RNGAFBQUhOjq6iPnz56vsGKtawDp9+jRq1qyJvn37YtKkSZg+fTr69u0LqVQKsViM/fv3l7k9BSz1qBuwkpKS4O3tDaFQiNDQUISHh2PSpEno3LkzoqOjVW6vjYB15MiRYn9L0dHRGDx4MBhjePfdd1XWZagBq7z9iDYC1t69e2Fvbw+RSITOnTtj0qRJGDlyJKpXrw7GGIYMGUIBi1RYt3590K1fH3h6e2Htrm3K56d/MR9tO78Dv4D6xQJWTMozSM3MsPvMcfj61cGn3y4ttt9pC+bB3sEBl58mYfHalTC3sMDJ+Ftl1kIBS0c0DVjlPTVW1QJWaY99+/bl/9zbrVuZ61HAUo+6ASskJATW1tY4ceJEud43XZ4iHDduHBhj2LVrl8p1DTVglffvRxsBa9q0aWCM4cMPPyzy/MGDB2FtbQ2ZTEYBi1RYQcAK/3QOQnv1UD7v61cHK37fUGLAWvD9t6hVry6SoEDUoi/gH9iw2H7v52SgYZO30LpTB1jLZJi3rHgI+y8KWDpSnoD18uVLJCYm4s2bN2p3jBSw8h8PHz4EYwy9evUqcz0KWOpRJ2CdPHkSjDF8+umnAICsrCykpKRo9L7pKmBlZmbC1tYWbm5uyMnJUbm+IQes8vQj2ghYc+fOBWMMERERxZa5urrC2dmZAhapsIKAdTYhDhKpFFefP8TuM8chs7PDXUVqiQGrwVtBmPXVQiQhf0otE1NTHLh8rti+95w7lf/LcIvmak3HRgFLRzQNWBKJRPlemJmZ4b333kNSUpLKjrGqBqy0tDTcvXsXt2/fxt69e9GqVStYW1vjzJkzZW5HAUs96gSsGTNmgDGGLVu2oEOHDhAIBGCMwcPDA998841a76OuAtb69evBGMOMGTPUWt9QA1Z5+xFtBKy///4bderUgVwux/z587F161b8/PPP6N69O4RCIaKioihgkQorCFhJUKBV+7aI/noxPhg1AkPHjkISFMUC1qFrF2Fiaoorzx4on+vcuyc+nDC22L4Hjx4JM3Nz2MnluPQkSWUtFLB0RN2AlZaWhoCAAERFRWHt2rVYunQpOnbsCMYY3Nzc8OjRozK3r6oBa8OGDUUu5PX19cXly5dVbkcBSz3qBKzevXuDMQa5XI4mTZpgzZo1WLVqFRo1agTGGObMmaPy/dBVwGrdujUEAgHu3r2r1vqGFrAq2o9o6yL3o0ePKusoYG1tjcWLF9NF7qRSFA5Y3/76E+rU94eNrS32nDuFJBQPWMM/mQDGGEQikZJQKISdXI67ilTlepsO7YdYLMb2E0fQ4K0gdO7dU2UtFLB0pKLDNERGRoIxhjFjxpS5XlUNWElJSdi2bRt++eUXREREwNbWFg4ODrhw4UKZ21HAUo86Aavgi9PLywsKhUL5fEZGBjw8PCCVSvHixYsy96GLgBUbm/+32K5dO7W3MbSAVdpD3X5EGwHr2LFjaNasGUQiEfr27Yt58+YhIiIC3t7ekEgkWLRoEQUsUmGFA1ZcZgqsZTLU9q+nXF44YN17kwa5owPmLFmEg1cvFGHv4IAfNv+GJChwK/UFPDyrY3T4JCSh5LsKS0IBS0cqGrCysrIgFovh7e1d5npVNWD993Ht2jVIJBI0adKkzPUoYKlHnYDVvXt3MMYQFRVVbFl4eLhaF5TrImBNnToVjDH89ttvam9jLAFL3X5EGwFrwoT8XwrCwsKKPH/kyBG4uLhAJpPh8OHDFLBIhRQOWElQICb5KW6lvlD+u3DAWrl1EyRSaZHlBfp/OBQhoZ2QBAUGjRwO79q1EJeZolweOf9TyB0dcPX5w1JroYClI5Ux0Ki7uztsbW3LXIcC1v8fzZo1g1AoRFZWVqnrUMBSjzoBa+zYsWCMYfny5cWWLV68GIwxrFu3rsx9aDtgZWdnw8nJCXK5vMivbKoexhKwAPX6EW0ErODgYDDGsHv37mLL+vTJHxzyxx9/pIBFKuS/Aeu/Cgesdl1C0aFblxLX+3nPTohEIiz9aTXEYjF2nvq7yPKCAUjffa9vqa9FAUtHKhqwkpOTIRQK4efnV+Z6FLD+/6hXrx6EQmGZd09RwFKPOgGr4MLxyMjIYsvCwsLAGMPevXvL3Ie2A9bWrVuVv6Jo8jCWgKVuP6KNgNW0aVMwxrB9+/Ziy3r06KEM5xSwiLGggKUj6gasuLg45OXlFXnuzZs3GDRoUKlfXoUfVS1g3bx5E9nZ2cWe37x5MwQCAd5+++0yt6eApR51AlZKSgpkMhlcXV2RnJysfP7FixeQy+WwsbFBampqmfvQdsAKDQ0FYwzXr19XexvA8AJWRfsRbQSsYcOGgTGGjz76qMjz+/btg52dHUxMTHDgwAEKWMRoUMDSEXUD1ocffoiaNWti0KBBiIyMxOjRo+Hr6wvGGAICAlSOK1TVAtbgwYPh5uaGAQMGICIiAmFhYWjTpg0YY7CxscGlS5fK3J4ClnrUHWh03bp1YIzB29sb0dHRmDt3Ljw9PcEYw6pVq1Rur82AlZiYCKFQiGbNmqm1fuGHoQWsivYj2hrJ3dHREYwxhISEYOLEiRg2bBgcHBxKDF4UsIiho4ClI+oGrO3bt6NLly7KubrMzMxQv359zJ07F+np6Sq/CKpawNq3bx/69u2LGjVqwMzMDBKJBL6+vhgzZgzu37+v8nhRwFKPJnMR7t69G8HBwbCwsIC5uTmCg4Oxe/dutbbVZsCaM2eO2kHvvw9DC1gV7Ue0NUzD7t270aNHDzg7O0MkEsHMzAz+/v6YNWsWDdNAjA4FLB2pjIvc1XlUtYBV0QcFLPVoErAq8tDlVDmaPAwtYFX0oa2AVVEUsIghoYClIxSwNEcBS39QwKKAVRYKWIQURwFLRyhgaY4Clv6ggEUBqywUsAgpjgKWjlDA0hwFLP1BAYsCVlkoYBFSHAUsHaGApTkKWPqDAhYFrLJQwCKkOApYOlIQsBYtWoS4uDit+fbbb40qYPXv31+rx+vMmTMUsNTQulMHNG7cWKvvRVxcHGQymcYBy9XVVet11a1bV68C1sKFC7Xa3u+++07jgCWRSLBlyxatCggIoIBFDAYFLB0pCFi6YiwBS1fHiwJW2Vp36qCz90LTgKWruvQpYOmKJgFLVzU1adWS+/tAiDooYOnIrdQX+HzFsmLGREyB2MQEtevVxfzl35a4TknGT4+AiakpfOrUxmfLvym2/MarJ9zbXFHf/rJO7eNRmslzZ8HM3ByuHh6I/mZxqesZQyDVpp/37CzxuEUt+hx2cnvIbG0xY+ECle9HUHALCAQCDB4zstR1dpw8qnZdW/4+qNHnYcH3y9CwSRCEQiEGjy69hpL8un8P9/ehtH6kNG+1bAFbe7ty//1cf/lYrbr+OHtC4327VfNAvYYN8PmKZfhw/FgIhUK1+sE1O7dyfx8IUQcFLI7+SYyHg7MTfP3qICblmcbbf/3zGo3/x18V/bp/D8RiMTr37onEvCzu9RiLe9npCG7bBmbm5th74Yxa29xVpKJJq5awtLLCwasXuNQdl5mCt4JbwNLKSu26DdX7H38I9+rVuNdREv/AhkV+FZyzZBEYYxg15RPutRFSGShgcRKb/gr+gQ1hLZPh6M2r5d7P6KmT6RSXGmZ9tRCMMUR8Fs29FmMxdNxoCAQC/LD5N422u/g4Ea4e7qhWwxNXnj3gUvvV5w/hVcsXji7OOHP/DvdjqS2GFLCSoMDg0SPBGMPnK5Zxr4+QiqKAxUnPge9DJBLhl31/VGg/CbmZaN+1M8QmJth85AD3dumz9z/+EEKhEKt3bOFei6Fb8H3+zRTjpk0t1/Z7L5yBuYUFmrQMxl1FKpc2nIy7CbmjA3zr+hnFKfWSGFrAupedjlbt20JsYoJNh/Zzr5GQiqCAxcG0BfPAGMPMLz+vlP3dfP0cterVhYOTI84mxHFvn7669yZNeXrqryvnuddjqH4/fABiExN06dOrQqdcf9j8GwQCAYaOHcWtLX+cPQEzc3M0a92KW9DTJkMLWElQICblGXzr+kFmZ4djt69zr5OQ8qKApWNrdm6FUChE/4+GVep+T8bfgp1cjroNAnA77SX3duqrgtNTHp7VcflpEvd6DM2JOzGwtbdHnfr+uJX6osL7mzAjEowxzF/+Dbc2/bD5NwiFQrw3bAj341vZDDFgJSG/P7N3cIBXLV+1L7QnRN9QwNKhg1cvwNLKCk1atdTK/5Z/+2svxGIx3unZnS7mLsO+i2e5n54yRDEpz+DrVwf2Dg44fS+2UvaZmJeFrn17cz8lNPPLz8EYw5To2dyPc2Uy1ICVBAW2HjsEU4kErdq3xb3sdO71EqIpClg6cuXZA1Sr4QlXD3dcfJyotdeJ/noxGGOYPHcW9zbrsx+3bIRAIMCQMSO512IIEnIz0al7N5iYmmLrsUOVuu9bqS9Qp74/bO3tceJODLc2Fly0v2TdKu7Hu7IYcsBKggKL164EYwz9PxzKvV5CNEUBSwfKczt7RQwc8TEEAgGWb/yFe9v12cSZ07ifnjIUBcdq0eoftLL/0/diIXd0gE+d2uUasqQy3M/JQKfu3SA2McFvf+3lfswrg6EHrCQoMDp8EhhjiP5mCfeaCdEEBSwdKO/t7OV1700amrVuBQtLSxy4fI57+/WVvpye0nff/vqTTn7t23b8MExMTdHx3a5IyM3k0tY7GckIbNoEVtbWRnEjhDEErIJfT0UiEdbu2sa9bkLUVWrAWv/Hdhy6cp5UUFhU/v/8Bw4fptPX3f73Qbh6uMPJzRVbjh7gfhz01R9n/kZNXx9Yy2zw854d3OvRN8t//RkSiQSBTZvgwMWzWn+9KXNncfl7KWzzoX1wcnOFi5sbNh/ax/09qIguvXrAyc2Vex0l8fGrjVbt26q17p//nEQt/7owtzDHyi0buddOiDrGTJlYcsC6dn0fchFPKuDQ4V9hYiJG7z6hyMmL0/nrX7j0BywszBEc3BiZilvcj4e+ir93DI6O9vDz88GrlCvc69EXCUkn4erqBG/v6nj24oLOXnfM2A8gEAjwy69LubX92o39sLW1QaNG9fA67Rr396K8Pvr4PVSv7sa9jpIEBtZDj54d1V4/8cEpuLs7w9PTHY+e/MO9fkJUmT2HApZWxMYdgb29Lfz9ayEllV8HvWXrcgiFQgwZ2pv7MdFnR49tgqmpCd7t3gHZuXe418NbRtZNNGsWCBsbK1yPOaDT11ZkxyKkbXNIpRKcOrON2zE4fPQ3SCSmCO3cBm9yYrm/J+VhTAErF/H45/xOWFiYo0WLRsjIusm9DYSUhQKWFqSkXkNAQB04ONgh7u7f3OuZNXsCGGP45ts53GvRZ6tWfwHGGGbMHMe9Ft4GDuoBkUiEPX+u4fL6z15cgI+PJ1xcHJGQdJLbcfh1w1IIBAIMH/E+9/ekPIwtYOUiHr9v/g5CoRCDPujJvQ2ElIUCViXLzr2Dd7t3gKmpCY4e28S9nlzEIycvDv3e6wqxWIQDf63nXo8+Gz1mEPfTU7wt/PLfuysXhHOt43rMAchk1mjatCHXXysKOslFX83g/t5oyhgDVi7iMWduGBhj+Gw+388oIWWhgFXJZkaNB2MMy76L5l5LYWkZN9C4sT/s7GS4FXuYez36quD0lJmZFKfPbudej67t3LUSQqEQ7w94l3stuYjHn3vXQiQSYeCgHlzrGDykN4RCITZvWc79mGjCWANWTl4cBgzsDoFAgA2/fc29LYSUhAJWJSo4nTBy1ADutZTk7v3jcHKSo3ZtL7xMvsy9Hn317MUFeHtXh6urExIfnOJej65cubYPVlYWaNKkAdIzY7jXU2DB51PBGMMXCyO51ZD15jbatQ+GmZkUx09u5n5M1GWsASsX8UjPjEHz5oFV9j9DRP9RwKokZ/7ZATMzKdqENIMiW38viD12YjMkElN07PS2wV64qwvXYw7AxsYKzZoFVomLaZ+/vAhf3xpwd3fGg0dnuNfzX8M+7AuhUIidu1Zyq+FVyhXUr18bcrktbt4+xP2YqMOYA1Yu4vHk2Xl4eVWDq6sT7ifyu1aPkJJQwKoEDx+fRbVqrjq/nb281qxdCMYYpkaM5F6LPtvz5xqIRCKjv5hWkR2Ldu2DYW5uhn/O7+ReT0nSM2PQtGlDWFlZ4Mo1fn1TQtJJuLs7w8urGh4/Pcf9uKhi7AErF/lDatjYWCEw0LCH1CDGhwJWBWVk3UTz5vm3s1+7sZ97PeoaP2EoZlf6UgAAIABJREFUGGP4ef1i7rXos3mfTTHYC5w1+SwIBAJs3PQt91rK8uDRGbi7O6NGDQ88eXaeWx3nLuyCpWX++HL6dCq1JFUhYOUi/1o9sViEHj070jArRG9QwKqgDwb3glAoxLbtK7jXook3ObF4J7Q197GG9F1OXhzeH/AuRCIRdu1exb2eyvb9inkG9WvmuQu7YG5uhrbtWnA9Ff/HntUQi0Xo07ezXn+hV5WAlYt4LF4yE4wxTJ8xlnvbCMkFBawK+WrxDDDG8Om8ydxrKY/nLy8qxxqi6xdKl54Zg7feCoC1tSWuGtHfxaEjG2BiIkbXbu30OiT816bfl0EgEGDc+CFc6/jhx/lgjCEichT3Y1KaqhSwchGPUaMHQiAQYN1Pi7i3jxAKWOW0+4/VEIlE6P9+Ny7T4FSWGzf/gkxmjcDAekhNv869Hn2V9PA03NycUatWTbx4dYl7PRVVeKaB5NdXudejqYjIUWCMYfn3n3KtY0r4CDDG8O2yudyPSUmqWsBSZMeibbsWMDU1waEjG7i3kVRtFLDKIebWQdja2uCttwL0/hoMdezdtw4ikQgDBnbnXos+O3tuJ8zNzdCufbBe3ymqyus0/ZppoDyyc++g27vtYWIixqHDv3Kro/Ap5O07fuB+XP6rqgWsXOTf7Vm3rg/kclvcvnOEeztJ1UUBS0MvXl1CrVo14ebmjKSHp7nXU1k+/yICjDF8/kUE91r02U8/fwXGGD6Z9BH3WsojO/cOuvfoCFNTExz5eyP3eioiJfUa/P1rwd7eFrFx/L5I0zNj0KJFI1hZWeD8xd3cj0thVTFg5SIed+KPwsHBDn5+PjTmH+GGApYG3uTEon2HlpBITHHi1Bbu9VQ2fRhryBBMnjIcjDH88ON87rVoKmrWBL0+paWpuLt/w8HBDgEBdbhOqv70+XnUqlUTrq5OuHv/OPfjUqCqBqxcxOPI3xtpzD/CFQUsDUya/DEYY0Z7AWXhsYYuX93LvR59lZ17B527hMDERIzDR3/jXo+69H2mgfI6emwTTE1N8G73Dlwv1o+NOwJHR3vUreujN9fpVeWAlYt4rF6TP4H7xLBh3NtLqh4KWGr6ceUCMMYwafLH3GvRpgePzsDDw4X7WEP6Lvn1VdSt6wMnJznuJZzgXo8qhWcayHpzm3s9lW3lqs/BGMPMqPFc6zh9djvMzc3Quk0zZCpucT8uVT1g5eL/vzjr2/ywxPhRwFLDiVNbIJVK0LlLiEHdzl5e+jLWkL67E38UcrktGjTw0+sRpA1tpoHyKrhF/9cNS7nWsen3ZRAKhRg6rA/3Y0IBK/8X53e7d4CJiRgH/lrPvd2k6qCA9S9FdiwO/LUe8z6bgnHjh6BX73cw6IOeGDtuMKytreDrW8Mgb2cvr/+ONRRz6yCWfj0LU8JHYMDA7ujTtzMmTByGz7+IwIlTW6pE8CzJ/gM/QywWoWevTsjJi8PT5+exdt2XiJo1AcM+7IsePTti5KgBmDM3DFu3fY+0jBtarScnLw6nzmzDFwsjMWHiMPTq/Q4cHOwgkZgictpoXI85wP2YaUNaxg1s2fo9atT0gFgsQus2zTB0WB/MjBqPNWsX6uTX2H/O78SXi6ZjYtgwNGjgB8YYWgQ3xleLZ+DSlT91dixu3j6Er7+ZjfCpI+Ht7QlzczOMnzAUCz6fimMnNnP9W71ybR8WL5mJSZM/hp2dDO7uzpgYNgwLv5yGM//s0NqQN2kZNxAUVB+2tjaIuXUQd+8fx3fLoxE5bTQGfdATvXq/g3Hjh2DeZ1Nw8NAvdM0WqRRVPmA9eHQGY8Z+ADs7GRhjEAgEcHZ2QkBAAHx9fSCRSJTPBwXVx6bflxn0uFeaCJ+aP8aPq6uT8nNhZWWFOnXqwN+/HuRyufJ5V1cnTJ8xtkresVMwgrS3tyfEYjEYY5BIJPD0rI7AwEC4ublCJBKBMQZzczO8178rbtz8q1JrSH59FVGzJsDNzVn5ntjb26NuXT/4+vrC0tJS+Xzt2l5Y9l20UZwqvBV7GAMGdoeFhTkYYxCJRHByckRAQAA8a3gq/35FIhFC2rbAwUO/VOrrp6Zfx7zPpqB6dTfl8bWzs0O9enVRp07tIsfd29sTXy2eoZXJw9/kxOLHlQtQt66v8vUsLS3h6+uLunXrwsHBQfm8s7MDIiJH6ew6sUzFLSz9eha8vT0L1WaB6tWroUaNGrCxsVY+7+7ugrnRn2jlF+GEpJOws5NBKpUqX08qlcLTszp8fX0gl9sXeg9lGDd+CB49+Yf7Z5wYriobsN7kxGLO3DBYWJjD3NwcI0aMwL59+6BQKPDfR0JCAr7++msEBQWBMYa33grQu9uxK9uBv9ajVm0vMMYQEhKClStX4unTp8WOTXp6OrZu3YoBAwbAxMQEcrkd98Efdel+4kl07hICxhhq1KiBefPm4fr168WOU25uLk6ePIkpU6ZALpdDLBZj5KgBlTK4648rF8DR0R5isRj9+/fH5s2bkZaWVqyGZ8+eYfXq1ejQoQMYY/DxqYF9+3/ifgzLIy3jBsaM/QAmJiawt7fDpEmTcPz4ceTm5hZrd0xMDObP/1975x0V1dHG4dm+S116BxUExYIFC0gidgVsCNjFFrtRg1EUJSq2aGzRqLFii8aGhSg2LFgwthi7BGzYS0SUJuzv+2O/JSDbK2XmnOd43L135525d2cf7p37zjx4eXmBEIKOnQK18qTf1m1L4ehoByaTiR49emDHjh3IysoqU/+7d++wefNmhISEgMFgoFo1Z+w/sFZrfZF88jd4e9cs/q6uXbsWL1++LBNHTk4OEhIS0L9////3m4XOnyY9mLge1au7gMFgwN/fH7GxsTh69ChSU1NLkZycjDlz5qBNmzZgsZiws7PB5i2LtRbHn5cPoLFvPRBC4O3tjYkTJ+LAgQNl4khJScHSpUvRtWtX8Pk8GJsYYc7c76vsFXqKZlRJwXr/4Ubxj+KQIUPw9OnTMoORtCISibBnzx5Ur14NxsZG2LN3lcHboguWr5gJNpuNBg0a4NSpU0r1DQDcu3cPXbp0ASEEQ7/pVSmukMgj9c99cHCwhaWlJVavXo3Pnz8r1U9ZWVmIiYkBh8NBo0Z11V6mKP9zGkaO6gdCCIKDg3Hnzh2lj9WZM2fQqFEjsFgsLFk63eB9qQqZz1LRpIkP2Gw2pkyZgvfv3yvV5s+fP2PNmjWwsrKCnZ01zp7frVb9n4v+KZ443aZNG/z9999K9/vFixfh5+cHBoOB2XMmanw1fNXq2eBwOKhfvz6Sk5OVjiMtLQ3dunUDIQSDBofrZEL+vPmTwGQyUbduHaxbt66MzMhi27ZtaNasKQghmPDdEI1v1/2+cwUERgI4Oztj4cKFSsdx4MABBAcHgxCCrt3aGzQNCKViUuUES3wv3gdcLhcbN25UekAqWV6/fo2vv/4aTCYTW7YuMXibtMnsORNBCEFERARycnJU7huRSITZs2eDwWBUuDXuVOHs+d0QCPjw8vLC/fv31TqPjh8/DktLSzg7O+DJ0wsq1V8oSkePsE5gMBiIjY2FSCRSuf7c3Fz06dMHhBDE/jDO4H2qDM9e/Ak3NycIhUIcOXJErX7/559/4O3tDR6Pq1ay1ciBYSCEYOLEiVKvmCkq+fn5GDp0aLFAqNsXkuTAoaGhUq9YKlPmzZsHJpOJoODWWp13NGnyCBBCEBISgpSUFKWlRsL58+fRv39/EELQp29XtePYsHEBGAwGfH19pV45U4apU6eCzWajWbOGlWLlDor+qHKC1advV7DZbCQlJak1IJUcJDt27AiBgI+Ll/YbvF3aYN/+NWAymRg6dKhaP9gly7p160AIwdSY0QZvl7Z5nHkeDg62qF27Nt69e6dRP92+fRtCoRDNmzdUaW6O5Iv7yy+/aFS/SCTCqFGjwGAwsGv3SoP3rTxy8+8hIMAXZmZmKl01klbev3+PevXqwc7ORqU0G4sWixd4nz9/vkb1A8CkSZNACMHG+IUq90XiHxvAZDIxcOBAtSSvZNm4cSMIIZg0eYRWjtOWrUtACEHv3r3VEpqSjBs3Tu0VJs5d2AMej4uAgACcPXtWozgWL14MFouJAZGhBv8eUCoOVUqwNsYvBCEES5Ys0XhwBMRzK2rWrIkaNVzLRc4bTXjx6jLMzEwQEBAgdR6aOuXbb78Fg8GodIuutmnbAhYWFmpfufqyHDp0CEwmU+kfuLPnd4sTho4YoZX6CwoKEBgYCBMTYzx9ftHg/SuLmGljwGQysX//fq20Oz09HVZWVmjZsplS9V+7fki8Zmffvlqpv6ioCMHBweDxuCqtCfn67VVYWJijefPmyMvL00os3333HRgMhsZpDB4+PgeBgI/mzZvj/PnzGgtWamoqgoODwWQycenKAaXj+JR7By4ujqhevRpOnDihlTjGjBkDQgi2bltq8O8CpWJQZQQr+9MtODraoWXLljIHmezs7JKdUQoWiyV1nzNnzoAQgp8WxRi8jZoweswAcLlcZGRkKDUgZ2dnw9XVFYQQmT84+fn5cHd3h69v/Urz5OUfhzaAEIKVK1fK7Jtnz55h5MiRaNy4Maytrf//RGE19OzZE3/++afUfYYOHQo+n6dw8nWhKB1Nm/rAxcUFubm5co9RVlYWpk6dCi8vL/B4PFhYWCAgIAAHDx4ss+3Dhw/B4/HwzbDeBu9jaTx8fA58Pg+RkZFy26xquyVXWpVZqLl9h69ha2uL7OxsqfXGxMTIHD8kT5Z+WV69egVTU1P06t1Z6b4YP2Ew2Gw27t27JzUOdcaxgoICeHh4oH79Whrd1u8/IBR8Ph+JiYkyRWX//v0IDw+Hi4sLeDwehEIhfHx8MHPmTKnbnzx5ElZWVvhaSREuQgbmzpsEBoOBDRs2yJWmEydOYODAgXBzcwOHw4GpqSl8fHzw008/Sd2+Xr16cHV10smToJTKR5URLEkmdnkTQSUDU5MmTRAXF1eKOXPmyNyvbdu2cHCwrbDzjd68uwYej4tvvvlGZhu/LGPHji1+BF3eX/QbNoiFpLIk+Ats5Yfq1avLvcqXmpqKGjVqICIiAlFRUYiJiUFERAT4fD5YLBYOHTpUZh+J4Ciak3M6ZScIIVi1apXc45OZmYmaNWuK59cEBeH7779HVFQUQkJCMGPGDKn7jB49GhwOp1w+mj5p8ghwOBykp6drtd0FBQWoWbMmWrTwlVv/1b/+ACEECxYskFn3qVOnyowbcXFxGDRokHiidNeuUveLjo4Gk8lExsMUhf3wb9bfEAj4GDhwoMw41B3HNm/eDEIIDifFq3WMHmeeB4vFQp8+fWQKTVJSEqysrIqPT1RUFEaMGAE3NzcQQjBw4ECp+40fL/6hUmY6Rv7nNNjYWMHf31+uXB08eBAuLi5gMpnw9/dHv3790KdPHwQEBGDo0KFS9/n555/Vvq1L0Q8RPUNACMF3UUPLvBcU3KrM1JWIniEICm5VZv8vH/5Zs3YerKwsVIqlyghWh44tUatWLTlD838D0/Dhw+Vu92XZu3cvCCFqTZgtD8Rv+gmEEFy7dk2p9qampoLJZGLx4sUKBaugoABCoRDDR1T89e+ePr8IJpOJ2bNnq3R+SMqJEydACEFQUJDU90NDQ+Hq6iT3at+34wbB2NhY4QMIrVu3hqmpKc6dO6d0fLdu3QIh5XMRa3d3N3Tu3FlhG9Rp94IF4onQ8p7mjJk2BlwuF//++6/SnyspEyZMACFE6hU0AHjy5AkYDAYWLZ6msB+2/bYMhBCZV0IB9cexgoICWFpaYsjQnmodo5+XzwAhBAkJCXInjEsTqRMnTsDMzAxCoVDmVSwej6vUbfTjJ7aJ7yrIuAolwdfXF0ZGRli7dq1Ktwrd3FwRHNLa4N8JinQieobAxcUB9vY2pVYiefr8Ing8LhwcbBUKFp/Pg42NZaknR6lgySD70y3w+TxMmjRJ7gBTcmB69+4dnjx5goKCAoUDU3Z2NgQCgdYmiRrihHR1dVVqYntBQQHq1q2L7t27Iy0tTaFgAUBERARcXcvnch2qIBFRdSdYv3r1CoQQdOvWTer78fHxIITIXWi7Zs3qMq+ESMr58+dBCEFcXBwAIC8vT2p+JmnFw8MDXbu1N3hfl+T23eMghGDt2rU6affdu3cVimWjRnXRpk0bpfqwZMnPz4eVlRWcnJxQWFgoc7uGDRuiTdsWCvuib79ucHR0lDuxXd1xDAD69OkDR0c7tY5Tx06BcHd3lysns2bNAiEE33//fZn3HB0dYW9vL3NfP7/mqFvXS2EcE74bAoFAgNOnT8v8rLVr1xb3UWqqOP+VsnO1evfuDYGRgD5RWE6J6BmCiJ4h8PBww4GD64pf/3FBNIKCW8HHp7ZCweoe2gE1arjihxn/PV1NBUsGf988AkII9uzZI3dwkQxMkuzPhBAIBAL07NkTmZmZcvf19fVFSOc2Bm+rOtSrVwthYWFKDcBxcXEwNTVFZmam0oIludJV0fPITI4eASMjI6X6CRAnYX3w4AHu37+PpKQkBAYGwszMDBcvXpS6veSHfsfvy6XWn5t/DwwGA3PnzpVb77Rp4ifddu/ejfbt24PBYIAQAhcXFyxdulTuvn379oWXVw2D93VJ9iasVkpsNWm3UCjE+AmDZcYgEPAxdepUuZ8hrezYsQOEEEybNk3udiNGjFBKbBo1qqtQsDUZxyS3wNTJ8u7q6oTOnTvLlZMzZ86gdu3asLKywty5c7F3715s3boV3bp1A5PJRGxsrMx9hw4dCg6HrXAqRsdOgahbt67cOCS3befNm4dmzZoVnyt2dnaYMGGC3H3nzJkDQkilXXaqoiMRrLjZUQjt0bH4dW/vmti56xelBCuiZwi2bF0CU1Pj4mW2qGDJIOnIJhBCcOHCBbmDy8ePH+Hj44PY2FjEx8dj2bJl6NChAwghcHJywvPnz2Xu27VrVzRqVNfgbVUHKysLfPvtt3L7BhALAI/HK/6xUlawJD8yFX1A6te/Ozw83BX2k6Ts2rWr1ARjT09PXL9+Xeb2Hz58kPvARPoD8QMV8fHxcusNCxPnabK2tkazZs2wceNGrF+/Ho0bNwYhBNOnT5e576RJk2BkJDB4X5dk+YqZIITgzZs3Omt3nTreCI8Illr/qzdXQAjB8uXL5dYvrbRt2xYMBgMPHjyQu92sWbPAZDIVLq5ub2+DkSNHyv0sTcax3bt3K7yKKo1CUTq4XA4GDRqk8ArQ6dOn0bFjx1LfDTMzMyxZskTuftHR4rxfmc9S5cZSv35tBAYGyv2s1q3FiaaFQiHq1KmD6dOnIyYmBrVq1QIhBIMHD5a575o1a0AIwdFjWwz+3aCURSJIkgdjXr25ggsXE2BpKURu/j2lBatQlA4fn9oYN178hxcVLBn8vnMFCCG4ffu2ygMkgOJ5A6NHj5a5TWRkJGrUcDV4W9WBzWbL/fEBxPmSvv76azRu3Lj4VoeygpWUlARCCM5d2GPwtmpC5y5t0bhxY6XPm6dPnyIhIQHbtm1DdHQ0LCwsYGNjg6tXr8rsYzabjWnTx0qtXzLRet++fXLrlfyYuru7l5qMn5OTAxcXF3C5XKnLHgHA3LlzQQgpV1n4JclvFWXK16TdLVq0QLv2X0mtPy39FAgh2LJli9z6vywZGRlgMBho27atwm2XL18OQghev70qty8EAj6io6NVikNSlBnHjh8X3449nbJTpWOU/Uk8f2/s2LFyxSYlJQX+/v5gsViIiIjAnDlzEB0dDU9PT3C5XLmZ1iVXjm7ePio3Fjc3J4SEhMiNo3nz5sXCWTIR6unTp2FnZwcOh4OkpCSp+/72228ghGDnrl8M/t2glEUiSEXIQNt2AVj28w8YMbIvRo8ZgCJkKC1YRRDnm+PxuHjw6CwVLFkkn9ounoSuwrIvJUt+fj64XC48PDxkbtOxY0f4+TUyeFvVwdHRTuGE2NWrV4PJZOLy5cvFrykrWJs2ia8gqpLrpzwyZGhPuLg4q3bylCi3bt0Cn89HkyZNpL7/+vVrEEJkrg+X+SxVPFdozRq59UiWQImNjS3zniS5ZUJCgtR9x40bB0tLocH7uiRr1s4DIUThklaatNvDwx39+neXWn9W9k0QQrBo0SK59X9ZJGkbduzYoXDbadOmgcfjKkxn4ubmhMGDB6sUh6QoM45t2yaeIH4v7aTKx8nY2Aj9+vWTKzaSxKFf3oY7ffo0nJycYG5ujpMnT0rdNyoqSnwl8901uXE0aeqDFi1ayI2jZcuWIES8VNqX70kyyP/4449S912xYoVaEkrRDyUFadtvy1C/fi1YWJjjz8viPGqqCFYRMvDVV00QOTCMCpYs7twTP721fft2tQYmAKhWrRosLCxkvl+vXr1S93srEo0a1UWXLl1ktu3Dhw8wNzdHeHg40tLSipE8Fde1a1ekpaXh7du3UvefN28eGAxGhZ8UOm36WHC5XLmTlRWVr776StwXnz6Vee/69eviuYIy1rgsKEwDi8WSmWZBUiQJEaWlcliyRJxle/369VL3DQsLU2oisT45mLgehBBcunRJJ+0WiUQwNjaW+5CKqakJoqKi5NZfshQWFsLR0RHW1tZKJe4dNGgQ3NwUPwjSrFkDdOrUSek4viyKxrGFC8XJmD98VH2+pLu7Gzp27ChXbAICAkAIkZonq1evXsUPM0jbd8CAAeDzeQoltHOXtqhVy0tuHOHh4SCEYNKkSWXek6SEiImJkbrvjBnipyXv/3PK4N8NSllKCtKn3DsQCs1Qr95/Y5qqgpVybjdYLBbGTxhMBUsaeQX3YWFhjmHDhqk1KH348AEsFgve3t5S33/58iVYLBbmzP3e4G1Vh6Hf9IKlpaXMJ42ePHlSar6ELGJiYqTu3759+3L3o60OCft+BSEEZ86cUes8AgAfHx8wGAypSUKXLl0qnq8jJ9lo48b15CbLBYCtW7eCEIIpU6aUeU+SMiAxMbHMe4WFhbC1tcWAyB4G7+uSPHl6AQwGAwsXLtRJu1NTxVcGf9+5QmYMLQObo1GjRnLrL1kOHDhQfKVGmVK9ejV0D+2gsC9GjuoHc3NztVZbUDSOAUBQUBBq1XJX6zhF9AyBnZ0tLly4oPDW3L59+8q8J5lDt2rVKqn71q1bB/4tGiuMY8bM8WCxWDhy5IjMOGbOFM/ri4yMLPNe7969i69YStu3c+fOsLQUanXtRor2+FKQ3r2/XuoBK1UFqwhiaefzeVSwZNGnb1fY29vLfbw5PT29TKqCgoKC4kvG0gZuAMWP/P59s2L22YGD4mzWx44dk9q+nJwc7Nq1qwySeSNfffUVdu3ahZs3b5bZ999//wWHw8GUqaMM3k5Nyf50CwIBX+GP5t27d6XOF9q9W7zETUBAgNT9WrZsiYYN68iNQfLjIWsuESDOZC4UCuHo6Ij3798Xv/727VtYW1vDzMxMavqC06dPgxCC3XukX0EzJE2b+sDf319uv6vb7smTJ4PH4+LfrL9l1r9o8TQwGAw8fPhQbgyS0qVLF/GDHbduKdz26tWrIES55JWHk8SpPKQlq5UUdcexrKws8Hg8fD9puFrHaOu2pSCEyM2ePnjwYBBCyiTyPHbsGKytrcHhcHDs2LEy+x08eBAMBgPzf5ysMI4r1xKLH2qQFceJEydgamoKa2trHD9+vPj1o0ePQigUwtjYWGrahnPnzsHCwgL9B9A1Ccsr0gSpJOoI1t83j4DJZFLBksW+/WsUTlQdPnw4qlevjv79+2PKlCkYNWoUPD09QQiBj4+P1MG5sLAQdevWrdBXaD7m3IaVlYXMBJiyijJzsOLi4sBgMHD1rz8M3k5tEBYeBAsLC7mLPEdGRsLJyQl9+/ZFdHQ0JkyYgFatxBmEzc3NpSZ0vXTpkjgFw7xJcuu/efsomEymwsf+JfPePDw8EBcXh1mzZqFatWoghGDdunVS9+nWrRuEQjO1bg/pmoU/TQWDwVD4JLCq7c7KyoK1tTW6dG0nt/6MhyngcDgYN26c3PoB8VJJLBYLfn5+CrcFgP79+8PY2Aiv3lxR2A+5+fdga2uNdu3ayfw8dcYx4L9b+ZK5Kqry9t+/YGxshHbt2skUm6SkJNja2oIQgtatW2P8+PEYMmRI8WuyMqj37dsXbDZL6dtynp414OnpKXc9xNjYWBBC4OzsjOHDh2PYsGFwcHAAIQRTp06Vus/06dPFV0L/2GDw7wSl/FNlBKtQlI7mzRuievVqMhdIPXDgADp37ly8RpZAIED9+vUxa9YsqXNmgP9WoldmLbPyzOIl4hxCp0+fVupHAVAsWK9evYKZmZncvyYqGjdvHwWbzZabtPbIkSOIiIhA9erVIRAIwOPxULNmTYwePRqPHj2Suo9kuSVlcoX1HxAKExMTuY/bA0BiYiICAgJgbGwMIyMjBAQESL1FBgDnzp0TT+xdEG3wPpZG9qdbcHZ2QMuWLRUmxFWl3TExMWCxWPjr78MKYxg1uj94PB4eKEi5IHnaTdY8t5Ll+vXrYmGW8eSoNCRpK44fPy71M9UZx968eQOhUKjxPNIZM8eDyWRi06ZNMsUmMTER3bt3h729PVgsFgQCAerVq4cffvhB6vb79+8XL+WlwjqZO3f9AkKIzPUNJSxatAg+Pj4QCATg8/nw8fGReWvwzJkzsLe3R4sA+csqUSgSqoxgFUG8jhuTycTQoUMVDnzKlHv37kEoFCKwlZ/B26Ypufn3ULNmdVSrVg2vX7/WuG8KCwvRoUMHCAR8pKVXrsmgI0f1A5vNlvkDp2qRJGJdu26+UvU/eHQWxsZGaN26tcLUBcqUt2/fwt3dHdWru5TrBxEkmfTnz5+vhV4X3xLlcDhKLw3z/OUlCIVmaN68ucw/0lQpHz58QJ06deDgYIv3H24o3Q95BfdRu7YHXFxc8OLFC43jKCoqQlBQEHg8Lu7eT9boGH34eBNOTvaoVq1aqVuP/RUHAAAgAElEQVRv6pKSkgIfHx+Ymprg6fOLSsdRKEqHf4vGMDc3w549ezSOIzU1FcHBwWAymRU+3QxFf1QpwSpCBmbOEk92VTRhVlF5/vw5ateuDQcHWzzOlL2GWUXi6l9/wNjYCC1btsSHDx/U7huRSFT8RNfmLYsN3i5tk/3pFho2rAMrKyvcuHFDo/No//79YLPZ6N2ni0ox7Ph9ORgMBoYNGyZ3XqGi8vHjR7Rp0wYCAR+Xrqh3a0ifDIjsARaLhd27d2vU73fu3IGtrQ3q1aul0goDBxPXg8lkom/fvhrJbW5uLkJCQsDlctR63P/6jSSYmpqgRYsWSi+DJK2IRKLip+Y2bFyglWN09vxu8Hhc+Pv7y12uRhHnz58vlpqEfb+qHMeDR2dhY2MFd3d3HD58WCO5GjVqFAghCm/hUyglqXKCVShKR99+4nw5Y8aMUWuQvHbtGlxcXGBmZoqz53cbvE3aZM/eVeByOahfv77SE3pLlo8fPyI0NFQ8j6HERMLKRsbDFLi6OsHMzEzuhGN5ZfHixWCxWPD3b4yPObdVjkHyx0KXLl2QnZ2tcv1PnjxBw4YNweFwZC7PU974lHsHLVs2A5PJxIIFC9Tq9yNHjkAoFMLJyV6tq6uSCe/t2rVTa/HnFy9ewM/PDywWC+s3qC81+w+sBY/HRZ06dZCRkaFyHJ8+ffovXYGW11HdtHkR2GwW6tSpIzUlgyKOHz+O5s2bKz2xXRanU3bCxMQYjo4O2LZtm8pxnD17tng8ixwYpjBFBIVSkionWEUQS9a06WPBYDDg6+ur9K2e9+/fY+rUqTAyMkKNGq64UUn76OTpHbC2toSlpSUWLVokNaXAl0UkEmHnzp2oWdMDHA4Hq1bPNng7dM2zF3+iefOGYLFYGDp0qMJ13iTl+vXrxUuF9OnbVaPbcuvW/wgulwN39xrYvn27Ugt25+XlYcmSJbCysoKlpRAnkrcZvC9VISfvLgZE9gAhBO3bt5eZGf/L8uzZMwwfPhxsNhtNmtTHk6cX1I7ht+3LIBDw4erqgvj4eKWuIhYUFGDlypWws7OFmZmpViZKnzm7C7a21rCwsMCCBQuQk5OjMA6RSIQ9e/bAy8sLbDZbZmJbTTmcFA8zM1NYWlpi4sSJOHv2rFJXrWbMmAEHBwfw+Txs2bpE4zj++vswXF2dIBAIMGTIECQnJyslV8uWLYOXlxcYDAZmzBxP5YqiMlVSsCQcTFwPb++aIITA19cXc+fOxYULF5CZmYnPnz/jw4cPuHXrFhISEhAZGQkLCyE4HA6Gj+ir1BM/FZn0B2cQHhEMBoMBa2trjBw5EocPH8bdu3fx6dMn5Ofn4+HDhzhz5kypNbz8/BpVqTkKn3LvYHrstzAxMQafz0doaCg2b96MGzdu4M2bNxCJRHj+/DmuXLmC5cuXo3Xr1mAymXB0tMPadfO1MmhfuJiAFi18QQiBl5cnpkyZgtOnT+PBgwfIz89HTk4O7t27h6SkJIwePRqOjg5gMBjoEdYJ/2ScNngfqsv6DQvg7OwAJpOJwMBALFu2DFeuXMGzZ88gEonw9u1b3LhxA1u3bkVYWBgEAgGMjY0QM22MWlcMv+TKtUS0au0PQghq1KiO77//HsnJyUhPT0deXh5yc3ORlpaGY8eOYdy4cXBxcQYhBMEhrXH77nGt9cODR2fRq3dnMBgM2NnZYsSIETh06FDxd7WgoACPHj1CSkoKpk2bBm9vbxBC0KxZA5w5u0unx+ju/WR06doOhBDY2dkiIiICP//8M3bt2oXTp08jJSUFe/fuxcqVK9G/f3+4uLiAEIKWgc1x+epBrcXx/OUlDP2mF9hsFszNzRASEoIFCxZgx44dOHnyJM6dO4eDBw9i7dq1GDFiBLy8vEAIQZ06njicFG/wc51SManSglUEcXbsDRsXILCVH5hMpswkmg4Othg+oi/u3Dth8Jj1xYWLCeByuXB0soOFhbnMvmGxWOByOVixUjd/CVcEnr34E5OjR8DDo5rMfhJfMa2HhT9NRfanW1qPYd/+NQjp3AZ8Pk9mDEKhGfr07YrzqXsN3mfa4GPObSxeMq34DyVZ1Kjhiu8nDVe4ULA6HE6KR7fuHWBkJJBZv6mpCSJ6huDUmd911heXrhxA/wGhsLQUyoyDx+OiU1Agdu1eqdcrMmfO7kLPXp1hamYiMzaBgI+u3drjj0MbdBbHrTvH8M2w3rC1tZb7PTU2FuCXlXE0mShFI6q8YElIPvkbOBw2/PwbY0P8QgwbLs7mGzc7CpeuHMDnon8MHqM+eZx5Hg4OtqhZsxrevLuGvIL7OHdhD0aO6lc8v2rzlsVIPvkbbtw6Ajs7a9Sq5Y63//5l8NgNza07x7D/wFoMGRJRfA4l/rFBbw9DZGXfRPKp7di8ZTGsrIRo2tQH23f8jHMX9pSrRZy1xaMn4nPV07M6du1eiXXrf4SDgy0aNqyDffvX6O1W/sec2zh15nds2boE344bBEIIoqNHIuXcbuTk3dVbf+R/TsP51L34fecKNPdrCAsLc2zavAjJJ3+Tm0xVH+Tm30PKud34bfsy8Pk8BLbyw7hxg8QPDvSTvhakLvhc9A/+vHwAu/eswtJlsZj/42TEb/oJx45vxfHkbTAyEqBtuwDkf6aCRVEfKljIQFr6KVhZWaBePa/iJ4qST4pXTK+KC3rm5N2Fn18jmJub4tadY6Xe2xgvXqvs4eNzpV6/eGk/HZS+4Ped4kVhtXk7SFXc3V0xcFCYwftCV2R/uoVGjepCKDQr1c8+PrURFh5ksLguXEwAIQRJRzYZtH+GftNLqTUODYGZmUlx1vg5c78HIQQLFk4xeFxFEOfRYjAYGDwkwuCxUCouVV6wPny8CR+f2rCxsUT6gzPFr1dlwerXvztYLJbUuQeyBKsIYqGgg1Lp/qCCpVv69usGFotVRmSoYImpKIIliVXdlAy6QPLjuGTpdIPHQqmYVGnB+lz0D7p17yA1F01VFayFP00FIQTz5kvP9yJPsIqQgWnTx4IQgmU//2DwthgaKli6Zd78SSCEYOFPU8u8RwVLTEUSrLyC+whs5QcTE6NysbSWJKUPk8nE/gNrDR4PpeJRpQUr9odxIIRIfUy5KgrWgYPrwGQyMWhwuMxtFAlWoSgdvXp3BovFwoGD6wzeJkNCBUt37D+wFkwmU2YWdipYYiqSYBUhA6/eXIGHhxscHe3KRQLnT7l34OfXCKamxrh2/ZDB46FULKqsYG3f8TMYDAZGjOwr9f2qJlh/3zwCU1NjNGvWQG5eJkWCVQTxZN9mzRrA1NRYqTXeKitUsHSDOIu5MZo3byhz8jgVLDEVTbCKIH5IRCg0Q+PGdXXytK2qvHx9Be7urnBzc8KzF38aPB5KxaFKCtbFS/shEPAR2MpP5lNVVUmw3ry7Bk/P6nB2tle43pcyglWEDDx9fhEuLg6oVs0Zz19eMngbDQEVLO3z8vUVVK/uAhcXB7nnKhUsMRVRsIqQgaQjm8Bms9AjrFO5SPB549YRmJubwt+/Ubler5NSvqhygvXsxZ9wdXWEh4cbXr+9KnO7qiJY+Z/T0LZdAIyMBEqtRaesYBVBnIjRxMQILVo01utj6uUFKljaJf9zGlq38YeRkUBhEkoqWGIqqmAVIQPLV8wEIQTTY781eKxFyMChwxvBYrEQHhFcLqSPUv6pUoKVk3cX/v7i9AM3bx+Vu21VEaxx4weDEKL0khSqCFYRMpD4xwawWCxE9AypcoMSFSztMmZsJBgMBnbtXqlwWypYYiqyYBUhA6PHDACDwSg3i8YvWjwNhBDMivvO4LFQyj9VSrAGRPZQ+jHgqiBYv66ZC0JUW+hVVcEqwn9Pe82eM9HgbdYnVLC0x6rVs4sT3CqzPRUsMRVdsAoK0xAc0hp8Pg9nz+82eMxFyMCIkX3BYDCw7bdlBo+FUr6pMoK1ZOn04qzaymxf2QUr+dR2cDhshHRuo1KWenUEqwjigZ7BYOC37QoGpYsJKHpi+KeHtAEVLO0gWWWhS9d2Sp+rXwqWaOEUFOlwmZovoYKlGGUEqwgZeP/hBurV84K1tQXu/3PK4HHnFdxHm7YtIBDwK82SUxTdUCUES3KbqlfvzkrfpqrMgvXg0VnY2Vmjbl1PvP9wQ6V91RUsSY4bgYCPCxcTpG4jSt4GmBhB1K29wftIG1DB0hxpqywoQ0nBEk0dBRAC0dhIvcVNBUsxygpWEcSLz9vaWsHbuybevb9u8NjfvLsGL68asLe3UXkspFQdKr1g3b2fDAsLczRt6oOPObeV3q+yCtaHjzfRoIE3rK0tSmWuVxZ1BasI/+W4cXCwLbO/aNcvAJcD+DVCUSVZz5AKlmbIWmVBGXx8aiM8rBNE3/QSy5WeJ0pTwVKMKoJVBPGC0TweFx06tiwXizCnpZ+CjY0lGjTwVkn+KVWHSi1Yb//9C15eNeDkZI/MZ6kq7VsZBatQlI7uoR3AZrNw7PhWtT5DE8Eqwn85bho2rIMPH8WDkmjjAoDFgqhtCxR9vIkiUTpEGxagqIIvTEwFS33krbKgDI3r18JZF0exXElWJXh7FaLenVGkh1xGVLAUo6pgFSED8Zt+AiEE4ycMNnj8RcjAqTO/g8vloFNQYLmQPkr5otIKVkFhGtp3+Bo8HletyZGVUbAkB/vn5TPU/gxNBasI/+W46da9A4qWTgcYDIi6tkNR3l0UFf0D0bDe4h/GCj6JlAqW+khWWfhlZZzq++fewWkzE4gYDIgkqzQ8vwjU8wKMjVB0eofO46eCpRh1BKsIGYieMlL9c0MHrN+wAIQQtdpCqdzIFKz43zfg0Jk/KixhfXqIT/qYKLX2//Hn+eJ1zlYsMHhbtMHUmZPBYDAQ1CVIo8+JmvodCCHYtHuTRp8zasJITCQEIkLwIrAFjpzYh6TkfXgV0AxgMHB7wkiD95mmTJk1BYQQrNn6q8FicHR2RPugdgbvC1WYPEN8rgZ3V/1cPXJkD942rI9CBgOza3vi0Jk/cGrHOuQ62KHA3Azn1y3VSxuW/LoEhBDMWRRn0L7s2LkD7BzsDH5MpWFkbISwPj3U2PcgAtu0BJvNxtzFsw3ejkNn/kBor1AQQvDt92MMHgul/DBqwkjpgpV86y9kIr9CsnDdahBCMDxqvNqfsevkMRBCsDcl2eDt0ZRj1y/D2MQE/q1a4mHBR40+a0n8OhBC8OfjdI0+58PkiQAh2EAIFq5egac575HbqQPAZOLfX38xeJ9pg9U7/38V9O4Ng8Xg5l4DPQdFGrwvlOXQpfPgCwRo0TpQ5XP1adZr5H8VABGHg4lurggJ74GXN66i0N4OhY4OeKHHMS3x4lkQQrDtyB8G7c8+3wyBs5urwY+rNEzNzDBqUpRa+/6T8x4NmjaBuYWFQb9fEh4X5aJD185gczjYmXzU4PFQygdRM2Mrl2AduHAGPD4fbUOC8LgoV+3PqSyC9dfLTDi7ucLNvQZuvHmm8edpLFiiPHwcMxIgBB++HY22wZ1gyeHgVf16AJuNt79tNnifaQsqWKpx7cUTOLm6oJqHO26+fa7Svs9eP0VB40YQ8fl4czAB3j718W27NiiytUGhizNe6PkYUMFSjCaClYl8XH32CI4uznCtUR3XX2UavD33st/C26c+hJaWSLl/y+DxUAxPpRKsS08yYGNvB8863rj74Y1Gn1UZBCsj7wOatPCHsYkJjl2/rJXP1EiwinLxcdhQsVzFxiAT+bj/4B5uCATIYzBwu5JcuZJABUt5MvI+wNffD6bm5jh5+7pK+z5/+hCfvWtDZGKC1yePIRP56OPhgY8cDj57uOP5wzS9t4cKlmI0FaxM5CPp6kUYGRuj2VcBeJCfbfA2XXn6EPZOjnD38sStdy8MHg/FsFQawUr79C/qNmwAcwsLnLl3U+PPqwyCFTFwAJhMJtYl7NLaZ6orWE8LPiKnd0+AEGTNn4NM5OP5s0coqOONIj4fEUJzeNTywu1/Xxq837QFFSzlCY/sDyaTifX7dqu03/PH6fjsWRNF5uZ49f/v6utjh5HDZOKBuTmeP39skPZQwVKMNgQrE/lYu+d3MJnMcnOeH7p8AQIjI3zdrg0efv5k8HgohqNSCNYTUR6Cw0LBZrPx29FDWvnMii5YccuXghCCqJmxWv1cdQXr5eULEHG5yJozC5nIx/MnGfjs5QmRmRlenTmBvSnJ4PJ4lWpQooKlHDOXLhIv2TR7psr7vki7jc+1a+HVuVPIRD7eJOyCiMfD30ZG6N21s8HaRAVLMdoSrEzkI3puHAghmP7TjwZvVyby8euu7WAwGOg9ZJDBY6EYjkohWJIv1w+LF2rtMyuyYO04ngQ2m42uvSLwRJSn1c/W5Bbhi/S74n/TbqPQzRVFVlZ4eflCmc/uPXSwwftQG1DBUszmP/aDxWKhW59e6p+r/59r+XbnbxBxucj390OzunUQEt7DYO2igqUYbQqWpK3qXAXVFd/NEC/PNmvZYoPHQjEMFV6wNuzfAyaTiT7fDNHq51ZUwTqbdhtCS0v4NPHFPznvtf75mk5yV/RU16hJUSCEIG75UoP3paZQwZJPyv1bMLewQIOmTZCem6XRZ73dvgUiDgf5AS3w7P0rePvUp4KFqiVYDws+wi/waxibmODoX5cM3r4nojx079sbLBYL8QcTDB4PRf9UaME6/vcVGJuYoHnLrzVOP/AlFVGw7rx/BY9aXrCxs8XFR//opA5NBStrbhwK7e3w8sZVqe8/LspFx25dKsWgRAVLNrf/fQl3L0/YOzni6rNHGn/e2707kRvUEU8/vkMm8qlg/Z+qJFiZyMeNN89QzcMddo4OuJz5wOBtTM/NQmO/5jAxNcXxv68YPB6KfqmwgnX9VSZcqrnB0cUZ11480frnVzTBelSYg5Yd2oHL42Hf/+ej6AJt5MF69lL+I9X/5LyHTxPfCj8oUcGSzqPCHLRs3xZcHg/7z5/WSR1UsMRUNcHKRD5O3fkbZkIh6jduhLRP/xq8nX+/fgrXGtXhUs1NJ79VlPJLhRSsB/nZaPZVAIyMjXHk2p86qaOiCdaoyRNBCMHSTet1Wo+2Eo0q4srTh3BwdoJLNTf8pUDIyitUsKQz8nvxagDLNm/QWR1UsMRURcHKRD62HfkDbDYbwWGhWp+Hqg7Jt/6Cqbk5fP39kJH3weDxUPRDhRSsyFEjwGAwsHbP7zqroyIJ1vKt8SCEYOj4sTqvS1+ClYl8HL6SCoGREZq08K+QgxIVrLJoY5UFZaCCJaaqClYm/nuS+rsfphm8rZnIx9bDB8FisdA5IqxcSB9F91Q4wZq3ajkIIRg/fapO66kognUwNQU8Ph+tgzriUWGOzuvTp2BlIh9rdu8Ag8FA2IB+Bu9rVaGCVRptrbKgDFSwxFRlwcpEPgaOFv8xvnxrvMHbm4l8xC5aoHZKEkrFo0IJ1s7ko2BzOHr5C6AiCNalJxmwdbBHDc+aessarG/BysR/J2n03DiD97kqUMH6jz8fp2ttlQVloIIlpqoL1qPCHLQNCQKPz9fZfD9VGTByOBgMBlZUomXBKNKpMIJ17p87sLCyQu369XAv+63O6yvvgpX26V/Ua9QQZkKhXn/ADSFYT0R5CO3XBwwGA79s32LwvlcWKlhitL3KgjJQwRJT1QUrE/m4++ENvOrWgaW1Nc7/PxefIXlY8BEBbVqBLxDgYGqKweOh6I4KIVh3sl6jZu1asLa1Qaqe1hUr74IV2q8PWCyW3gdwQwhWJv573JkvECDx4lmD978yUMHSzSoLykAFSwwVLDEXHtyHta0NPL1r4877VwZv+613L+Du5QlbB3u9j6UU/VHuBetxUS46dO0MDpeLhLMn9VZveRasqfPnGGxZCEMJVib+e9y5ogxKVLB0s8qCMlDBEkMF6z8Szp4El8dDYMf2epmvqojz6XdhaW2NOg18cP//+dsolYtyL1jjpk0BIQSLNqzRa73lVbA2HtgLJpNpsOVkDClYmfjvcee6DRuU+0GpqguWrlZZUAYqWGKoYJVm6ab1IIRg2HfjDN7+TORjz5kT4HC5aBPcqVxIH0W76EWw9qYkl6xE50ibo/X7iSN6jUFRZvlftm/RWyxmQqHMOALatNJbHPIG00FjR+ktjjbBndQ6j1t16qC3GIeMG1Om/kOXzuutfkII/n791CD13njzrFS703Oz9Fr/7lPHStV/6UmGXus/IWOVg0yIHxbQZyzK/g7YOznqLaaF61aXqd/cQqi3+hVNTu/Wp5feYqmIT1dXJfQqWL1798bkyZN1Rps2bUCIfMHq16+fTmMIDAwEIcoL1rBhw3QaT9OmTWGuQLBcXV11GsPkyZPB4/EUCpZAIED//v11irWNjUaC5eTkpPO+MjIykitYEREROq2/QwexSH4pWLqut3379iBEtmA1btxYp+eGpN2yBCsoKEin7Q8NDVVasIKDg3UaS/fu3VUTLEdHeHp66vT4hIWFyRYsoRDe3t46rV/SJ8oIllAo1PlYZmZuRgWrnKNXwTp58iR0WZYsWaJQsM6dO6fTGObPn6+SYKWlpek0nokTJyoUrFatWuk0BgAwU3A7YNDYUbC0skJqaqpOqVevnkaC1aJFC533lY2NjVzBOnz4sE7rX7VqlVTB0nW9K1eulCtYY8eO1em5sXr1armCtXHjRp22PyEhQWnBio+P12kse/bsUVmwQkNDdXp8EhMT5QpWnz59dFq/pE+UEazqNWrofCxzdXOjglXOoYKl5UIFS3qhgqV8oYJFBUvWOUgFiwoWFayKAxUsLRcqWNILFSzlCxUsKliyzkEqWFSwqGBVHKhgablQwZJeqGApX6hgUcGSdQ5SwaKCRQWr4kAFS8uFCpb0QgVL+UIFiwqWrHOQChYVLCpYFYdyI1jZ2dklAykFj8dTalDQlmC9f/8eU6ZMgaenJ3g8HiwsLPDVV1/h0KFDCvfVpmDFxMTI7BNl+0UXgpWVlQVnZ2cQQhAZGanUPtoQrJMnT8rsCw6HUy4E69mzZxg5ciQaN24Ma2tr8Hg8VKtWDb169cLly5eV6ittCJYm57AmgqVJvdoQrKSkJISGhsLW1hZsNhu2trYIDw/HsWPHdC5Ymn5ftSlYmo6nuhIsTY6PNgRr//79CA8Ph4uLC3g8HoRCIXx8fDBz5kyDCNbx48cRGRkJV1dXcDgcmJqaokGDBliyZAkVrEpAuROsJk2aIC4urhTz5s1TOCAA2hGszMxMeHh4gMlkIigoCJMmTUJUVBSCg4MRFxenMAZtCtapU6fK9EVcXBwiIyNBCEHXrl0VxqMLwRo1ahRMTEwMJlje3t4YPnx4KUaNGlUuBCs1NRU1atRAREQEoqKiEBMTg4iICPD5fLDZbBw9elRhX2kqWJqew+oKlqb1aipYSUlJcHR0BIPBQFBQECZMmIDQUPEyPe7u7jh58qROBUvT76suBEvd8VQXgqXp8dFUsJKSkmBlZQUWi4Xg4GBERUVhxIgRcHNzAyEEAwcO1KtgHTx4EM7OzmAymfD390f//v3Rp08ftGjRAsOHD6eCVQkod4I1fPhwhV9+WUUbgtW6dWuYmZmpfStRH7cIx44dC0IIDh48qHBbbQvWuXPnwGQysWjRIoMJVvfu3ZWSKUMIlqxy5Ij4/OvSpYvCbTUVLE3PYXUFS9N6NRWsPn36gBCC7777rtTrc+aIl5YaOnSoTgVLVlH2+6oLwVJ3PNWFYGl6fDQVrKlTp4IQgiFDhpR6/cSJEzAzM4NQKNSrYPn6+sLY2Bhr165VayyjglX+KZeC9e7dOzx58gQFBQUqDQqaCtb58+IfktmzZwMA8vLykJWVpVIMuhas3NxcWFhYwMnJCYWFhQq316Zg5efnw9vbG2FhYbhz545BBevYsWM4cOAAzp49WyEE69mzZyCEoEePHgq31USwtHEOqyNY2qhXU8GqVasWGAyG1CshxsbGcHR01LtgqfJ91ZVgqTOe6kKwND0+mgrWrFmzQAhBdHR0mfccHR1hb2+vN8Fau3YtCCEYMWIEUlNTkZKSghMnTlDB0gJdeoaLz/2o8WXeaxPcCYQQfBsTXea9nclHxX8E9wwv9fqjwhz4NPFF54iwUq9fe/4YQktLzFq2WGYs5U6weDxecQwCgQC9evVCZmamUoOCpoI1bdo0EEKwZ88etG/fHgwGA4QQuLi4YPny5UrFoGvB2rp1KwghmDZtmlLba1OwZs6cCTMzMzx9+tSggsXhcErNJ2nXrh0OHjxYrgTr48ePePDgAe7fv4+kpCR8/fXXMDMzw8WLFxXuq4lgaeMcVkewtFGvpoJVo0YNsNlsnD9/vsx7VlZWIIQgKSlJr4KlyvdVF4Kl7niqC8HS9PhoKlhnzpxB7dq1YW1tjXnz5mHv3r3YsmULunXrBiaTidjYWL0J1qBBg0AIwfz589GsWbPi74udnR2ioqKoYGlAl57hcHRxho29HR5+/lT8+rXnj8Hl8WDrYC9VsEL79YFPE19weTzcevei1HvJt/4Cl8fDr7u2F7/WrnMwmrf8Gk9EeTJjKTeC9fHjR/j4+CA2Nhbx8fFYtmxZ8dIVTk5OeP78ucJBQVPBkizFYG1tjWbNmmHjxo1Yv349GjduDEIIZs6cqTAGXQtWYGAgGAwGHjx4oNT22hKsO3fugMfj4eeffy7+vyEEq2bNmhgyZAimT5+O7777Ds2bNwchBDY2Nvjjjz/KjWBt37695BcLnp6euH79ulL7aiJY2jiH1REsbdSrqWBJlspauXJlqddLHotNmzbpVbBU+b5qU7A0HU91IViaHh9tTHI/ffp0cT9IMDMzU2pSuTYFq3Xr1iCEQCgUok6dOpg+fTpiYmJQq1YtEELwzTffUMFSky49w9GlZziqebgj/mBC8esxC+ahTXAnePvULyNYd7Jegy8QIPHiWXh618bsFcvKfO7U+XNgZWOD668ysSBdcXgAAAsNSURBVCR+HYyMjXE+457cWMqNYMkqU6ZMASEEo0ePVritpoIl+eK5u7sjPz+/+PWcnBy4uLiAz+fj7du3cmPQpWClpaWBEIK2bdsqvY82BEskEuGrr76Cr68vioqKABhGsGQhmUQcFhZWbgQrMzMTCQkJ2LZtG6Kjo2FhYQEbGxtcvXpV4b6aCJY2zmF1BEsb9WoqWGvXrgWTyYSdnR3mzZuHPXv2YPHixXBzcyu+6vnrr7/qTbBU/b7qI02DsuOpLgRL0+OjqWClpKTAz88PLBYLERERmDNnDqKjo+Hh4QEej4dFixbpTbAkfxg6OTkhJSWllADa2dmBy+Xi6NGjVLDUQCJYk2bPRFCP7sWve3rXxq+7tksVrPmrV8Crbh1kIh+xixagXqOGZT73UWEOGjZrisCO7WEmFGLOL2Ul7EvKvWDl5eWBzWbDw8ND4baaCla3bt1ACEFsbGyZ9yZNmgRCFE9U1aVgTZ48GYQQ7NixQ+l9tCFYq1evBovFwpUrV4pfK0+ClZKSAhaLBWdn53IjWF+WmzdvgsfjoVmzZgq31USwtHEOqyNY2qhXG2ka5s2bB2tr61JXKNq0aYNOncRzL7Zu3ao3wVL1+6oPwVJ2PNVVmgZNjo+mgjVu3DgQQjBhwoRSr586dQoODg4QCoVyn2TUpmC1bNkShJSdcJ+amor+/fuDEIKffvqJCpYaSATrz8fp4PH5uPHmGRIvnoXQ0hIP8rOlClaDpk3ww+KFyEQ+rr/KBIfLxbHrl8uOwZcvgBCCJi385d4alFDuBQsAnJ2dYWFhoXA7TQVrzJgxIIRg1apVMj9706ZNcmPQlWB9/vwZdnZ2sLa2LnWFQFHRVLA+fPgAc3NzhIeHIy0trRjJU3GhoaFIS0tTeHVC14lGbW1tYWpqWm4FCwD8/PzAZDKRl5cndztNBEsb57A6gqWNerWVaPTcuXPYvHkzVqxYgX379iE1NRV169YFi8XCqVOn9CJY6nxf9ZVoVJnxVJeJRtU9PpoKVkBAAAghSExMLPNeeLh4YrS8J/q0KViS+iZNmlTmvfHjxxf/sUIFS3UkgpWJfHzdrg3ifl6CASOHY9CYkchEfhnBSr55DRwut3i8y0Q+gsNCpY7BkaNGQGBkBEtra/z1MlNhLOVesN6/fw8mkwlvb2+F22oqWJIJqVOmTCnz3oQJE0CIeBKmvKIrwdq7d2/xX1+qFE0F68mTJ6X+2pRFTEyM3Dh0KVjHjx8Hk8lE9erVy7Vg1a1bF0wmU+HTXJoIljbOYXUESxv16iqT+969e8FkMtGkSRO522lTsNT5vupDsJQdT/WZyV3Z46OpYEluy0mkriTdu3cv/gNBH4I1c+bM4jsAX77Xu3dvEEKwdOlSKlhqUFKwVvy2GbXr14O5hQUOXb6ATJQVrGHfia9sslisYphMJiytrfEgP7t4u53JR8Fms7Hv3Ck0aNoEwWGhCmMpN4KVnp4OkUhU6rWCgoLiy6XSBu4vi6aClZWVBaFQCEdHR7x//7749bdv38La2hrm5ubIzs6WG4OuBCsoKAiEENy6dUup7SVFU8HKycnBrl27yrBs2TIQQhAYGIhdu3bh5s2bcuPQhmDt2bMHFy5cKPXa2bNni28vSBus9C1Yd+/exefPn8u8vnv3bjAYDLRs2VLhMdNEsLRxDqsjWNqoVxuCVXI+S2qqeE6Lr68vGAwGfvnlF70JljrfV20Klqbjqa4ES5Pjo6lgDR48GISUzbd15MgRWFpagsPhyM0or03BOnHiBExNTWFtbY3jx48Xv3706FEIhUKYmJgoTLxKBUs6JQUrPTcLZkIhatWrW/x+ScF6WPAR1rY2mLl0EU7cuFoKKxsbrNm9A5nIx73st3Cp5lb8GybtqUJplBvBGjJkCGrUqIH+/ftjypQpGDVqFDw9PUEIgY+Pj1I5dbSRaHTTpk0ghMDDwwNxcXGYNWsWqlWrBkII1q9frzAGXQjWkydPwGQy4efnp3DbL4uu1iI0xBysLl26wMnJCZ06dUJkZCR69OgBV1dXEEJQs2ZNpfLI6FqwIiMj4eTkhL59+yI6OhoTJkxAq1atQAiBubk5/vrrL4V9pWmiUU3PYXUTjWpar6aCde7cOZiamqJ9+/YYOHAgwsPDYWdnB0L+yzekD8FS9/uqTcHSdDzVhWBpeny0kcnd1tYWhBC0bt0a48ePx+DBg2FjYyNVvHQpWKmpqYiNFf/4Ojs7Y/jw4Rg2bBgcHByK7wgo2p8KlnRKClYm8nHn/atSTlBSsNbt3Qkeny/VGXoPGYTWQR2RiXz0HzEMHrW8kJ6bVfz+lHmzYW1rU2a8Kkm5Eax9+/YhJCSkeI0ogUCA+vXrY9asWfj06ZNSA5S21iJMTExEQEAAjI2NYWRkhICAACQmJioVgy4ES3I5WZkfqS9LZRKsBQsWICAgAHZ2duBwOODxePDw8MCwYcPkzt3Qp2AdOXIEERERqF69OgQCAXg8Hjw9PTF69Gg8evRIqb7SxlqEmpzDmqxFqEm9mgrWhQsX0KVLF7i4uIDL5cLU1BRNmzZVeKtF24Kl7vdVm4Kl6XiqC8HS9PhoI01DYmIiunfvDnt7e7BYLAgEAtSrVw8//PCDwn11sRbhokWL4OPjA4FAAD6fDx8fH4VPM1LBks+XgvUlJQWrbUgQ2ncJkbrdlkMHwGKxsGzzBrDZbBy4cKbU+5IEpF17Rcisq9wIljaKtgRLk6KPpXJUKboSLFWLrie5K4sh52ApW7QhWJoUTQRLk6KrOVjKoqulcpQt+prkrkzR5xwsZdGGYGmCLgRLE6hglX+oYGm5UMGSXqhgKV+oYFHBknUOUsGigkUFq+JABUvLhQqW9EIFS/lCBYsKlqxzkAoWFSwqWBUHKlhaLlSwpBcqWMoXKlhUsGSdg1SwqGBRwao4UMHScqGCJb1QwVK+UMGigiXrHKSCRQWLClbFQa+C9euvv+Ly5cs6IyoqSqFgbdiwQacxjB07ViXBSkhI0Gk8/fr1UyhYvr6+Oo3h8uXLMDY2VihYZubmiI+P1ynuHh4aCZaPj4/O+8rCwkKuYC1fvlyn9UvWq/tSsHRdb3R0tFzB6tWrl07PjalTp8oVrB9++EGn7f/pp5+UFqwZM2boNJaFCxeqLFitW7fW6fFZunSpXMHq2LGjTutfsGCB0oLl6OSo87HM3t6eClY5R6+CpS/kCZa+UFaw9IGZAsHSVxyKBEtfcWgiWPqKUZ5g6YsvBUtfyBIsfSFLsPSFMoKlL1QRLH3FJFWwLIR6q18ZwdJXLFSwyjd6Eazb/77E9mOH9cajwpwyMdx8+1yvMShaCPLaiyd6i2XXyWMy4zh8JVVvcaTcvyUzjtN3b+gtjiPX/lTrPE66elFvMZ6+e6NM/XeyXuut/u3HDhf/kWCoeiU8LsrVa/233r0oVX9G3ge91i/tD0QJ6blZeo3l/sd3Sn039pw5obeYrjx9WKb+3aeO6a3+a88fy+2LEzeu6i2W5JvXDC4RFNnoRbAoFAqFQqFQqhJUsCgUCoVCoVC0DBUsCoVCoVAoFC1DBYtCoVAoFApFy1DBolAoFAqFQtEyVLAoFAqFQqFQtAwVLAqFQqFQKBQtQwWLQqFQKBQKRctQwaJQKBQKhULRMlSwKBQKhUKhULQMFSwKhUKhUCgULUMFi0KhUCgUCkXLUMGiUCgUCoVC0TJUsCgUCoVCoVC0jEzB6tozHANGDqdQKBQKhUKhqIiPb2PpgkWhUCgUCoVC0QoGD4BCoVAoFAqlUvE/AUYrxu5CqR8AAAAASUVORK5CYII=)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZRwWeM94gPs7"
   },
   "source": [
    "Pseudokod:\n",
    "\n",
    "```\n",
    "function alphabeta(node, depth, α, β, maximizingPlayer) is\n",
    "    if depth = 0 or node is a terminal node then\n",
    "        return the heuristic value of node\n",
    "    if maximizingPlayer then\n",
    "        value := −∞\n",
    "        for each child of node do\n",
    "            value := max(value, alphabeta(child, depth − 1, α, β, FALSE))\n",
    "            α := max(α, value)\n",
    "            if α ≥ β then\n",
    "                break (* β cutoff *)\n",
    "\n",
    "        return value\n",
    "    else\n",
    "        value := +∞\n",
    "        for each child of node do\n",
    "            value := min(value, alphabeta(child, depth − 1, α, β, TRUE))\n",
    "            β := min(β, value)\n",
    "            if α ≥ β then\n",
    "                break (* α cutoff *)\n",
    "        return value\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "--C2n5H6HXmM",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "source": [
    "## Zadanie 4 (2 punkty)\n",
    "\n",
    "Zaimplementuj gracza realizującego algorytm alfa-beta pruning, zmodyfikuj funkcje ewaluacji tak by preferowała szybkie zwycięstwo i penalizowała szybką porażkę.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu minimax z $\\alpha$-$\\beta$ pruningiem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def alphabeta(\n",
    "    board: np.ndarray,\n",
    "    player: int,\n",
    "    is_maximizing: bool = True,\n",
    "    alpha: float = -inf,\n",
    "    beta: float = inf,\n",
    ") -> tuple[int, tuple[int, int] | None]:\n",
    "\n",
    "    opp = opponent(player=player)\n",
    "\n",
    "    state = eval(board=board, player=opp, is_maximizing=(not is_maximizing))\n",
    "\n",
    "    if state is not None:\n",
    "\n",
    "        score = state * (len(get_possible_moves(board=board)) + 1)\n",
    "\n",
    "        return score, None\n",
    "\n",
    "    best_move = None\n",
    "    best_eval = -inf if is_maximizing else inf\n",
    "\n",
    "    for move in get_possible_moves(board=board):\n",
    "\n",
    "        new_board = deepcopy(board)\n",
    "        new_board[move] = player\n",
    "\n",
    "        current_eval, _ = alphabeta(\n",
    "            board=new_board,\n",
    "            player=opp,\n",
    "            is_maximizing=(not is_maximizing),\n",
    "            alpha=alpha,\n",
    "            beta=beta,\n",
    "        )\n",
    "\n",
    "        if (is_maximizing and current_eval > best_eval) or (\n",
    "            not is_maximizing and current_eval < best_eval\n",
    "        ):\n",
    "            best_eval = current_eval\n",
    "            best_move = move\n",
    "\n",
    "        if is_maximizing:\n",
    "            alpha = max(current_eval, alpha)\n",
    "        else:\n",
    "            beta = min(current_eval, beta)\n",
    "\n",
    "        if alpha >= beta:\n",
    "            break\n",
    "\n",
    "    return best_eval, best_move"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T13:04:42.368902Z",
     "start_time": "2022-11-08T13:04:42.353193Z"
    },
    "editable": true,
    "id": "M0dGwlnFS8hj",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [],
   "source": [
    "class AlphaBetaPlayer(PlayerInterface):\n",
    "    def move(self, board, player, verbose=True):\n",
    "        # your_code\n",
    "\n",
    "        best_eval, best_move = alphabeta(\n",
    "            board=board, player=player, is_maximizing=True, alpha=-inf, beta=inf\n",
    "        )\n",
    "\n",
    "        if verbose:\n",
    "            print(\n",
    "                f\"\\nBest move for {CHARS[player]} with score {best_eval} is {best_move}\"\n",
    "            )\n",
    "\n",
    "        if best_move is not None:\n",
    "            board[best_move] = player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "editable": true,
    "id": "gejqt6hxoGGD",
    "outputId": "46750746-5c9a-4abc-98d0-6846cd7c1a10",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score 0 is (0, 0)\n",
      "\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with score 0 is (1, 1)\n",
      "\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score 0 is (0, 1)\n",
      "\n",
      "---------------\n",
      "| O || O ||   |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with score 0 is (0, 2)\n",
      "\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score 0 is (2, 0)\n",
      "\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with score 0 is (1, 0)\n",
      "\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| X || X ||   |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score 0 is (1, 2)\n",
      "\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with score 0 is (2, 1)\n",
      "\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "| O || X ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score 0 is (2, 2)\n",
      "\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "| O || X || O |\n",
      "---------------\n",
      "draw\n",
      "Wall time: 805 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'draw'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "game = TicTacToe(AlphaBetaPlayer(), MinimaxPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed games: 15/15 - 100.00%\r"
     ]
    }
   ],
   "source": [
    "outcomes = get_outcome_distribution(\n",
    "    N=15, player1=AlphaBetaPlayer(), player2=MinimaxPlayer()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_outcome_distribution(N=15, outcomes=outcomes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Jywnp22zmd-o"
   },
   "source": [
    "# Monte Carlo Tree Search (MCTS)\n",
    "\n",
    "Metody Monte Carlo polegają na wprowadzeniu losowości i przybliżaniu za jej pomocą rozwiązań dla trudnych problemów. Dla gry w kółko i krzyżyk nie jest to co prawda niezbędne, ale dla bardziej skomplikowanych gier, jak szachy czy go, już zdecydowanie tak.\n",
    "\n",
    "Ogólna metoda MCTS składa się z 4 etapów:\n",
    "\n",
    "- selekcji - wybieramy najlepsze dziecko, aż dotrzemy do liścia,\n",
    "- ekspansji - jeżeli nie możemy dokonać selekcji, rozwijamy drzewo we wszystkich możliwych kierunkach z węzła,\n",
    "- symulacji - po ekspansji wybieramy węzeł do przeprowadzenia symulacji gry aż do końca,\n",
    "- wstecznej propagacji - kiedy dotrzemy do końca, ewaluujemy wynik gry i propagujemy go w górę drzewa.\n",
    "\n",
    "W naszym wypadku wystarczy nieco prostszy algorytm Pure Monte Carlo Tree Search (Pure MCTS), w którym realizujemy tylko symulację i wsteczną propagację. Dla każdego możliwego ruchu w danej rundzie przeprowadzamy N symulacji oraz obliczamy prawdopodobieństwo zwycięstwa/remisu/przegranej dla każdego z możliwych ruchów, a następnie wybieramy najlepszy ruch.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "ahb1QeIfHcH3",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "source": [
    "## Zadanie 5 (2 punkty)\n",
    "\n",
    "Zaimplementuj gracza realizującego algorytm Pure MCTS.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funkcja ewaluująca jakość otrzymanego wyniku:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Powstała w celu ważenia wyników, niżeli polegania na suchym porównywaniu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_score(wins: int, draws: int, losses: int) -> float:\n",
    "    return -inf if any(map(lambda p: p==-inf,[wins, draws, losses])) else wins + 0.5 * draws - 3 * losses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funkcja przeprowadzająca n symulacji dla danego ułożenia planszy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "\n",
    "\n",
    "def n_simulations(N: int, board: np.ndarray, player: int) -> np.ndarray:\n",
    "    outcomes = np.zeros(3)\n",
    "    opp = opponent(player=player)\n",
    "\n",
    "    for _ in range(N):\n",
    "\n",
    "        sample_board = deepcopy(board)\n",
    "\n",
    "        if check_for_end(board=sample_board, player=player):\n",
    "            outcome = \"win\"\n",
    "        elif check_for_end(board=sample_board, player=opp):\n",
    "            outcome = \"loss\"\n",
    "        else:\n",
    "\n",
    "            curr_player = opp\n",
    "\n",
    "            while get_possible_moves(board=sample_board):\n",
    "                move = random.choice(get_possible_moves(board=sample_board))\n",
    "                sample_board[move] = curr_player\n",
    "\n",
    "                if check_for_end(board=sample_board, player=curr_player):\n",
    "                    outcome = \"win\" if curr_player == player else \"loss\"\n",
    "                    break\n",
    "                curr_player *= -1\n",
    "            else:\n",
    "                outcome = \"draw\"\n",
    "\n",
    "        match outcome:\n",
    "            case \"win\":\n",
    "                outcomes[0] += 1\n",
    "            case \"draw\":\n",
    "                outcomes[1] += 1\n",
    "            case \"loss\":\n",
    "                outcomes[2] += 1\n",
    "    return outcomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementacja algorytmu Pure Monte-Carlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pure_monte_carlo(\n",
    "    board: np.ndarray, player: int, N: int\n",
    ") -> tuple[np.ndarray, tuple[int, int]]:\n",
    "\n",
    "    best_proba = np.full(3, -inf)\n",
    "    best_move = None\n",
    "\n",
    "    moves = get_possible_moves(board=board)\n",
    "    \n",
    "    for move in moves:\n",
    "        \n",
    "        new_board = deepcopy(board)\n",
    "        new_board[move] = player\n",
    "        \n",
    "        outcomes = n_simulations(N=N, board=new_board, player=player)\n",
    "\n",
    "        curr_wins, curr_draws, curr_losses = outcomes\n",
    "        best_wins, best_draws, best_losses = best_proba\n",
    "\n",
    "        if get_score(wins=curr_wins, draws=curr_draws, losses=curr_losses) > get_score(\n",
    "            wins=best_wins, draws=best_draws, losses=best_losses\n",
    "        ):\n",
    "            best_proba = outcomes\n",
    "            best_move = move\n",
    "\n",
    "    return best_proba, best_move"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T13:08:53.710354Z",
     "start_time": "2022-11-08T13:08:53.683363Z"
    },
    "editable": true,
    "id": "_kixa8QfoPli",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [],
   "source": [
    "class PureMonteCarloPlayer(PlayerInterface):\n",
    "    def move(self, board, player, verbose=True):\n",
    "\n",
    "        N = 1000\n",
    "\n",
    "        best_proba, best_move = pure_monte_carlo(board=board, player=player, N=N)\n",
    "\n",
    "        probas = np.char.add(np.round(((best_proba / N) * 100), 2).astype(str), \"%\")\n",
    "        wins, draws, losses = best_proba\n",
    "        score = get_score(wins=wins, draws=draws, losses=losses)\n",
    "\n",
    "        if verbose:\n",
    "            print(\n",
    "                f\"\\nBest move for {CHARS[player]} with probas [win, draw, loss]: {probas}, score: {score}, is {best_move}\"\n",
    "            )\n",
    "\n",
    "        if best_move is not None:\n",
    "            board[best_move] = player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "editable": true,
    "id": "ok8ely0adZNI",
    "outputId": "9636df6b-abb6-4465-9c43-df0d23d68455",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with probas [win, draw, loss]: ['67.1%' '12.7%' '20.2%'], score: 128.5, is (1, 1)\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with probas [win, draw, loss]: ['22.2%' '13.0%' '64.8%'], score: -1657.0, is (0, 2)\n",
      "\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with probas [win, draw, loss]: ['68.6%' '15.5%' '15.9%'], score: 286.5, is (1, 2)\n",
      "\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "|   || O || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with probas [win, draw, loss]: ['15.2%' '32.2%' '52.6%'], score: -1265.0, is (1, 0)\n",
      "\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with probas [win, draw, loss]: ['69.2%' '30.8%' '0.0%'], score: 846.0, is (0, 0)\n",
      "\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with probas [win, draw, loss]: ['0.0%' '64.8%' '35.2%'], score: -732.0, is (2, 2)\n",
      "\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "|   ||   || X |\n",
      "---------------\n",
      "\n",
      "Best move for O with probas [win, draw, loss]: ['51.4%' '48.6%' '0.0%'], score: 757.0, is (2, 1)\n",
      "\n",
      "---------------\n",
      "| O ||   || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "|   || O || X |\n",
      "---------------\n",
      "\n",
      "Best move for X with probas [win, draw, loss]: ['0.0%' '100.0%' '0.0%'], score: 500.0, is (0, 1)\n",
      "\n",
      "---------------\n",
      "| O || X || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "|   || O || X |\n",
      "---------------\n",
      "\n",
      "Best move for O with probas [win, draw, loss]: ['0.0%' '100.0%' '0.0%'], score: 500.0, is (2, 0)\n",
      "\n",
      "---------------\n",
      "| O || X || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "draw\n",
      "Wall time: 1.94 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'draw'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "game = TicTacToe(PureMonteCarloPlayer(), PureMonteCarloPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "wkDVcylKJaTG",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "source": [
    "## Turniej - zadanie specjalne!\n",
    "\n",
    "Teraz przeprowadzimy turniej w celu porównania zaimplementowanych metod. Każdy algorytm będzie grał z każdym po 10 razy.\n",
    "\n",
    "**NIE WYKONANIE TURNIEJU SKUTKUJE AUTOMATYCZNYM ZEREM ZA CAŁOŚĆ LABORATORIUM**\n",
    "\n",
    "Należy go wykonać nwet wtedy gdy nie wszystkie algorytmy zostały zaimplementowane.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "editable": true,
    "id": "aVNaDdwdRhoN",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "import pandas as pd\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "def print_scores(scores, names):\n",
    "    win = {}\n",
    "    for name in names:\n",
    "        win[name] = [scores[\"win\"][name][n] for n in names]\n",
    "    loss = {}\n",
    "    for name in names:\n",
    "        loss[name] = [scores[\"loss\"][name][n] for n in names]\n",
    "    draw = {}\n",
    "    for name in names:\n",
    "        draw[name] = [scores[\"draw\"][name][n] for n in names]\n",
    "\n",
    "    print(\"wins\")\n",
    "    df = pd.DataFrame.from_dict(win, orient=\"index\", columns=names)\n",
    "    display(df)\n",
    "    print(\"losses\")\n",
    "    df2 = pd.DataFrame.from_dict(loss, orient=\"index\", columns=names)\n",
    "    display(df2)\n",
    "    print(\"draws\")\n",
    "    df3 = pd.DataFrame.from_dict(draw, orient=\"index\", columns=names)\n",
    "    display(df3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 713
    },
    "editable": true,
    "id": "Sf8fn_m39nef",
    "outputId": "4168d336-bf24-45de-84bb-59efef2a83c0",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wins\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>RandomPlayer</th>\n",
       "      <th>Blocking</th>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <th>PureMonteCarloPlayer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RandomPlayer</th>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Blocking</th>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <td>10</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <td>10</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PureMonteCarloPlayer</th>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      RandomPlayer  Blocking  RandomPlayerWinIfCan  \\\n",
       "RandomPlayer                     5         0                     3   \n",
       "Blocking                        10         4                     7   \n",
       "RandomPlayerWinIfCan             8         1                     8   \n",
       "MinimaxPlayer                   10         9                    10   \n",
       "AlphaBetaPlayer                 10         9                    10   \n",
       "PureMonteCarloPlayer            10         3                    10   \n",
       "\n",
       "                      MinimaxPlayer  AlphaBetaPlayer  PureMonteCarloPlayer  \n",
       "RandomPlayer                      0                0                     0  \n",
       "Blocking                          0                0                     2  \n",
       "RandomPlayerWinIfCan              0                0                     1  \n",
       "MinimaxPlayer                     0                0                     0  \n",
       "AlphaBetaPlayer                   0                0                     0  \n",
       "PureMonteCarloPlayer              0                0                     2  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "losses\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>RandomPlayer</th>\n",
       "      <th>Blocking</th>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <th>PureMonteCarloPlayer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RandomPlayer</th>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Blocking</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>10</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PureMonteCarloPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      RandomPlayer  Blocking  RandomPlayerWinIfCan  \\\n",
       "RandomPlayer                     2         8                     7   \n",
       "Blocking                         0         2                     0   \n",
       "RandomPlayerWinIfCan             1         5                     1   \n",
       "MinimaxPlayer                    0         0                     0   \n",
       "AlphaBetaPlayer                  0         0                     0   \n",
       "PureMonteCarloPlayer             0         0                     0   \n",
       "\n",
       "                      MinimaxPlayer  AlphaBetaPlayer  PureMonteCarloPlayer  \n",
       "RandomPlayer                      8                7                    10  \n",
       "Blocking                          2                1                     1  \n",
       "RandomPlayerWinIfCan              8               10                     6  \n",
       "MinimaxPlayer                     0                0                     0  \n",
       "AlphaBetaPlayer                   0                0                     0  \n",
       "PureMonteCarloPlayer              0                0                     0  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "draws\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>RandomPlayer</th>\n",
       "      <th>Blocking</th>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <th>PureMonteCarloPlayer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RandomPlayer</th>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Blocking</th>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PureMonteCarloPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      RandomPlayer  Blocking  RandomPlayerWinIfCan  \\\n",
       "RandomPlayer                     3         2                     0   \n",
       "Blocking                         0         4                     3   \n",
       "RandomPlayerWinIfCan             1         4                     1   \n",
       "MinimaxPlayer                    0         1                     0   \n",
       "AlphaBetaPlayer                  0         1                     0   \n",
       "PureMonteCarloPlayer             0         7                     0   \n",
       "\n",
       "                      MinimaxPlayer  AlphaBetaPlayer  PureMonteCarloPlayer  \n",
       "RandomPlayer                      2                3                     0  \n",
       "Blocking                          8                9                     7  \n",
       "RandomPlayerWinIfCan              2                0                     3  \n",
       "MinimaxPlayer                    10               10                    10  \n",
       "AlphaBetaPlayer                  10               10                    10  \n",
       "PureMonteCarloPlayer             10               10                     8  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 7min 35s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "number_of_rounds = 10\n",
    "players = [\n",
    "    RandomPlayer(),\n",
    "    Blocking(),\n",
    "    RandomPlayerWinIfCan(),\n",
    "    MinimaxPlayer(),\n",
    "    AlphaBetaPlayer(),\n",
    "    PureMonteCarloPlayer(),\n",
    "]\n",
    "scores = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))\n",
    "\n",
    "for player in players:\n",
    "    for adversary in players:\n",
    "        for i in range(number_of_rounds):\n",
    "            game = TicTacToe(player, adversary, SIZE)\n",
    "            score = game.play(False)\n",
    "            # print(\"player name {} adversary name {} score {} \".format(player.name, adversary.name, score))\n",
    "            scores[score][player.name][adversary.name] += 1\n",
    "\n",
    "\n",
    "print_scores(scores, [player.name for player in players])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "id": "yiPBrh4AdmgC",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "source": [
    "# Zadanie dodatkowe (3 punkty)\n",
    "\n",
    "Rozwiń kod algorytmu MCTS tak, aby działał z ogólnymi zasadami, a nie w formie uproszczonego Pure MCTS.\n",
    "\n",
    "Zastosuj prosty, ale bardzo skuteczny sposób selekcji UCT (_Upper Confidence Bound 1 applied to trees_), będący wariantem bardzo skutecznych metod UCB, stosowanych m.in. w podejmowaniu decyzji, uczeniu ze wzmocnieniem i systemach rekomendacyjnych. Polega na wyborze tego węzła, dla którego następujące wyrażenie ma maksymalną wartość:\n",
    "\n",
    "$$\n",
    "\\large\n",
    "\\frac{w_i}{n_i} + c\\sqrt\\frac{\\ln N_i}{n_i}\n",
    "$$\n",
    "\n",
    "gdzie:\n",
    "\n",
    "- $w_i$ to liczba zwycięstw dla węzła po rozważeniu $i$-tego ruchu\n",
    "- $n_i$ to łączna liczba symulacji przeprowadzonych dla węzła po $i$-tym ruchu,\n",
    "- $N_i$ oznacza całkowitą liczbę symulacji przeprowadzoną po $i$-tym ruchu dla węzła-rodzica aktualnie rozważanego węzła,\n",
    "- $c$ to hiperparametr, wedle teorii powinien mieć wartość $\\sqrt{2}$.\n",
    "\n",
    "O uzasadnieniu tego wzoru możesz więcej przeczytać [tutaj](https://en.wikipedia.org/wiki/Monte_Carlo_tree_search#Exploration_and_exploitation).\n",
    "\n",
    "Jeżeli chcesz, możesz zastosować ten algorytm dla bardziej skomplikowanej gry, jak np. warcaby czy szachy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementacja drzewa przeszukiwań Monte-Carlo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stałe, funkcje pomocnicze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "editable": true,
    "id": "nCIck2r0_NmD",
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "ex"
    ]
   },
   "outputs": [],
   "source": [
    "C = np.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def UCT(s: int, n: int, N: int) -> float:\n",
    "    return inf if n == 0 else s / n + C * np.sqrt(np.log(N) / n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Węzeł drzewa Monte-Carlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MCSTNode:\n",
    "    def __init__(self, board: np.ndarray, player: int, k: int) -> None:\n",
    "        self.board: np.ndarray = board\n",
    "        self.player: int = player\n",
    "        self.k: int = k\n",
    "        self.children: list[MCSTNode] = []\n",
    "        self.parent: MCSTNode = None\n",
    "        self.move = None\n",
    "        self.n: int = 0\n",
    "        self.s: int = 0\n",
    "        self.visited = False\n",
    "\n",
    "    def rollout(self) -> None:\n",
    "        wins, draws, losses = n_simulations(\n",
    "            N=self.k, board=self.board, player=opponent(self.player)\n",
    "        )\n",
    "        self.s = get_score(wins=wins, draws=draws, losses=losses)\n",
    "        self.n = self.k\n",
    "        self.visited = True\n",
    "\n",
    "    def expand(self) -> None:\n",
    "        opp = opponent(player=self.player)\n",
    "        for move in get_possible_moves(board=self.board):\n",
    "\n",
    "            child_board = deepcopy(self.board)\n",
    "            child_board[move] = self.player\n",
    "\n",
    "            child = MCSTNode(board=child_board, player=opp, k=self.k)\n",
    "            child.parent = self\n",
    "            child.move = move\n",
    "\n",
    "            self.children.append(child)\n",
    "\n",
    "    def backpropagate(self, s: int, n: int) -> None:\n",
    "\n",
    "        if self.parent is None:\n",
    "            return\n",
    "\n",
    "        self.parent.s -= s\n",
    "        self.parent.n += n\n",
    "\n",
    "        self.parent.backpropagate(s=-s, n=n)\n",
    "\n",
    "    @property\n",
    "    def UCT(self) -> float:\n",
    "        return UCT(self.s, self.n, self.N)\n",
    "\n",
    "    @property\n",
    "    def N(self):\n",
    "        return self.parent.n\n",
    "\n",
    "    @property\n",
    "    def is_leaf(self) -> bool:\n",
    "        return not self.children\n",
    "\n",
    "    @property\n",
    "    def is_finite_state(self) -> bool:\n",
    "        return not get_possible_moves(self.board)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drzewo przeszukiwań Monte-Carlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MCST:\n",
    "    def __init__(self, board: np.ndarray, player: int, k: int, depth: int) -> None:\n",
    "        self.depth = depth\n",
    "        self.root = MCSTNode(board=deepcopy(board), player=player, k=k)\n",
    "        self.root.expand()\n",
    "\n",
    "    def __select(self, root: MCSTNode) -> MCSTNode:\n",
    "        if not root.is_leaf:\n",
    "            max_UCT = max(child.UCT for child in root.children)\n",
    "            max_children = [child for child in root.children if child.UCT == max_UCT]\n",
    "            current = random.choice(max_children)\n",
    "            return self.__select(root=current)\n",
    "        return root\n",
    "\n",
    "    def __visit(self, node: MCSTNode) -> None:\n",
    "        node.rollout()\n",
    "        node.backpropagate(s=node.s, n=node.n)\n",
    "\n",
    "    def __traverse(self, node: MCSTNode) -> None:\n",
    "\n",
    "        current = self.__select(root=node)\n",
    "\n",
    "        if not current.visited:\n",
    "            self.__visit(node=current)\n",
    "            return\n",
    "        if not current.is_finite_state:\n",
    "            current.expand()\n",
    "            child = self.__select(root=current)\n",
    "            self.__visit(node=child)\n",
    "\n",
    "    def next_best(self) -> tuple[float, tuple[int, int]]:\n",
    "\n",
    "        for _ in range(self.depth):\n",
    "            self.__traverse(node=self.root)\n",
    "\n",
    "        best_eval = -inf\n",
    "        best_move = None\n",
    "\n",
    "        for child in self.root.children:\n",
    "\n",
    "            if child.UCT > best_eval:\n",
    "                best_eval = child.UCT\n",
    "                best_move = child.move\n",
    "\n",
    "        return best_eval, best_move"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gracz, symulacja"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MonteCarloPlayer(PlayerInterface):\n",
    "    def move(self, board, player, verbose=True):\n",
    "\n",
    "        T = MCST(board=board, player=player, k=1000, depth=1000)\n",
    "\n",
    "        best_eval, best_move = T.next_best()\n",
    "\n",
    "        if verbose:\n",
    "            print(\n",
    "                f\"\\nBest move for {CHARS[player]} with score: {best_eval} is {best_move}\"\n",
    "            )\n",
    "\n",
    "        if best_move is not None:\n",
    "            board[best_move] = player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score: 1.0060393072389173 is (1, 1)\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with score 0 is (0, 0)\n",
      "\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score: 1.12857892476846 is (0, 1)\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with score 0 is (2, 1)\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score: 0.971596507063924 is (2, 0)\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| O || X ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with score 0 is (0, 2)\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| O || X ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score: 1.006034307711283 is (1, 2)\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "|   || O || O |\n",
      "---------------\n",
      "| O || X ||   |\n",
      "---------------\n",
      "\n",
      "Best move for X with score 0 is (1, 0)\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || X ||   |\n",
      "---------------\n",
      "\n",
      "Best move for O with score: 0.61753940002384 is (2, 2)\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || X || O |\n",
      "---------------\n",
      "draw\n",
      "Wall time: 4.72 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'draw'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "game = TicTacToe(MonteCarloPlayer(), AlphaBetaPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Porównanie z innymi graczami"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_rounds = 10\n",
    "players: list[PlayerInterface] = [\n",
    "    RandomPlayer(),\n",
    "    RandomPlayerWinIfCan(),\n",
    "    Blocking(),\n",
    "    MinimaxPlayer(),\n",
    "    AlphaBetaPlayer(),\n",
    "    PureMonteCarloPlayer(),\n",
    "    MonteCarloPlayer(),\n",
    "]\n",
    "\n",
    "scores = defaultdict(lambda: defaultdict(int))\n",
    "\n",
    "for player in players:\n",
    "    scores[player.name][\"win\"] = 0\n",
    "    scores[player.name][\"loss\"] = 0\n",
    "    scores[player.name][\"draw\"] = 0\n",
    "\n",
    "for adversary in players:\n",
    "    for i in range(number_of_rounds):\n",
    "        game = TicTacToe(MonteCarloPlayer(), adversary, SIZE)\n",
    "        score = game.play(False)\n",
    "        scores[adversary.name][score] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MonteCarloPlayer vs. results over 10 games:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>win</th>\n",
       "      <th>loss</th>\n",
       "      <th>draw</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RandomPlayer</th>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Blocking</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PureMonteCarloPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MonteCarloPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      win  loss  draw\n",
       "RandomPlayer           10     0     0\n",
       "RandomPlayerWinIfCan   10     0     0\n",
       "Blocking                3     0     7\n",
       "MinimaxPlayer           0     0    10\n",
       "AlphaBetaPlayer         0     0    10\n",
       "PureMonteCarloPlayer    0     0    10\n",
       "MonteCarloPlayer        0     0    10"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(scores).T.fillna(0).astype(int)\n",
    "print(f\"MonteCarloPlayer vs. results over {number_of_rounds} games:\")\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wydaję mi się, że implementacja jest poprawna. Wyniki zależą od liczby wykonywanych symulacji w trakcie `rolloutu` oraz głębokości przeszukiwania (parametr `depth`). W porównianiu z algorytamami minimax, które można traktować jako `'ground truth'`, jako że perfekcyjnie przeszukją stany gry, remisuje, co jest dobrym znakiem. Ta metoda powinna być lepsza lub równa od `Pure Monte-Carlo`, bo bierze pod uwagę większą przestrzeń, co potwierdza tabelka."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "jupytext": {
   "formats": "ipynb,py:percent"
  },
  "kernelspec": {
   "display_name": "ai-course-agh-_AsuPTn7-py3.11",
   "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.11.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}