LC_DSA_Notes.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNwWT/GWtNeSKJMO8cgiJzY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kurt980/Python_Notes/blob/main/LC_DSA_Notes.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import List"
      ],
      "metadata": {
        "id": "-HOLXyAAgtd-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Oz9EZ2QKLuFl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Before 2023-01-03**\n",
        "\n",
        "**5. Longest Palindrome**\n",
        "1. edge case\n",
        "2. conditions have order\n",
        "\n",
        "https://www.youtube.com/watch?v=dfIqLxAf-8s"
      ],
      "metadata": {
        "id": "g4BvOjoIeJ4b"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "jKP34lyFeJ-M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**53. Maximum Subarray**\n",
        "1. 2 popular solutions\n",
        "  - use accumulate sum\n",
        "  - use greedy\n",
        "2. solution 1 uses **121. Best Time to Buy and Sell Stock**, slight modification, moves updating to the front"
      ],
      "metadata": {
        "id": "KV4jfrfC6Rcm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def maxSubArray(self, nums: List[int]) -> int:\n",
        "        sums = accumulate(nums, initial = 0)\n",
        "        sums = list(sums)\n",
        "        # print(sums)\n",
        "        curr = sums[0]\n",
        "        res = -math.inf\n",
        "\n",
        "        for s in sums[1:]:\n",
        "            high = s - curr\n",
        "            res = max(res, high)\n",
        "            if s < curr:\n",
        "                curr = s\n",
        "            \n",
        "        return nums[0] if len(nums) == 1 else res"
      ],
      "metadata": {
        "id": "aCxbZu0D6Rr_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def maxSubArray(self, nums: List[int]) -> int:\n",
        "        res = nums[0]\n",
        "        cur = 0\n",
        "        for n in nums:\n",
        "            if cur < 0:\n",
        "                cur = 0\n",
        "            cur += n\n",
        "            res = max(res, cur)\n",
        "\n",
        "        return res"
      ],
      "metadata": {
        "id": "W8dHzEjW6qYR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**121. Best Time to Buy and Sell Stock**\n",
        "1. popular algorithm\n",
        "2. Can be used in one of the solutions of **53. Maximum Subarray**\n",
        "3. a new max can only happen when there's a smaller number"
      ],
      "metadata": {
        "id": "6YDe8mKK5pMo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def maxProfit(self, prices: List[int]) -> int:\n",
        "        prof = 0\n",
        "        cur = prices[0]\n",
        "        for p in prices[1:]:\n",
        "            if p < cur:\n",
        "                cur = p\n",
        "            diff = p - cur\n",
        "            prof = max(diff, prof)\n",
        "\n",
        "        return prof"
      ],
      "metadata": {
        "id": "XOjXiCTZ5pcY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**20. Valid Parentheses**\n",
        "1. good use of queue"
      ],
      "metadata": {
        "id": "uw8sOD-C8h-2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def isValid(self, s: str) -> bool:\n",
        "      \n",
        "        map = {')':'(', '}': '{', ']': '['}\n",
        "        temp = []\n",
        "        for c in s:\n",
        "            if c in (')', '}', ']'):\n",
        "                if not temp:\n",
        "                    return False\n",
        "                open = temp.pop(-1)\n",
        "                if open != map[c]:\n",
        "                    return False\n",
        "            else:\n",
        "                temp.append(c)\n",
        "\n",
        "        return not temp"
      ],
      "metadata": {
        "id": "BnCfe-u48iG6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-03**\n",
        "\n",
        "**5. Longest Palindrome**\n",
        "1. edge case\n",
        "2. conditions have order\n",
        "\n",
        "https://www.youtube.com/watch?v=dfIqLxAf-8s"
      ],
      "metadata": {
        "id": "tQ076qhWf2Yx"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XpSZdaCvfz4r"
      },
      "outputs": [],
      "source": [
        "class Solution:\n",
        "    # # dp\n",
        "    # def longestPalindrome(self, s: str) -> str:\n",
        "\n",
        "    #     res = ''\n",
        "    #     dpMat = [[0] * len(s) for _ in range(len(s))]\n",
        "\n",
        "    #     for i in range(len(s)):\n",
        "    #         dpMat[i][i] = True\n",
        "    #         res = s[i]\n",
        "\n",
        "    #     # traverse\n",
        "    #     for i in range(len(s)-1,-1,-1):\n",
        "             \n",
        "    #          for j in range(i+1, len(s)):\n",
        "\n",
        "    #              if s[i] == s[j]:\n",
        "                    \n",
        "    #                 if j - i == 1 or dpMat[i+1][j-1] is True:\n",
        "    #                     dpMat[i][j] = True\n",
        "\n",
        "    #                     if len(s[i:j+1]) > len(res):\n",
        "    #                         res = s[i:j + 1]\n",
        "        \n",
        "    #     return res \n",
        "\n",
        "    # middle pointer\n",
        "    def longestPalindrome(self, s: str) -> str:\n",
        "\n",
        "        res = ''\n",
        "\n",
        "        for i in range(0, len(s)):\n",
        "            # odd palindrome\n",
        "            l, r = i, i+1\n",
        "            while l >= 0 and r < len(s):\n",
        "                if s[l] != s[r]:\n",
        "                    break\n",
        "                if r - l + 1 > len(res):\n",
        "                    res = s[l: r+1]\n",
        "                l, r = l - 1, r + 1\n",
        "\n",
        "            # even palindrome\n",
        "            l, r = i, i\n",
        "            while l >= 0 and r < len(s):\n",
        "                if s[l] != s[r]:\n",
        "                    break\n",
        "                if len(res) < r - l + 1:\n",
        "                    res = s[l : r + 1]\n",
        "\n",
        "                l -= 1\n",
        "                r += 1\n",
        "        \n",
        "        return res"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-04**\n",
        "\n",
        "**200. Longest Palindrome**\n",
        "1. BFS is used to exhaust all neighboring points\n",
        "2. use of deque() and set()"
      ],
      "metadata": {
        "id": "XRwAwscxlDEO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def numIslands(self, grid: List[List[str]]) -> int:\n",
        "        # mark all points in an island\n",
        "        def bfs(r,c):\n",
        "            q = deque()\n",
        "            q.append((r,c))\n",
        "            visited.add((r,c))\n",
        "\n",
        "            while q:\n",
        "                row, col = q.popleft()\n",
        "                dirs = [[1,0],[-1,0],[0,1],[0,-1]]\n",
        "\n",
        "                for hor, ver in dirs:\n",
        "                    r1 = row + hor\n",
        "                    c1 = col + ver\n",
        "                    if r1 in range(len(grid)) and c1 in range(len(grid[0])):\n",
        "                        if grid[r1][c1] == \"1\" and (r1,c1) not in visited:\n",
        "                            q.append((r1,c1))\n",
        "                            visited.add((r1,c1))\n",
        "\n",
        "\n",
        "        # initialize \n",
        "        res = 0\n",
        "        visited = set()\n",
        "\n",
        "        # search all points\n",
        "        for i in range(len(grid)):\n",
        "            for j in range(len(grid[0])):\n",
        "                # \n",
        "                if grid[i][j] == \"1\" and (i,j) not in visited:\n",
        "                    bfs(i,j)\n",
        "                    res += 1\n",
        "\n",
        "        return res"
      ],
      "metadata": {
        "id": "wTo-sTHFlDKi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**973. Longest Palindrome**\n",
        "1. heapque is sorted by first value if a list"
      ],
      "metadata": {
        "id": "OpASArsEGa_F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:\n",
        "\n",
        "        for i in range(len(points)):\n",
        "            x,y = points[i]\n",
        "            dist = x**2 + y**2\n",
        "            points[i] = [dist, x, y]\n",
        "\n",
        "        # heapify\n",
        "        heapq.heapify(points)\n",
        "\n",
        "        res = []\n",
        "\n",
        "        for i in range(k):\n",
        "            dist, x, y = heapq.heappop(points)\n",
        "            res.append([x,y])\n",
        "\n",
        "        return res"
      ],
      "metadata": {
        "id": "9HaBrhn9GbGI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-05**\n",
        "\n",
        "**79. Word Search**\n",
        "1. Fuck this shit"
      ],
      "metadata": {
        "id": "eB4ORq2w9G5f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def exist(self, board: List[List[str]], word: str) -> bool:\n",
        "        rows = len(board)\n",
        "        cols = len(board[0])\n",
        "        visited = set()\n",
        "\n",
        "        # define dfs\n",
        "        def dfs(r,c,i):\n",
        "            # base case\n",
        "            if i == len(word):\n",
        "                return True\n",
        "\n",
        "            # termination conditions\n",
        "            if (r not in range(0, rows) or\n",
        "                c not in range(0, cols) or\n",
        "                i >= len(word) or\n",
        "                board[r][c] != word[i] or\n",
        "                (r,c) in visited\n",
        "                ):\n",
        "                return False\n",
        "            # current is good\n",
        "            visited.add((r,c))\n",
        "\n",
        "            res = (dfs(r + 1, c, i + 1) or\n",
        "                   dfs(r - 1, c, i + 1) or\n",
        "                   dfs(r, c + 1, i + 1) or\n",
        "                   dfs(r, c - 1, i + 1))\n",
        "            \n",
        "            visited.remove((r,c))\n",
        "\n",
        "            return res\n",
        "\n",
        "\n",
        "        # loop through all points\n",
        "        for r in range(rows):\n",
        "            for c in range(cols):\n",
        "                # return any successful attempt\n",
        "                if dfs(r,c,0): return True\n",
        "\n",
        "        return False"
      ],
      "metadata": {
        "id": "Z8y5QfcS9HB3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**621. Task Scheduler**\n",
        "1. I have no fucking idea, just memorize this shit"
      ],
      "metadata": {
        "id": "bGUH6dI4uqde"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def leastInterval(self, tasks: List[str], n: int) -> int:\n",
        "        # I have no fucking idea how this works, just memorize it.\n",
        "        tasks.sort()\n",
        "\n",
        "        # get frequency table\n",
        "        freq = []\n",
        "        count = 0\n",
        "        prev = ''\n",
        "        for t in tasks:\n",
        "            if t == prev:\n",
        "                pass\n",
        "            else:\n",
        "                freq.append(tasks.count(t))\n",
        "                prev = t\n",
        "\n",
        "        # reverse it\n",
        "        tasks1 = [-f for f in freq]\n",
        "        heapq.heapify(tasks1)\n",
        "\n",
        "        # starts this shit\n",
        "        q = deque()\n",
        "        time = 0\n",
        "        while tasks1 or q:\n",
        "            time += 1\n",
        "            # \n",
        "            if tasks1:\n",
        "\n",
        "                task = heapq.heappop(tasks1)\n",
        "\n",
        "                if task != -1:\n",
        "                    q.append([task + 1, time + n])\n",
        "\n",
        "            if q and q[0][1] == time:\n",
        "                heapq.heappush(tasks1, q[0][0])\n",
        "                q.popleft()\n",
        "            \n",
        "\n",
        "        return time\n",
        "        "
      ],
      "metadata": {
        "id": "oHcuDppouqk-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**78. Subsets**\n",
        "1. Classic algorithm, need to memorize"
      ],
      "metadata": {
        "id": "P9dF1_M1KzEd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def subsets(self, nums: List[int]) -> List[List[int]]:\n",
        "        res = []\n",
        "        subset = []\n",
        "\n",
        "        def dfs(i):\n",
        "            if i >= len(nums):\n",
        "                res.append(subset.copy())\n",
        "                return\n",
        "            # include\n",
        "            subset.append(nums[i])\n",
        "            dfs(i + 1)\n",
        "\n",
        "            # exclude\n",
        "            subset.pop()\n",
        "            dfs(i + 1)\n",
        "\n",
        "        dfs(0)\n",
        "\n",
        "        return res\n"
      ],
      "metadata": {
        "id": "h5seGrvvKzUp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**90. Subsets II**\n",
        "1. This is fucking miserable, fuck it"
      ],
      "metadata": {
        "id": "aw42y_unLDRl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n",
        "        nums.sort()\n",
        "        res = []\n",
        "        subset = []\n",
        "        visited = set()\n",
        "\n",
        "        def dfs(i):\n",
        "            print(i)\n",
        "            \n",
        "            if i == len(nums):\n",
        "                res.append(subset.copy())\n",
        "                return\n",
        "\n",
        "            if i < len(nums) and nums[i] not in visited:\n",
        "                visited.add(nums[i])\n",
        "            print(visited)\n",
        "            # include\n",
        "            subset.append(nums[i])\n",
        "            dfs(i + 1)\n",
        "            subset.pop()\n",
        "\n",
        "            # exclude\n",
        "            while i < len(nums) - 1 and nums[i] == nums[i + 1]:\n",
        "                i += 1\n",
        "            \n",
        "            dfs(i + 1)\n",
        "\n",
        "        dfs(0)\n",
        "\n",
        "        return res\n"
      ],
      "metadata": {
        "id": "gNYsIl28LDYQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-06**\n",
        "\n",
        "**133. Clone Graph**\n",
        "1. Good algo, very tricky"
      ],
      "metadata": {
        "id": "jYptsAsb0wA_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "# Definition for a Node.\n",
        "class Node:\n",
        "    def __init__(self, val = 0, neighbors = None):\n",
        "        self.val = val\n",
        "        self.neighbors = neighbors if neighbors is not None else []\n",
        "\"\"\"\n",
        "\n",
        "class Solution:\n",
        "    def cloneGraph(self, node: 'Node') -> 'Node':\n",
        "        mapping = {}\n",
        "\n",
        "        def dfs(node):\n",
        "\n",
        "            if node in mapping:\n",
        "                return mapping[node]\n",
        "\n",
        "            copy = Node(node.val)\n",
        "            mapping[node] = copy\n",
        "\n",
        "            for nei in node.neighbors:\n",
        "                temp = dfs(nei)\n",
        "                copy.neighbors.append(temp)\n",
        "\n",
        "            return copy\n",
        "\n",
        "\n",
        "        return dfs(node) if node else None"
      ],
      "metadata": {
        "id": "TD2i96ZA0wIM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-07**\n",
        "\n",
        "**102. Binary Tree Level Order Traversal**\n",
        "1. Good algo, bfs and record length of each level"
      ],
      "metadata": {
        "id": "c_R8ZHEuqM-l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definition for a binary tree node.\n",
        "# class TreeNode:\n",
        "#     def __init__(self, val=0, left=None, right=None):\n",
        "#         self.val = val\n",
        "#         self.left = left\n",
        "#         self.right = right\n",
        "class Solution:\n",
        "    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]: \n",
        "\n",
        "        def bfs(node): \n",
        "\n",
        "            if not node:\n",
        "                return\n",
        "\n",
        "            q = [node]\n",
        "            res = [[node.val]]\n",
        "            \n",
        "            while q:\n",
        "\n",
        "                level = len(q)\n",
        "                cur = []\n",
        "\n",
        "                for i in range(level):\n",
        "                    temp = q.pop(0)\n",
        "                    \n",
        "                    if temp.left:\n",
        "                        q.append(temp.left)\n",
        "                        cur.append(temp.left.val)\n",
        "                    if temp.right:\n",
        "                        q.append(temp.right)\n",
        "                        cur.append(temp.right.val)\n",
        "\n",
        "                if cur:\n",
        "                    res.append(cur)\n",
        "            \n",
        "            return res\n",
        "\n",
        "        return bfs(root)"
      ],
      "metadata": {
        "id": "1ODlAKXmqNFc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-07**\n",
        "\n",
        "**199. Binary Tree Right Side View**\n",
        "1. Good algo, very similar to the previous one"
      ],
      "metadata": {
        "id": "Yh5E8fcIuljc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definition for a binary tree node.\n",
        "# class TreeNode:\n",
        "#     def __init__(self, val=0, left=None, right=None):\n",
        "#         self.val = val\n",
        "#         self.left = left\n",
        "#         self.right = right\n",
        "class Solution:\n",
        "    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n",
        "\n",
        "        def bfs(node):\n",
        "\n",
        "            if not node:\n",
        "                return []\n",
        "            \n",
        "            q = [node]\n",
        "            res = []\n",
        "\n",
        "            while q:\n",
        "                width = len(q)\n",
        "                for i in range(width):\n",
        "                    temp = q.pop(0)\n",
        "                    if temp.left:\n",
        "                        q.append(temp.left)\n",
        "                    if temp.right:\n",
        "                        q.append(temp.right)\n",
        "                    \n",
        "                    if i == width - 1:\n",
        "                        res.append(temp.val)\n",
        "\n",
        "            return res\n",
        "\n",
        "        return bfs(root)"
      ],
      "metadata": {
        "id": "8RMpzDLpulsA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**200. Number of Islands**\n",
        "1. Good algo, uses bfs\n",
        "2. bfs uses queue structure, same for trees"
      ],
      "metadata": {
        "id": "homZbf6wwlBN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def numIslands(self, grid: List[List[str]]) -> int:\n",
        "        # mark all points in an island\n",
        "        def bfs(r,c):\n",
        "            q = deque()\n",
        "            q.append((r,c))\n",
        "            visited.add((r,c))\n",
        "\n",
        "            while q:\n",
        "                row, col = q.popleft()\n",
        "                dirs = [[1,0],[-1,0],[0,1],[0,-1]]\n",
        "\n",
        "                for hor, ver in dirs:\n",
        "                    r1 = row + hor\n",
        "                    c1 = col + ver\n",
        "                    if r1 in range(len(grid)) and c1 in range(len(grid[0])):\n",
        "                        if grid[r1][c1] == \"1\" and (r1,c1) not in visited:\n",
        "                            q.append((r1,c1))\n",
        "                            visited.add((r1,c1))\n",
        "\n",
        "\n",
        "        # initialize \n",
        "        res = 0\n",
        "        visited = set()\n",
        "\n",
        "        # search all points\n",
        "        for i in range(len(grid)):\n",
        "            for j in range(len(grid[0])):\n",
        "                # \n",
        "                if grid[i][j] == \"1\" and (i,j) not in visited:\n",
        "                    bfs(i,j)\n",
        "                    res += 1\n",
        "\n",
        "        return res"
      ],
      "metadata": {
        "id": "mOXJO6Q4wlJN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**695. Max Area of Island**\n",
        "1. Very similar to the 695"
      ],
      "metadata": {
        "id": "CDipyK0BwJI3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:\n",
        "\n",
        "        # mark all points in an island\n",
        "        def bfs(r,c):\n",
        "            number = 1\n",
        "            q = deque()\n",
        "            q.append((r,c))\n",
        "            visited.add((r,c))\n",
        "\n",
        "            while q:\n",
        "                row, col = q.popleft()\n",
        "                dirs = [[1,0],[-1,0],[0,1],[0,-1]]\n",
        "\n",
        "                for hor, ver in dirs:\n",
        "                    r1 = row + hor\n",
        "                    c1 = col + ver\n",
        "                    if r1 in range(len(grid)) and c1 in range(len(grid[0])):\n",
        "                        if grid[r1][c1] == 1 and (r1,c1) not in visited:\n",
        "                            q.append((r1,c1))\n",
        "                            visited.add((r1,c1))\n",
        "                            number += 1\n",
        "            \n",
        "            return number\n",
        "\n",
        "\n",
        "        # initialize \n",
        "        res = 0\n",
        "        visited = set()\n",
        "\n",
        "        # search all points\n",
        "        for i in range(len(grid)):\n",
        "            for j in range(len(grid[0])):\n",
        "                # \n",
        "                if grid[i][j] == 1 and (i,j) not in visited:\n",
        "                    cur = bfs(i,j)\n",
        "                    res = max(res, cur)\n",
        "\n",
        "        return res"
      ],
      "metadata": {
        "id": "S_K0X3hywJP2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**326. Power of Three**\n",
        "1. I need to wash my brain"
      ],
      "metadata": {
        "id": "0yT9BpqWZNlC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def isPowerOfThree(self, n: int) -> bool:\n",
        "        res = False\n",
        "\n",
        "        while n > 0:\n",
        "\n",
        "            if n == 1:\n",
        "                return True\n",
        "            elif n < 3:\n",
        "              return False\n",
        "            else:\n",
        "              n = n / 3\n"
      ],
      "metadata": {
        "id": "PF3V65mCYOU6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**231. Power of Two**\n",
        "1. good use of the trunc() function"
      ],
      "metadata": {
        "id": "VWFdh15VdzpX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def isPowerOfTwo(self, n):\n",
        "        return n > 0 and log2(n) == trunc(log2(n))"
      ],
      "metadata": {
        "id": "bKRBMZaDYPg4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**203. Remove Linked List Elements**\n",
        "1. good use of the trunc() function"
      ],
      "metadata": {
        "id": "jCm3kCOdsP7A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definition for singly-linked list.\n",
        "# class ListNode:\n",
        "#     def __init__(self, val=0, next=None):\n",
        "#         self.val = val\n",
        "#         self.next = next\n",
        "class Solution:\n",
        "    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:\n",
        "        \n",
        "        if not head:\n",
        "            return None\n",
        "\n",
        "        nextNode = self.removeElements(head.next, val)\n",
        "\n",
        "        if head.val == val:\n",
        "            head = nextNode\n",
        "        else:\n",
        "            head.next = nextNode\n",
        "\n",
        "        return head"
      ],
      "metadata": {
        "id": "NygSIIeFsQBv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**799. Champagne Tower**\n",
        "1. Don't know why this is good, and should remember"
      ],
      "metadata": {
        "id": "M21OIsNdLE_Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def champagneTower(self, poured: int, query_row: int, query_glass: int) -> float:\n",
        "\n",
        "        glasses = [[0] * (i+1) for i in range(query_row + 1)]\n",
        "        glasses[0][0] = poured\n",
        "\n",
        "        # fill glasses\n",
        "        for i in range(len(glasses) - 1):\n",
        "            for j in range(len(glasses[i])):\n",
        "                extra = glasses[i][j] - 1\n",
        "                glasses[i][j] = min(1, glasses[i][j])\n",
        "                if extra > 0:\n",
        "                    glasses[i + 1][j] += (extra / 2)\n",
        "                    glasses[i + 1][j + 1] += (extra / 2)\n",
        "        \n",
        "        return min(1, glasses[query_row][query_glass])"
      ],
      "metadata": {
        "id": "MQgvQmjJLFFc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-08**\n",
        "**234. Palindrome Linked List**\n",
        "1. Contains 2 algos: get to mid point and reverse linkedlist\n",
        "2. uses only O(1) space"
      ],
      "metadata": {
        "id": "c9nq3AtIoXne"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Definition for singly-linked list.\n",
        "# class ListNode:\n",
        "#     def __init__(self, val=0, next=None):\n",
        "#         self.val = val\n",
        "#         self.next = next\n",
        "class Solution:\n",
        "    def isPalindrome(self, head: Optional[ListNode]) -> bool:\n",
        "\n",
        "        if not head:\n",
        "            return None\n",
        "\n",
        "        # get to mid point\n",
        "        def reachMid(node):\n",
        "            slow, fast = node, node\n",
        "            while fast.next and fast.next.next:\n",
        "                fast = fast.next.next\n",
        "                slow = slow.next\n",
        "            \n",
        "            return slow\n",
        "\n",
        "        # reverse list\n",
        "        def reverse(head):\n",
        "\n",
        "            prev, curr = None, head\n",
        "\n",
        "            while curr:\n",
        "                temp = curr.next\n",
        "                curr.next = prev\n",
        "                prev = curr\n",
        "                curr = temp\n",
        "            return prev\n",
        "            \n",
        "        \n",
        "        # get to mid point, reverse latter part, use two pointers\n",
        "        first = head\n",
        "        node = head\n",
        "        second = reachMid(node)\n",
        "        second = reverse(second)\n",
        "\n",
        "\n",
        "        while first and second:\n",
        "            if first == second:\n",
        "                return True\n",
        "            \n",
        "            if first.next == second or second.next == first:\n",
        "                return first.val == second.val\n",
        "\n",
        "            if first.val != second.val:\n",
        "                return False\n",
        "\n",
        "            first = first.next\n",
        "            second = second.next"
      ],
      "metadata": {
        "id": "xYlTTurMoXup"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-08**\n",
        "**355. Design Twitter**\n",
        "1. very useless but need to pay attention"
      ],
      "metadata": {
        "id": "8RwrffuGGrzr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Twitter:\n",
        "\n",
        "    def __init__(self):\n",
        "        self.following = {}\n",
        "        self.tweets = []\n",
        "\n",
        "    def postTweet(self, userId: int, tweetId: int) -> None:\n",
        "        self.tweets.append([userId, tweetId])\n",
        "        if userId not in self.following:\n",
        "            self.following[userId] = [userId]\n",
        "\n",
        "    def getNewsFeed(self, userId: int) -> List[int]:\n",
        "        newsFeed = []\n",
        "        if userId in self.following:\n",
        "            f = self.following[userId]\n",
        "        else:\n",
        "            return []\n",
        "        for i in range(len(self.tweets) - 1, -1, -1):\n",
        "            user, tweet = self.tweets[i]\n",
        "            if user in f:\n",
        "                newsFeed.append(tweet)\n",
        "            if len(newsFeed) == 10:\n",
        "                return newsFeed\n",
        "        \n",
        "        return newsFeed\n",
        "\n",
        "    def follow(self, followerId: int, followeeId: int) -> None:\n",
        "        if followerId in self.following:\n",
        "            self.following[followerId].append(followeeId)\n",
        "        else:\n",
        "            self.following[followerId] = [followerId, followeeId]\n",
        "\n",
        "    def unfollow(self, followerId: int, followeeId: int) -> None:\n",
        "        if followerId in self.following:\n",
        "            if followeeId in self.following[followerId]:\n",
        "                self.following[followerId].remove(followeeId)\n",
        "\n",
        "\n",
        "# Your Twitter object will be instantiated and called as such:\n",
        "# obj = Twitter()\n",
        "# obj.postTweet(userId,tweetId)\n",
        "# param_2 = obj.getNewsFeed(userId)\n",
        "# obj.follow(followerId,followeeId)\n",
        "# obj.unfollow(followerId,followeeId)"
      ],
      "metadata": {
        "id": "TAA6eHXVGr5q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-11**\n",
        "**994. Rotting Oranges**\n",
        "1. still bfs, but simultanuously for multiple points."
      ],
      "metadata": {
        "id": "HDiOEP7B27WX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def orangesRotting(self, grid: List[List[int]]) -> int:\n",
        "\n",
        "        row, col = len(grid), len(grid[0])\n",
        "        rotten = []\n",
        "        q = deque()\n",
        "\n",
        "        # get all fresh tomatoes\n",
        "        fresh = []\n",
        "        for i in range(row):\n",
        "            for j in range(col):\n",
        "                if grid[i][j] == 1:\n",
        "                    fresh.append([i,j])\n",
        "                if grid[i][j] == 2:\n",
        "                    rotten.append([i,j])\n",
        "                    q.append([i,j])\n",
        "\n",
        "        time = 0\n",
        "\n",
        "        # four directions\n",
        "        dirs = [[0,1],[0,-1],[1,0],[-1,0]]\n",
        "\n",
        "        while q and fresh:\n",
        "\n",
        "            for i in range(len(q)):\n",
        "                r, c = q.popleft()\n",
        "\n",
        "                for h, v in dirs:\n",
        "                    r1, c1 = r + h, c + v\n",
        "                    if ((r1 in range(0, row) and c1 in range(0, col))\n",
        "                        and grid[r1][c1] == 1 \n",
        "                        and [r1, c1] not in rotten):\n",
        "\n",
        "                        rotten.append([r1, c1])\n",
        "                        q.append([r1, c1])\n",
        "                        fresh.remove([r1, c1])\n",
        "            \n",
        "            time += 1\n",
        "\n",
        "        return time if fresh == [] else -1\n"
      ],
      "metadata": {
        "id": "SO-kXox627e1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-12**\n",
        "**207. Course Schedule**\n",
        "1. dfs, need to understand the question\n",
        "2. very important to remove in dfs"
      ],
      "metadata": {
        "id": "s0aUI64fSdCm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:\n",
        "\n",
        "        # create hash map for dfs\n",
        "        preMap = {i:[] for i in range(numCourses)}\n",
        "        for a, b in prerequisites:\n",
        "            preMap[a].append(b)\n",
        "        \n",
        "        #\n",
        "        visited = set()\n",
        "\n",
        "        # \n",
        "        def dfs(course):\n",
        "            if course in visited:\n",
        "                return False\n",
        "            if preMap[course] == []:\n",
        "                return True\n",
        "            \n",
        "            visited.add(course)\n",
        "\n",
        "            for pre in preMap[course]:\n",
        "                if dfs(pre) == False:\n",
        "                    return False\n",
        "                preMap[course].remove(pre)\n",
        "            # why this? because 3 could be the parent of 1,if we do not remove 1, then 3 will return false\n",
        "            visited.remove(course)\n",
        "            return True\n",
        "\n",
        "        for c in range(numCourses):\n",
        "            if not dfs(c):\n",
        "                return False\n",
        "            \n",
        "        return True\n",
        "            "
      ],
      "metadata": {
        "id": "EuIu1T55SdKd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**210. Course Schedule II**\n",
        "1. similar to previous, add section to remove redundancy"
      ],
      "metadata": {
        "id": "VVlW-rP5hRL-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:\n",
        "        # get hash map\n",
        "        preMap = {i : [] for i in range(numCourses)}\n",
        "        for i, j in prerequisites:\n",
        "            preMap[i].append(j)\n",
        "\n",
        "        #\n",
        "        visited = set()\n",
        "        cycle = set()\n",
        "        self.res = []\n",
        "        # dfs\n",
        "        def dfs(course):\n",
        "            # base\n",
        "            if preMap[course] == []:\n",
        "                if course not in self.res:\n",
        "                    self.res.append(course)\n",
        "                return True\n",
        "            \n",
        "            #\n",
        "            if course in cycle:\n",
        "                return False\n",
        "            \n",
        "            # \n",
        "            if course in visited:\n",
        "                return True\n",
        "\n",
        "            cycle.add(course)\n",
        "            for pre in preMap[course]:\n",
        "                if dfs(pre) == False:\n",
        "                    return False\n",
        "            \n",
        "            cycle.remove(course)\n",
        "            visited.add(course)\n",
        "\n",
        "            if course not in self.res:\n",
        "                self.res.append(course)\n",
        "\n",
        "            return True\n",
        "\n",
        "        for c in range(numCourses):\n",
        "            if not dfs(c):\n",
        "                return []\n",
        "        \n",
        "        return self.res"
      ],
      "metadata": {
        "id": "VZZpy--6hRTd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**1749. Maximum Absolute Sum of Any Subarray**\n",
        "1. very tricky formula\n",
        "2. user of accumulate, returns the accumulate sum, initial means the first value is 0, this is to find the case where the first one element is the answer\n",
        "https://www.notion.so/Leetcode-1749-56f6c5e455104d4f85975d1fce12e539"
      ],
      "metadata": {
        "id": "1JUHHEaqMF4N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def maxAbsoluteSum(self, nums: List[int]) -> int:\n",
        "        \n",
        "        return max(accumulate(nums, initial = 0)) - min(accumulate(nums, initial = 0))\n",
        "        "
      ],
      "metadata": {
        "id": "GgmtTQMeTAJf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [-2,1,-3,4,-1,2,1,-5,4]"
      ],
      "metadata": {
        "id": "D0TLE5HXMF-A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import itertools"
      ],
      "metadata": {
        "id": "cDxM9LiGOhy1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = itertools.accumulate(a)"
      ],
      "metadata": {
        "id": "YgWYcpfFMGB3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "list(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8RHnq9PSOsJz",
        "outputId": "3762da31-2669-4863-d76b-c7f1e4f043f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[-2, -1, -4, 0, -1, 1, 2, -3, 1]"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-ms7hGleOsMT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-21**\n",
        "**55. Jump Game**\n",
        "1. O(N) solution, very tricky"
      ],
      "metadata": {
        "id": "jJt60MIEGoh5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def canJump(self, nums: List[int]) -> bool:\n",
        "        if len(nums) == 1:\n",
        "            return True\n",
        "\n",
        "        # doing backwards\n",
        "        currGoal = len(nums) - 1\n",
        "        for i in range(len(nums) - 2, -1, -1):\n",
        "            # print('i', i)\n",
        "            if currGoal - i <= nums[i]:\n",
        "                if i == 0:\n",
        "                    return True\n",
        "                currGoal = i\n",
        "            # print(currGoal)\n",
        "\n",
        "        return False"
      ],
      "metadata": {
        "id": "8eEinbZLGopY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**55. Jump Game**\n",
        "1. O(N) solution, very tricky\n",
        "\n",
        "Although your explanation is not perfect, the solution is great!\n",
        "\n",
        "Let me reason the solution.\n",
        "\n",
        "There are 2 possibilities - either the number of -ve numbers is even or odd.\n",
        "\n",
        "If they are even, then obviously we would want to include all of them(in fact the whole array(unless for zeros)) to maximise the product. This is because multiplying an even number of -ve numbers would make the result +ve.\n",
        "\n",
        "If they are odd, then we would want to exclude at most(to maximise the product) one -ve number from our product. So, now the question is, which -ve number to exclude? There are 2 possibilities - first -ve num or last -ve num.\n",
        "a. Note that, you cannot exclude a -ve number that is not the first or the last, because, if you do so, you will need to exclude all(because you are breaking the product at this point) other -ve nums following that -ve number and then that needn't result in the maximum product.\n",
        "b. Remember, that our goal is to leave out only 1 -ve number so that we can maximise our product.\n",
        "c. Note: We are leaving out one -ve number, so that we are able to make the number of -ve nums even. Having said all that, now the question is whether to exclude the first -ve num or the last -ve num in the array. We can only know the answer by trying both.\n",
        "d. By taking the product from the beginning of the array, you forcefully include the first -ve number and exclude the last -ve number\n",
        "e. vice-versa for taking the product from the end\n",
        "\n",
        "To further explain 2d,e, let me take an example:\n",
        "\n",
        "Assume the array has an odd number of -ve nums. The first -ve num is -2 and the last -ve num is -3. So the array is .....-2.......-3.......\n",
        "The maximum product can either be made of all numbers from the beginning of the array to the first non-zero number just before -3, or from the end of the array to the first non-zero number just after -2.\n",
        "\n",
        "This is why we are considering two possible products, one from the beginning and one from the end.\n",
        "\n",
        "But wait, you might be thinking, why we are still continuing to multiply even beyond -3(forward iteration) or beyond -2 (backward iteration). That's all actually waste, as the product is only going to increase in negativity beyond those points. The maximum is already updated, so this doesn't affect at all.\n",
        "\n",
        "Hope you find this useful!\n",
        "\n",
        "This is the reasoning I came up with. If there is anything wrong, please feel free to correct!"
      ],
      "metadata": {
        "id": "bfrCJJ0bQK_9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def maxProduct(self, nums: List[int]) -> int:\n",
        "        res = -11\n",
        "        prod = 1\n",
        "\n",
        "        for n in nums:\n",
        "            prod = prod * n\n",
        "            res = max(prod, res)\n",
        "            if n == 0:\n",
        "                prod = 1\n",
        "\n",
        "        \n",
        "        prod = 1\n",
        "\n",
        "        for i in range(len(nums)-1, -1, -1):\n",
        "            prod = prod*nums[i]\n",
        "            res = max(prod, res)\n",
        "            if nums[i] == 0:\n",
        "                prod = 1\n",
        "\n",
        "\n",
        "        return res"
      ],
      "metadata": {
        "id": "0OP-zcB1QLJk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**45. Jump Game II**\n",
        "1. O(N) solution, very tricky"
      ],
      "metadata": {
        "id": "8Hu8vmiqKj41"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def jump(self, nums: List[int]) -> int:\n",
        "        step = 0\n",
        "        farthest = 0\n",
        "        l,r = 0, 0\n",
        "        #bfs\n",
        "        while r < len(nums) - 1:\n",
        "            \n",
        "            for i in range(l, r + 1):\n",
        "                farthest = max(farthest, i + nums[i])\n",
        "\n",
        "            l, r = r + 1, farthest\n",
        "            step += 1\n",
        "\n",
        "        return step"
      ],
      "metadata": {
        "id": "lTxzGZpeKj_8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**134. Gas Station**\n",
        "1. First, this is very tricky, in that it involves some tricks about reading the question\n",
        "2. Second, it is hard to come up with the for loop without some tricks"
      ],
      "metadata": {
        "id": "o0kPk9Ni0AAo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:\n",
        "        #\n",
        "        diff = [g - c for g,c in zip(gas, cost)]\n",
        "        length = len(gas)\n",
        "        if sum(diff) < 0:\n",
        "            return -1\n",
        "        total = 0\n",
        "        res = 0\n",
        "        for i in range(length):\n",
        "            total += diff[i]\n",
        "\n",
        "            if total < 0:\n",
        "                total = 0\n",
        "                res = i + 1\n",
        "\n",
        "        return res\n"
      ],
      "metadata": {
        "id": "fpaj6uYX0AHI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**57. Insert Interval**\n",
        "1. Came up with the important part (overlapping), but couldn't solve the other parts"
      ],
      "metadata": {
        "id": "_bUKy8MDzW43"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:\n",
        "        l, r = newInterval\n",
        "\n",
        "        res = []\n",
        "\n",
        "        if not intervals:\n",
        "            return [newInterval]\n",
        "\n",
        "        for i in range(len(intervals)):\n",
        "            a,b = intervals[i]\n",
        "            # print('cur:', intervals[i])\n",
        "            # no overlapping\n",
        "            if b < l:\n",
        "                # print('smaller')\n",
        "                res.append([a,b])\n",
        "            \n",
        "            elif a > r:\n",
        "                # print('bigger')\n",
        "                res.append(newInterval)\n",
        "                return res + intervals[i: len(intervals)]\n",
        "\n",
        "            else:\n",
        "                # print('overlapping')\n",
        "                l = min(l, a)\n",
        "                r = max(r, b)\n",
        "                newInterval = [l, r]\n",
        "\n",
        "        return res + [newInterval]"
      ],
      "metadata": {
        "id": "98jPkrlDjoSO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-23**\n",
        "**495. Teemo Attacking**\n",
        "1. People say this is easy, geez, I used 1 hour to solve it"
      ],
      "metadata": {
        "id": "H9Gn3gfUJ0WM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:\n",
        "        total = 0\n",
        "\n",
        "        for i in range(1, len(timeSeries)):\n",
        "            total += min(duration, timeSeries[i] - timeSeries[i - 1])\n",
        "\n",
        "        return total + duration"
      ],
      "metadata": {
        "id": "ckGpHnyrJ0kj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**56. Merge Intervals**\n",
        "1. Solved it indeed, but took too much time.\n",
        "2. When dealing with intervals, remember to use min() and append last one"
      ],
      "metadata": {
        "id": "FaFkf80WJ8MS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def merge(self, intervals: List[List[int]]) -> List[List[int]]:\n",
        "        #\n",
        "        intervals.sort()\n",
        "        res = []\n",
        "        l,r = intervals[0]\n",
        "        for a,b in intervals:\n",
        "            if r < a or l > b:\n",
        "                res.append([l,r])\n",
        "                l, r = a, b                \n",
        "            else:\n",
        "                l = min(l, a)\n",
        "                r = max(r, b)\n",
        "            \n",
        "        res.append([l,r])\n",
        "\n",
        "        return res"
      ],
      "metadata": {
        "id": "fqlXyBYdJ8Z2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**435. Non-overlapping Intervals**\n",
        "1. Very tricky"
      ],
      "metadata": {
        "id": "1dd4Z8sIJe07"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:\n",
        "        intervals.sort()\n",
        "        res = 0\n",
        "\n",
        "        l,r = intervals[0]\n",
        "        for a,b in intervals[1:]:\n",
        "            if r <= a:\n",
        "                r = b\n",
        "            else:\n",
        "                res += 1\n",
        "                r = min(r, b)\n",
        "\n",
        "        return res\n",
        "        "
      ],
      "metadata": {
        "id": "o_ynYwWbJfBF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**605. Can Place Flowers**\n",
        "1. Boring, but fuck it man"
      ],
      "metadata": {
        "id": "alnUUlRoUeVW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:\n",
        "        if n <= 0:\n",
        "            return True\n",
        "        flowerbed = [0] + flowerbed + [0]\n",
        "        for i in range(1, len(flowerbed) - 1):\n",
        "            if flowerbed[i] == 0 and flowerbed[i - 1] == 0 and flowerbed[i + 1] == 0:\n",
        "                n -= 1\n",
        "                if n <= 0:\n",
        "                    return True\n",
        "                flowerbed[i] = 1\n",
        "        # print(res)\n",
        "        return False"
      ],
      "metadata": {
        "id": "1G2U6Jb-Ueh0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-24**\n",
        "**9. Palindrome Number**\n",
        "1. Can convert to string\n",
        "2. many edge cases"
      ],
      "metadata": {
        "id": "g_0Y0umFdeCt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def isPalindrome(self, x: int) -> bool:\n",
        "        # edge case\n",
        "        if x < 0:\n",
        "            return False\n",
        "        # edge case\n",
        "        if x % 10 == 0:\n",
        "            return x == 0\n",
        "\n",
        "        reverse = 0\n",
        "\n",
        "        while x > reverse:\n",
        "            curr = x % 10\n",
        "            reverse = reverse * 10 + curr\n",
        "            print(x, reverse)\n",
        "            if x == reverse:\n",
        "                return True\n",
        "            x = x // 10\n",
        "\n",
        "        return x == reverse"
      ],
      "metadata": {
        "id": "sMDiCnlqdeHw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**13. Roman to Integer**\n",
        "1. Dont know if theres faster solutions"
      ],
      "metadata": {
        "id": "7UOMjqR8dotT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def romanToInt(self, s: str) -> int:\n",
        "\n",
        "        hashMap = {'I': 1, 'V': 5, 'X': 10, 'L':50, 'C': 100, 'D': 500, 'M':1000,\n",
        "                    'IV': 4, 'IX': 9, 'XL': 40, 'XC': 90, 'CD': 400, 'CM': 900}\n",
        "\n",
        "        i = 0\n",
        "        res = 0\n",
        "\n",
        "        while i < len(s):\n",
        "            # check double digits\n",
        "            if i < len(s) - 1 and s[i:i+2] in hashMap:\n",
        "                res += hashMap[s[i:i+2]]\n",
        "                i += 2\n",
        "            else:\n",
        "                res += hashMap[s[i]]\n",
        "                i += 1\n",
        "\n",
        "        return res"
      ],
      "metadata": {
        "id": "vywf1y9kdoy2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**997. Find the Town Judge**\n",
        "1. Very clever solution"
      ],
      "metadata": {
        "id": "fnjAF8agkZBb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def findJudge(self, n: int, trust: List[List[int]]) -> int:\n",
        "        \n",
        "        if n == 1:\n",
        "            return 1\n",
        "        \n",
        "        diff = [0] * (n + 1)\n",
        "\n",
        "        for i,j in trust:\n",
        "            diff[i] -= 1\n",
        "            diff[j] += 1\n",
        "\n",
        "        for i in range(len(diff)):\n",
        "\n",
        "            if diff[i] == (n-1):\n",
        "                return i\n",
        "\n",
        "        return -1"
      ],
      "metadata": {
        "id": "SPCk9_18kZHw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-25**\n",
        "**14. Longest Common Prefix**\n",
        "1. 很多种解法，各种答案都可以看一看\n",
        "https://leetcode.com/problems/longest-common-prefix/description/"
      ],
      "metadata": {
        "id": "IYRTOBd3MkNQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def longestCommonPrefix(self, strs: List[str]) -> str:\n",
        "        res = strs[0]\n",
        "\n",
        "        for s in strs[1:]:\n",
        "            for i in range(len(res)):\n",
        "\n",
        "                if i >= len(s) or s[i] != res[i]:\n",
        "                    res = res[0:i]\n",
        "                    break\n",
        "\n",
        "        return res\n"
      ],
      "metadata": {
        "id": "O_ekpOraMkTs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-26**\n",
        "**208. Implement Trie (Prefix Tree)**\n",
        "1. very classic algorithm\n",
        "2. much faster than using a list"
      ],
      "metadata": {
        "id": "yogyx5wQoNX4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class TrieNode:\n",
        "    def __init__(self):\n",
        "        # use dictionary as a tree\n",
        "        self.children = {}\n",
        "        self.endOfWord = False\n",
        "\n",
        "class Trie:\n",
        "\n",
        "    def __init__(self):\n",
        "        self.root = TrieNode()\n",
        "\n",
        "    def insert(self, word: str) -> None:\n",
        "        # just like a tree\n",
        "        cur = self.root\n",
        "\n",
        "        for c in word:\n",
        "            if c not in cur.children:\n",
        "                cur.children[c] = TrieNode()\n",
        "            cur = cur.children[c]\n",
        "\n",
        "        cur.endOfWord = True\n",
        "\n",
        "    def search(self, word: str) -> bool:\n",
        "        # \n",
        "        cur = self.root\n",
        "\n",
        "        for c in word:\n",
        "            if c not in cur.children:\n",
        "                return False\n",
        "            cur = cur.children[c]\n",
        "        \n",
        "        return cur.endOfWord\n",
        "\n",
        "    def startsWith(self, prefix: str) -> bool:\n",
        "        #\n",
        "        cur = self.root\n",
        "\n",
        "        for c in prefix:\n",
        "            if c not in cur.children:\n",
        "                return False\n",
        "            cur = cur.children[c]\n",
        "        \n",
        "        return True\n",
        "            "
      ],
      "metadata": {
        "id": "eC5OAqMaoNi3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-28**\n",
        "**211. Design Add and Search Words Data Structure**\n",
        "1. use a partial bfs, although the implementation is not very clear\n",
        "2. dfs is going to the last and going backwards, need to revisit"
      ],
      "metadata": {
        "id": "EOT280OVeuN9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class TrieNode:\n",
        "    def __init__(self):\n",
        "        self.children = {}\n",
        "        self.endOfWord = False\n",
        "\n",
        "class WordDictionary:\n",
        "\n",
        "    def __init__(self):\n",
        "        self.root = TrieNode()\n",
        "\n",
        "    def addWord(self, word: str) -> None:\n",
        "        curr = self.root\n",
        "        for c in word:\n",
        "            if c not in curr.children:\n",
        "                curr.children[c] = TrieNode()         \n",
        "            curr = curr.children[c]            \n",
        "        \n",
        "        curr.endOfWord = True\n",
        "     \n",
        "    def search(self, word: str) -> bool:\n",
        "        # like a partial dfs\n",
        "        def dfs(i, node):\n",
        "            curr = node\n",
        "\n",
        "            for j in range(i, len(word)):\n",
        "                c = word[j]\n",
        "                if c == \".\":\n",
        "                    # each item is a node\n",
        "                    for child in curr.children.values():\n",
        "                        # dfs until next letter\n",
        "                        if dfs(j + 1, child):\n",
        "                            return True\n",
        "                    return False\n",
        "                else:\n",
        "                    if c not in curr.children:\n",
        "                        return False\n",
        "                    curr = curr.children[c]\n",
        "            \n",
        "            return curr.endOfWord\n",
        "\n",
        "        return dfs(0, self.root)"
      ],
      "metadata": {
        "id": "t70VCnRWeuUV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**From Codesignal**\n",
        "1. isdigit()\n",
        "2. lexicographical"
      ],
      "metadata": {
        "id": "aRyZU_C1lG-l"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAdEAAANuCAYAAABJwDMSAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAOySSURBVHhe7P0PdBzHdeeLX0mR/LSKE1mCIDqgTGt08uCsCHJ/pikiJgmTMpWnedxQG1A5DEFFwUoT82D2xKSXkGLQCg4WlglHhHcp5whcPsEKwhXB5YmAWIyg0a64Ig1CDihafgLA/TnYPRqJJhETICQ7cWT9JFmaX92q6u7qnp6Z7p7B4N/3c06TXV3V1VW3quvWvVWDviIjIAAAAACE5kr9PwAAAABCAiUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiET+nejIzyZpVBz8Px/MyutvlscffnqFDAMAAAALmUhK9L+8OUqHxZGP+4UinXVl+uEH9PN/fl+dX3sdffwadVoW3n+Hfv6uPr9GPPtafe7De//4DulS0jW/eh197CodAAAAMKcJrUSbX3vRtjyD8OKG+/RZDj6copEXnqG/7B2kE+c/kJc+vqyGtiYT1Lx2qQxHZrSblidT8rRq5z76b39YLc/LwfTAXtrQMa4Cm3bT37Wtp2t+MkavXVR1/D+W1tDKT14tzsaoc10b9cir19GX//Iwfek3ZQAAAMAcJ9SaqOm6ZdjaNJVk57+6S14zYas1J++O0bcTX6YdHf/DVqDMz8+PUc+f7qJVbafp5/ravONffIJ+6zOV6rielaWo1w+P0oNf+YY8Hj6RlteE7UkVVjpxfBxWKAAAzBsCW6KsPNkKtWCFyeufXsuUlao3rb81+g4NfutBSv6NVp6/fitt3/FZqvrJD+nQ37whlOfVtKbh31H7zvVUxYpFWqwn6MUf/pDOvP0JWrO6ljZv/iL91q+r2yVTY9R//DgNDP+UKlZ+kRpWvkE79v4PGWVaoj//3/+D+l4YptMjnO6zVHf3PbT5N68TMVN05thxOiM196101/0i/6nT9O0XlEV527o/os2feYdGnnmGvvczceFXbqWNNe/Qyf93Ssb/mnhm3T/+HR196We0vrGGXhvUluinv0g7P3OROv/iSTr68jvq2u2fpS+tvplu+8K9tPScyO8tvvgvaM2WBvqXl47TX76i81y+nv4/bw1T74lhmr6hlv4o8UdU90kZJYr7Qzp6LEUnZD1Efe+8hr73d2/IqF9buYUaV1fKcwAAADNDYCXqXQe1FONdp56W/1v4XfddH51KUbK+mwb5/Npb6ct/8R/oS59hRUb03t+n6OhbNdRouXN/cppamw9Q/3kVdLia6vf9Z2qvu16kEfndL/Kz1iE9WEp0YmAvbekYp/f0dcXV9Ft/0kF/ve1WGun6A9rRqxR7Y1cf1f+vJtpyQCk0+r2H6NWdH1Dr3QdogMO1CerfeJrqLbetzWfpwLdupt17lCtZunPrx+m3tWvZZPPXv0VrBvZQ6zCHlDu3/n8ZruAsRN4vfI3Wp7vp90V+lj3rpdzuawAAWIwEduea1mZY/DYh/fx//lApUEZYUfVagTIf+0zcUaDCOuz/lqVAhbLb9EX60u/dSh+XcR9Q/97HaODtd+hEz1/ZCvTjq9fTl7Z9ln7Lu5nn4nF6WCvQj62I03e6d9P2ZRzxAf1IWIkDbxN9Rli4H+NLghdHUnTmRa1Amb8R1uvZV5UCFaxcW0M36POC3FBN29c6daxaK+rRGKd/daO+kItrK2nz79VQTAeJfkgvnn2TBg5bCvRqWrktQV1//kdUL+sCAACgXERSouzKZfzWO61rVppcvPeedmsy115jK64s3n6VTkgrTXD779Of/1mSvrynk55KWAppnAZH/r/02oB2C19bTY+07KYv/8nX6EDSvTFpemSYRvR57LduFZr8OvpXtZbLc5zOnHuHPraylur1lYnDf0Wd/1MHJKfpT/dZhVlK/3q1d+PT9VTfso9OvfAwbfIq8KXraWedkX75F+nLiQRtX/Ev9AV/qu76I3pkTxt9bZu+ILlMaasYn9xED++MU93aLfS1P1mvLwIAACgHs/bHFipuq6YqfU4nT9PgP+pz5u03aOSiVrK/VP9JKq+nm/TGm5tuchTSz3/x/9NngndjtFTrxYpPCkWZgx8d65IbfP70mGNpvveh+OeaGlqzSYXp3Q+02/dq+phWiu+Ja5Lb62iNtTZpUXsvfXlzNVX8qtpIVBI++Qlpdf8fng1H11hK+idpep3XZwUTF9V6KAAAgPIQSYlam4b8fgdqXTM3FvEGpCx+84vUeLs+pzH60+R+OvryD+nMib+iB/+wmXb8wYP0+90/pJ9//BNUZSmMk7106OzP6Oc/OU2Heq01w+vpM5++hao+o4OUokN/c5He++c36Ogzp/U1xcdvdDbafGzb1+jcUB+d+97j1LXnIfpv3+ujP9/I1u11tOYLn1WJLGp/n5rv1uea2LrlFPMotqqVMarQ54WYeGuKfn7xIk1YPxANxW/Sms2Woh6n1h330+//W3EcuKivAQAAKAeBlaj3pyth8FWitJS2tyWozlKQ54fpG3/6DXqw7TidkVbpB5T+4RhdpFpq3F2t3b0/o56vPEi//fsH6KjeZBTb3EhbP/NpuuteKw3R4Ld20aq7m6nTcnlqPrY6Tl/W64bvHfsGrfq9B2nD3bso+a399H8lumnkn1Xcx2//LNWpU8nKtWuofq3pKr2eNn3WWaUMiqnE6ZkD9Nt/sJcGsjZLBeFqWrPzP1Dzaq1I332HfvS/36fYb16vwgAAAMpCYCXqtTqttU9TQVrn3k1IOf9y0Sfj1HXsa/Tltde510SvvY7qGpL019/6I7k5qGrzPjretp5Wmj9nkWl208GH1U9gKu7+Gj2dtDYcCXhDjrkGyVxVTV861EZf21Qpn/fe5Z/R9LtKaTb/yb208ldVMqpcRZtq9ble+/zY8lW0WV+hT/42feE3w7tsP7a6QVi7xn2iDtd4rNnAXHMz1e3+z/R3A4/TX/+nffTfXvgv9MgXnN/aVvyqs4kJAADAzBDqLxZ5f//J1ukK/VtRhjcT8d/TNXfjWr8nLYjxJ/ry/ek760/k5Uyj8yn45/Os5111DX28lGuYQRCW48/Fo4v5E3/vDR+gzzefJrqpktavq6GPvT5MJ0bfUWu4195KX+vu1DuPAQAAzBShlCjDCjPoz11YeRbapQui8AGlBx6jP+seo5HLjvXJfOymatr5Zw/Tlz4L1y4AAMw0oZUo4/3DC374/oEFUHLe+2dhmfOuYomwqn+9zFY1AAAsYiIpUQtWpmyV8mG5bPl/dvEGcuECAAAA85iilCgAAACwmJm1P7YAAAAAzHegRAEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiMgVGYE+B4uI6Z99SO++n6GPPgrf/FdeeQVde80VVHH9VfrK7LKQ6gIAmF9AiS5CWOmwvrnu2iulEgkLK6t33v2I+NbZVj4LqS4AgPkH3LmLELbaoiodhu/j+zmf2WYh1QUAMP+IpERHurbS8nXmsZf6p3SkZIw6xfXOUR0sK/xsb3nKz/TAXlreNaZD/kg5FkgzE7D1FVXpWPD9UdynkZhKUTJHm5a7LrJdm1M0rcOhGe1235+nbnOLEO/0XKsjl0ePVcmB7ELM1ns4l5H9XMss6yiVrFz9Inj/KvodLDEhlaiq6A5qo3NDfc7RFaPWelMANdQsrjev0EHgy8qkkF2yRodA6Rmjx+/cSqvv3EvPXtaXQESKeKcr49Q1tI/qK3W4zIwMpaiu5aAcq7o2z1Ih5iMNnnHeOmZkzJq/OiOUEh3paqMeFqxXiCsSdKqlmnqGrBmKMavwnYV6rEVjpsiHORtRFl2K+pudeL/ZpILzFWWkca3Us2c3WbNOLp89q5lyPafgjEvWzUlvlYvLvKFjnKi3zZ4x8bXkQEqWh9NymcyyBKmn6QGw8nLqpupqxc/uzNojR3GYdeF6mLLgw2wjxlXXZyb01bnCBPUY9fOW3d2fPf08mSIa7qYN67ppRF9m0s8YM/9Cs+wc/U6Rrw/r927ALJ+7HLIf2nHme+t9l3L0N786Zlkc+cvgrl+3SFvI8shVZ3V9Ry/RYEdT9nNyka/9XHl4ZWK959YNOWTE6HGn3+rnVly+tvXEeT2AuduO8cioUB8LgiyPbp9c+ZqytOrr6pMWHlnmk4PE/Q5mx5cR3lgUjNHM/rUtmb5JHcwLp63P7B/h88lM3576TNNzxo0jT2Zu3/N85rJ1vvbJzGsyQjD5fKbJeM7l51pEvJWXQKbPVw53OV97wny2Kpf9bAHnr+JVOW9/YlRFZIW9mHVk3GFZbuNeVQ93ublsVppC9VTxjpzkvXZ6r4x9ZG7w5k/ez/zivYzvcebbKl/z6PiBf1rOJ5tsuXnrrspeoG52G+n8PLKzyFUXv3qo48nMGZ/0/nXJxmonW7ayv+bpn35ho/9Z9zvyUv0oV9vl73de2XvDKm2WbK14WVbjXXSFs5+Ts7/51tGSQYEy6HivfF35ufDe7w17x4BszPfQt71cZffGeeXgrqfTTh4Z6Xq5y+W9xwh7+5lVT0surrYSuMKeZwtcdfZB9vM88ZJCfddbZi0vO72M95NXHjkIrHfQna/RLmUmuCU6dZHSFKPbQntDKqluYzUNnnzVnqFI98rGVVTBs6PDKWrsStBKHceun/YWotZnjNlKbYIaLTN/xRpqFJZm+pIOF2DlurjzbK5DbVzcf5oG5cRlSsQRbVotKjV6nFqH43TEtrIrqf7hBNX1HvXM6HIRwB1Ru57q8skvZz25nOMuOa28V5RNn2cjyt4ZwXV1OUXfOcYncXrqpT46q49dobw36tmmt6Jitai3Prdp2G6791R8ml6Xch6jF4Xl0Hh/XPQPRreDPA9OzU4uexvdJ0PV9Mgxqz4J0VJFItqp3ZKt6K87G0h7YVR/rmvZ7bguVyToSMO4uz9nUU3t91qlqqG7RH6D5yd12M30wFHqMfuJ2e8C9mFTtvxuUvqiv1Uiyn5uyHg3cxK+v+Usw+gZWT+vfHNS9HtrUqj9uG3G6cRZlfH0hTTVNcSJ7PHlVTpB6h2X7dTQZowHqlzUcdywZKvV2KPJ27bSJW6OL1puuTDbjmVEhkwFK5Nt1FhIRuxJM6xB63B7XnL33emzYpw1ZbBiC7XX6vNQ+IytOcfK8lPc7lyX24MPf3eJHCSHLcXFg6TVeSYpPSwGoKSZx1blCi0VS6rEsyeE8a8alTZuobtiWuBmpxcvBNVWUZW8SVO5VEwbclFDjezCtsru66IoFSynaoot0UHGVTbxgopBSbmsRFmiumpuWkUb7+CTFD3Aa4mHiquT7ZKt76ZBfa0gcrKWr65zgNhSrQAUVcssJaD6c+wWZ7BiZHyJmDgv3g3P8y3C92EPcpBL0Q79Hma5qW1K1N98kHXwk28Oiq6zi8Ltx+dKSegJ+L1rKOYaX9g40O3kVUIF3oN8bevguIhd42SetpMyku51oyxy2asAOdZEXcosD1yfumU36xBTSbcFaphyjq3FE1yJyo5pWQsaOdvRwu0SM7JcVK6iTbV6BidnmkpxWTR2uRtJHt5116jIZ6foRdGpuFH5BWHrVFoOl0TX150+ChWb9zl11y/MrPnmrbboF7Nw64UJ3fkq6Z5vKovthYfEwHGsjVYLZbo7Fa5OlvLckU7QKatMOg7MZZRFyf3oCFvXchDzrq1pStLf5h/SIOg9I4wFVrjsmWPryxpftFfLwlcJBbHs/bCUZxul9SYp3ofiUKDthOUm30XXMXubvQoxp8bWAoSwRJUrI79bKheOS7ffduUyN1NMmPfpCzMpHPXs9AXR0XvjdBfPotg6FZZD/1Da7vQVt4gpkp5R2kirKAB6QOFObbqtSwfLyeOuyFU27fZRnY9f9hCMddPqr6boLXF6Y3wfnX1cTYxe/rG/a9Ef5Wlo7xdl6LRcdiGQk7WAdQ3MOL1ZSlePx/3pWBD+/VnGlwjH6s2mqD7sQe4cHzoorBvHfelLMf3NB1kHP/nmoJR1zjUeuZ4vJ+XCmBgQxkDDGqkQuU3k+JJ2jIN87ZSLvPdoNzcrwkJuc2/b+cqoDDhWu8UUvR62YWZ8bC2eUO5c5UcXswLvjJN3UvGOvDwol243tfaa7hLLLXTAmO2qXWSlnHVwJxrs6BadULt9eKDmshid3naH2HUT5XismwaNtTs33p15at3SmSCUEjUR6Ek67vKRZ0zXULbMeN2Z9Eseile66W75sxBx7OI2jdNTO8N6BUwlKOQUxp1ruXIOWy5C3Q7yPCw1dB9b1IKnd+k6leLnLqLv9FjtPtpNO3jSINeFfPqzK754KjZvp0bz+Wbbh+7DHry7T3m5Y9i9bqcoYX/zwutb/G5aeYux5ZAYM3JSbJ1dBGk/dkkKY6JDGAPaVWmNL2nj3bfaya6HQO6ezeP6ztu2jKkIRblc7tx8bZclI4E3/QygrPY2Z4yU69f6PC/lHFuLJ+SaqFrgPULZvv6YdMnmcVXIGRyfaGvQQsw0TvFGonorvyY6sfFgEb/n0hazyM/ufHLhmYxGUAvg7vUHdoeI2VvaqlsTtcZ8fs5jI2QhZt/Oeq5Kb5Xb6kCl6qjs3jjS4Kx5HFqWEHWy1g5F2eWmBb1GJQ7pSg3rEq9J6M035hF2I45XLkcp1i8mX0Kx5rVoDGRdY9YaTpMYnKK7g6VF7arPPrrnJh3pR5DBpSFBscO6fmLy2NhluMV45qx/N63i08IqN+OVktiQy01aECHf/gSlfftd2D7sQZTd7GPqvfZz+RXob0XVUdXPzrt+gjax2zLnWmGRdfZSqP0EvBzk2hSkxxf3WqqnHuLYcHI9ncrrncnTtt62OVxFp9j6t/aa5G07lpE2gKz4JNGRQq5lM73rCDimsZfCHAtEmdvFuOteJ/XDO4a4x9a5Bv527ryFZ2usoPwGufycv/QBVd5wtQ5FZ+rtD2jZkuLzKYaZqMtIVzdRMuraFSg1bMFtOL+9dPskwKzB+yUOLSvGSJp7FLc7F5SJbPeZ2g5vuKNBaWD3IZXALQmikeUJGKOejnFqXAcFOt/Icl9L17zf8sD8BpbofIHXnc21Rd5kEGXjjgCWaDZzoS5AwdYK/5UhC969H/RnFWAuwZP/JmMdlDcchveczXWgRBchF6Z+STf82lVF/eF2/oPtb//Th3RL5a/oK7PDQqoLAGD+AXfuIoQ/Qs3f0Iz6FRa+j+/nfGabhVQXAMD8A5boIoU/Zs3f0IyifNjqY6UzVz5ivZDqAgCYX0CJAgAAABGBOxcAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACISAgl6v3aeH7kZ3C8X1LP81X3uU+4+jP8NQpbBvwVlsAfKXY/K0uW8xquW9QPUnuJ0Ccj9UH1KbowbV9KXP2oGEL1weL7XcnKDRYo3vcq/Bg7F4AlWi74K+9DQT8DVEPNQ/j8U6mp2LyPzkX8fBwAAPhRlBKVM1Uxc1CHM8Pl6xs6xol629TMn63QZIpouJs2mB/clR/gte53z0A4j+RASs5M7Dg5k3bSmx+p9kPOhI305qxYzbJTciaUKz9X/brO6Kt5cJWvm17UlyVeK8CTtp+fZVtJzowsS5ZZ9xaWg0P2x72zZ38qjZW325LInilKGbnKrevC92ZZfRzfRj00Tq31Rj6e+ph9iXG1Qz5Lysonh/XjLqu3f5gfgjZxvonYkzRll09O/uR7Xr6+mkWu9pfX3fLJbw166mDk5dvv9HUnfZ62sDkj+4x1j9l3GHd+jky8bZWrbt78JDKtyMscX1gGLrkFl78sS66xwqdc2R8Wt8h+f7Lah/Oz6527fbLbVaV1lyv7vpzkHItVmV3PkmmNOnvuzaq7b1lyvVeaUHKdZfgP0AdjNLN/bX1m/4gKXX6uJXP7nuczl1Uwkxl5MnP72iczr+mgjH9iVIcEHJ8nfWby+UzT2pZM36QKyvuNsPf52WE3rz1R7/M8T/nN+2W89/lO+WR+eZ6nyu/NT9xjycBVP1X2puf0w/S9Tnl9ZG3LMpwcvMi8vHKxw5OZvj1GmbPC2c9y56fiXe2eBacx2tUrN+uZVp7efuIKG+XJyicbs6xeOWTJxYUqU1YZc8opm3zPK9RXZXzONvDKwHxnPPe64rPLLMvkfQe88VnlNNrGg3pnPPkZ6fOGZVm9cd5653i27gvuenNZrPSq7tb7V0j+Wc+W8W452u+ygPMzwybuONV23n6h4gu0j1f2Lnnl6SN++ObltJs77MnLJQtG18kud76yqDrmiwsq19kkoiU6Rj0dRO0PG66xFQk60pCiQ4VmPBIxCzmcosauBK3UV9jd2d5C1PqMMeOpXU91Od2f+V2eK5N9btfdijXUqE9tahPUaN0v48cpfYkDUzR4cpzqWrbY5VuZbMu+32D67GkadOXH8tDnXkbPUI9I275ZV07UfWeutAUJ5/qtWC1kOizKqptpZChFdRtXKTmNHhczwzgdSdbIOFEwqn84QXW9RwNYHA6N66z7AyDd3Gb5K0V5qvW5D0Ku54aMfiMRs+X6bqKWg5Fd4KFcvaHlxO/LODXe7+RvPi9QX9VMDxyVfcfuZ5Fd/6LMneK5dh1039Dn2UR85xu220sYKv80vS6Ta5kYY0DF5t3UXqvzq1xFm8T5i9oimjgv0jbEqWdIjw/8DjWs8fQDk2pqv1fXTeZFxvus+tjg+UkZKm6s0HmdfFVbj2P0Ym81bVrtP3CtXBd30k5dpHRtXORlvY887pC+t0D7yDI48pHjT0555OsjAcZiOT6NU+tjwhrvahNyb3Pyku+juUxVQ3cZY1n0/hpOrrNJNCXKja9dcqYZv6NXxxdkktLajDfvl+6jnNRQY0u1c4/LlZEbx13EbsSgqPLFbjEb7GaKiRcxF/ySU2yp8yIKqpb5K4PpC+nAabOJJgcbOaA4k4XX007HlOWqraIqGdJULqWYPp1ZtNvI2w9WbJED6w4d5+e+6xETnB4xaIZ5wSo2b6dGubzA+QZxSzqElpN8X6optkSHcxCkr/r1s2KxXZliIjKor2VR9DvvwVcmlXSbLUR1nr7ADcMDaJzuureK6tIX5aDKk79QkzWB+33OJtpYoZXb8ARNcEAqRhHO9aglog46LSs+2riF7orp93HqVTpB2ff6t49SVko+epJhyyPMGBFsLJZGhHhfWkU7OJNHA8Nla/aJYvprKLnOIkWsiYqZXr+YKYlZhXl0WdZVABq7su83Z15e5Oyd03TF1VqNaLBcvn7rhdjQEaMjMu/8luR8IowcslEzPDmjz/HSlhdLebZRWliSXK9TYgBw0DNycZ0te/Wyu5VenbjvFM+cxUxZzVqDoGbE54YOCiVtKYfZWW+Zrb5qDc470gk6xc/tF9a0jvOn+Hc+DLbVJgdQMWnhCaC02njyJ5RqQWsmGEXL37CalWLUnh0/jLSsYFixcz3l+3hJqAvj3kLt41i1epJhyCPsGBF8LLY8CRpLeQoFH9N55PTAhSWMXGeRaEpUzrotayYKyqqzZlGhkS4ENdg65r6JcseqjuF1/QXBr3xqxpYLaUnqWbKFnIX5UHELT7GDpc1LQTn4I2d4vWeo39MxZbmsmZ+FtBhmEO3a5kGi0GAs3W5a6Z0467QND0SWZdkaeDJhYSlpHjgd91g+Qssp7/sSrq/69bNoKPeYVIpB3NhFv/MefPNj5ahPGXZZCjkP2v2UrVNxz1kx+Yvlc+WGodixgrEmpimRl+WOzYVKm74g+pql+Ng6FW3aP5Q27g3QPlI+YlIxkMe1XXCMCDYWj2g37hHt1rXyUW7kNvkMPxdtcf01jFxnj4iWqOUuMGfu2TvPciMGrvvFLKrjgGFReHaXZeHNX69b5pmdOB2D8w7jorHKd9yun+xE+twPaxDvsco32p3b1SU7vzHgi9ncocBusfByyELP8Fo7PB3Tcp3a7h8ht8e6xUtirWupF85elxJl4XWtojEVkpCby5Xk3ZHH1vOwn+tWWJZi1u3uU7mR1oe5+5OVOQW0bgrKyYt+Xw6bz3PXK2hfzepnMr1+b7RisicYBfuVqcREv8rnzi36nfeSnd/0wAG51rzTnkxxf+N+qiw2hgflng5h9YR05RYi+lihUBNT8U4H8OzwJGxQ1KHHWhLgduPxIO29t1D7sEtXKLUOr2s7zBgRYCyWY5ly49puXXOcNpQkv1fmuJe3vwYgjFxni8juXHYX8KYCa62K3XEkZnPWbERVnt0I+iXRimOD5YoTMyTpgrPXWJroxMaDeawRNUg6vvsmao215UgvOsbDCaKOJjtt+n62YEwFUABZvrRdv0PLEgVcPKJ8/QlKW+U7XEXtOd0aKq1dvvoJ2iQGlFxrB25ZFpCDV+n4omZ42Ru32CoTckor94+Vt+PWUXJVZeH4M3QXu4tCoV980e7yRRJydvUjIbdTnKe1+ckbL91GOX5vK9O6Z8q5kJtYyFoTFUcyLWb9uSwRPSNmmUvFWUhO2cj3Jeb3vLB91dPPXO2v+saglddjRDu5X/ni7UdHKdbP1rijhL3vcKF3Piycn/mOKXeq2Qa6nxqTG1mmAOvLwSnBWMHIiSkFm8zKTUFmWr0Zx/X+F24fhl26pnwUBcYIL/nGYnbXJlPGpiyrjyml632PNpzfLq1e6j2jxyCRPmd/9b5XPoSR6yxxBW/R1edgFuEZHHfAfANxUEa6uomS+V1T/LxW2p37xQIAhIAtrANEDwf9gyolgifNQ2tKMm7MTWZJriEoYmMRiEyWtai3+5fCRcUuPCq0XsTunbm7xgDAvGOWNulF2aU8r5gTmx/zA0t0luCdd+baAW9siOoWCwUrcOmeyec6BwAERb3LvAmojNYSu1l5jZQ39SxQK3RW5BoBKFEAAAAgInDnAgAAABGBEgUAAAAiAiUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAAAARAR/OxcAAIBk+mcf0rvvZ+ijj8KrhSuvvIKuveYKqrj+Kn1lcQAlCgAAQCpQ1p3XXXulVIhhYcX7zrsfEd+6mBTp/HLnyu9wbqXkgP6yO38OiL+W3pyiaXWlML73jFGn6/ueZUSWZ6/8SrwvBeL5c0E5vwoPCstXtj1/cT9kP1rQFJAJv4fGdf7Ae/lkx2XL156Cgm0+Tyi1nD35eWELNKoCZfg+vp/zyUb1qc5RHVxAzO810co4dQ310bnOOFXoSwXJuocbt4165DlYdIyeoZ7aBJ0K248WMvNdJvIdn9vfoJyLsCUZVYFa8P3+ruAaahb9qSzfTC4zIZXoFPU36xkqHy4LSM8QB5S1qA6vdee5v+CsypgR+1mKOa1KI/+81qupQFO0Q1zPOVOy7tOHnZ+kkFzc+RaaUUrr0nrOMxP6aj7OGHLKnoHL5+WJN+Fndw5YdXXS5suD70kOjBkyUPGuegSUl59lLZ9tXCtUn6Dyk/kkU0TD3bRBpOU2ClZ/d18MX/9sCuefMto4u58WkomXXM/zk4kLfp/seLOcE9RjtGlWffV7aB053zOJ+d6Lw257630dp9Z6nQe/l+Jd6rdkzWldlijfI87zjUuud7tbpBUyMN7PULLNO04IXHLIk1dEOZt9Th6W7HLmVy6842CuNp6H8JpoMCYzfXvqM7c/MZojPJrZv1aE9zyfuSzD/umbnpvU4UzmtSfMeC/6fs7Tc9h5TD6faeJr3meaafe05LlHl9k49o+oZG5UOifODPvX0ysXM9/Lz4kyWWWW5WnJ9OniSZlk1ceJ9yLTm/mPPOlK73oWI+OfzLymg15Ufu74Qnmoezx1EGWyZe5KX0BeWeVT8Vb9ApUlhPzk/UZ+OetvXPOGw9U/m7D5+6YP0caFnueVSRaeeHV/7j6YVR5Pn3ej2swZJ7xhfp+Me/X77MQLXPnrd9zbJzzvp32/a3wQeMvuDbvwvuuesK9ccslBwPEh5Ozu+wIZ70lvxnt48yfvZ37xXqbog/PJxpRFoTaeXwS3REePU+twnI4ka/SFSqp/OEF1vUdds6nG+y33TyXVbawmSl9UMzq+nxLUvtnxsaxMtlGj534b+Tw+Ec9kt5I4jjTImNxk3XOQNolZa27YxSDKIM/VPX7uhumBo9K91WjHGa6JgHIJxhi92OuWocxLnuehoc0p94ot1F47TifO8sPHqKeDqP1hwyW3IiHkmKJD3hmyScMaWqlPA+fRsN12n61cFxf/xmmn1dYr1ggZp+l1Tl5IXjJtil60ZqxTr9IJkf4uWb9CZYkoPy9Z9R+nxq6Efa1i824h44j1zyJ8/hWr14s6WfmFbeOAzwuL+X7I+o5T+hIHpqj/cMr1PHa3trcQtT4TxPoQbdjZR13GuJFNNW1anS8+37ikXNf2uCTKtjPfOCNke27IqEteTBemkkNdy27HzSzbSVjVgeSgySlnHk897ncZXwrG6PE7t9Jq19EtrpaKIG08dwmsRKcvpEUDVlGVDksql1JMnxZC3q9dRI67IfdapEwvqGvZYndYNTjlJvse0Tji5SmWifNCEceWOp3ToFi5uJi6KIbGaoot0WEmQF51y27WZ0wl3SZuGDw/qfNTri9H5ltph1A0gYmah1cmmsLyqqG7xCDWM6Re0emzp2nQUmqFyhJRfnnxy1PLOC856p9F1PwtwrZPsc8LzSSlxcS2J+ku3wahyP1R7+xgR5NKm2fZoxTI/uh5t6uWCSVrISelaqmHy5PfDV1DjS3VTl1dLkolh9gtbkXhelaJcNzPpdnr8VbqKD3NJ9va6OxLffpIiNpGpbxtPNOUd2ORtVnBdWADwMxSTe39XpmHnfWVIo/gyMlS7xkaEbP3wZPCalpnvq7lLcv8YO7LpLEru3znbG+EB2ntifj+BNVZE+9ZWzNTVhKXhz1hSkHmXsus2LxPlb2L+3CbVBKF1sNLhaU8N3TEtCfO8rIVx42fW09r+eRYm7RCHy9FU8ypNi6OwEq04hYxVR2eINc2DTmrDYbv/XmQ6QWDHcf1Irhyh+Qjyj1BkLNFy/3joVi5uJBWk+OekQTIS1qdNlP0urhBWqd++YWlFHkYBJKX5dIdMF25gkJliSi/vPg+U8m4JBSbf9j2men6ZHEzxWrF63MhgiKxdtJLhcSTqtIj+6Pn3ZaeJx+ku3TooLFckgetJE4Jy3Tw5Ksif3855HpWePSEU05WgrqbA3JTnA5I6/MgPXIH0dO72J27l569rOOLoQxtPNMEt0Qtt4Y9WxAK6rFuGjTWavKSdb9A7lTLsVNMpucTy5XSpNc78+BzzwkxSw+Gusdv1lixeTs1itlSj+3KEXVv1mkLykW9PJZ70lqT8ke7g4TiVy+1zkue58FYf50eOCDXHNV6nOVeMmXs3SVXiFLkYRCoH2mXboe47nKLFipLRPnlJfuZbhkXS7H5h22fma6PF8t1d8Cw3oz3J4vsuJEhMRF2rVOXEJ6wiXe71XreVIoOma5w7xgl1+hzrcF65a4UW93GVVThJweR947eamq/N7pj1IujpFmOpXHnjh3aSrtTnG8l3fPNPnpqG18dpzeDTtyyKHMbzzAh3Lns1hCzsLRyUUilFmvL7ZLJgu/njUTW/eJIEh3JOWvS6XVIuqxaCq1veu5paKOu+5V1mhs1qOSnhpr7E5S213VU3ZW7rJBcRLzcOGPFn6G7eNaVA3YHHYlZa8dNlN5YeGNMXct6Sus1sQ28yUSU1ZKpzK/BmlTw0UYkZqthfq9VijwcCslLYa1/qwHIoVBZosivEJznqZa0/UzlLivdbL/Y/MO2T9H10YpnQ6Gfe1gIq+wUbySy123F5HbjwRzuZvW+kLVeJo4daXG/3T94gqXWgP2VcFjUu20/r36CNvF4YK2Tys0/hmzruynWlWsJSuQl3m1n/dccJwRsnXbFHDkk0+JdzbOcFUrOXrmJvn8/W83GBD5suxm8vL/J3lT0wDFxYVsb7Yqs+wu18fxiYf3ZP/6Nlujkg3KNSHVOXifgTQx1LbleWgAAcJBjxvntIQyEhcH5Sx9Q5Q1X61B0pt7+gJYtKT6f+UJ5NxbNNHK9h3F2K6pdgIW3wAMAFiFZS0r6J0CuzWwA5Gbh/QF62xp14MX2aK5HAMBCh//Kj/mToMU6XsASjQa+4gIAAABKNCILy50LAAAgErn/eHxwSvFH7OcbUKIAAADkB7X5e6BRFSnfx/dzPosJuHMBAABI+MPc/D3QKIqULVBWoIvpg9wMlCgAAAAQEbhzAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAi+J0oACHAj9EBACZQogAEhBUo687rrr0y0t8Htf4sGt8KRQrAwiCEO/cj+taDv6Rv/VAHi2Dyb39Jn3jkQ5rU4XnFTz6k+4UcnvmJDnspFB+CsweFnA5+JM/ni8xmtsxj1On6Kj+Ht1LnqA7OMGyBRlWgDN/H93M+0VD15e/kLm9O0f8a2EvLu8Z0XGngD1KbecqweNa0Di92wsljivqbVVtlpc/6jml+vO0SlpK3K5cf/UIyK2uiN//ur9BPH72KbtbhBcUnr6LD3/kVuveTOgwWDGxJRlWgFnx/FFewZPQM9dQm6NRQH53rjNMN+jKY4wx3U+uAPfMDC4yilKi0NITVZR229aWtsfv/VlkkjEr7IZ21zk0LRae38jHvYwv4mUecOMvKsXHd+yE948qbrWd9jeOt6z/80MlP38flksj8RNhM432m4Px3jft96uJYosqC98/LUzdxuOvuj2ntKVQ+Oe/NI1/ZFiIvmaeOZ2+Dq21LUGaF516v3ET4GascWTJnK6yNemicWus91ucQz+q36sMzu+ePtNtxfHgtWREeyHN/UC6naPedW2n1nd0i16hoy8Uob1IPvtJySKbkgLxBXP/6f95LGzrGiXrb3BaBtHCc+005cR7JgZRtzXoteI73zZMmqMcol1UmmzzP9JKzDHny4I9mJwfGDNmoNuTrVnpvmaS8dJyrTf0sQNlHnGtmvvIo0tpvbIjTYMcBo9/5k6vMudrFnd7s125y3V+oXXPKgWVo90Wf9yVLxtkeIy6T8zxPvy9k4RZ8p7vFO61lY+dleHH4KLJNXfCaaDA+zHQ+8EGm81UVunT8g8z1X/tl5pIKZjKv/jJz/QO/zLyig67wP/wy84fi3r/+Bxnjudedrzv8YeavvybSdn0oY/zCnPYPj+uwfo43bye9QJbLKUtWGp88XM+04guUQeWv7rXjXGFvXbRc7HszmVe6nHiXzLyyls80wi5MeTLusPVMb9hbX7M+kcrsqrvCTGs9x4zPZjSzf21Lpm9SB2W4PnP7nuczl2V4MtO3R4SfGJWhzOTzmSYRv39EBe14O32B+z28+ZP3M794L+N/XHw+8yXOa+2TmTN+8cbB+WST/ezLz7WI/Iz6jjxplFXHm2XlePH813RQ1d+5Pys/H7x5qnsMGcpneMqU55lefMtQII/XnmC5esP1mabn9AXP/eoZucKqzZ0+4a6zzNuQscrbSS/TmvF5UW3K9/rnG7TM7jIyWeXwytCD7/152rWQHGQ4pxw876m+124vKRcrXsnIidPPNvu1SdB32nW/t82zn1kMES3Rj+jp7xI9+e8Ml+xnr6L//rkM/cXfagvis1fQk5/M0O8cFNbFExmif3Olr4tzUqR/9JNX0H2f1ReEcbznO79Cezj8wwz98U+uoP/eZBVT5PHvrqDf/YGwaNjSE/F87/7f1fGfvIr+5HPq1OSRNUY1RTl/6nK3Xkl1Pvc4dRPPrL+C6AcZx1oVPCnqo1D3/+1FHTTR5f8Tq3yc16O/QodlWJ3/1K4b0c2fE3XT53kRsn2EMjSo16cnRdn+Vty7WgULYMjXwpC/VQa7fiJui5DVeWlZF1FmlgUZbSVYLfJ5xGpLzZbPOfFBabw/ThXyrJLqNlYTpS+q2WdlnLqG+qh5hYwU6HgPOe8PxBQ9+1VhgW7rppdlOEUPSItUHF9N0VvyWhAqqb6zj84la3SYqGL1eqrT54URs/nDKWrsStBKfYXr395C1PqMMeuuFXlW6vOg1Cao0ZLhijXUSOOUvsSBgM/04ipDwDwatlO9vmflurj4N047N+sLskxpel1aI2PUI6wuM7+KzbupvTZFh6TlU0N3NRD1DFl5T9HgSZF+nZL7yqRylav+IJB5F8/KZBs15nTrFiqzF05P1P6wWc4EHWnIlT4HOdu1WDmwjMfpxFlVlukLaaoT1jidfFW9V1Ov0gnSfWD0OLVSgtqtthRIWfUe9besg77Tuj2Z6YGj1NPQ5rqn/uEEUcfxbCs6AuFHLOYnGfnwP/a49X7nBypaYSm87MHT5MesfKqu8F0fnZwQylcM4J/SYYkY1K2OJuM9935qqT4phOHidJebuYKWmQpfnP+uUFpKkQTHt/w+2K7UR4Qy1NfyoxT3yISasLAMXRMFF1fSff+G6NEn9DOy3KR+eOrvQ9gyS1mIfvMZLXN1iAmUjp9ZHFeOdGuVlEq655t9dPZYgtbKcJyeekmE+fhmnG6U18Jhu9Hqu2lQXyvMJKWHhXJI6ntnrL4mpXhmxDxqq6hKn7qYuijUaTXFluiwpJJui+lTgVTCvWfUAMoD+nCc7rIHWIXjKuUlhFJQQ81dOdy6AcrsQqZXyxqmzHb06vgSElUOVcuqafA8L9bwJIVo071rKDY8QRPiyvTZ00QbV0kFzQrWWqJw6hLkWcHf6YnzIp5d2eYzQr1b+YmmRDVPslUirBrzUFaWB6F8fqxPZx1LeYrBf+W/U2X+7z6WaDmwFNHvTFxBf8/yezSgVSdYveYK+tszGTEEfUSDP7iC6kzL0oPcyMX5i0kNCcuPnxl8HdNNMWXmCZC8x3PM3CYs60Vro3TLQTonZrCnWrJnrXMFS3nuSOvNQ/2JEJaoorFL3Mf3modh3c4EpXhmWcstraoUvTiqBvTBhjX2xNxSGhs6YnRElkNYRTquaKS1KJTfYwXW/AJRTe39HnmJo8uw6IqhWDlIL4qcqPAkKUa3VbJ1qmQ+cV4o1dVGOa3Ncq5jn+15cBPxnRaWqDt/PgzvRxFEU6LaGsxvmX1ku3GVW9d/0JaWo7BS7A0mBjcLKzNLAWsrmJHxnnulZZsH5fq8Ug7eLpemC4/VKc7/NoB15sW3/Das/PREJMpOZXbpClmc/tsMPRrUlatd2X8vLFOlgMMSvcz5ZTFDGLtZSzW4zBxj9GKvHhhNN1pgbqZYLVH6Qgh3XtGU4pklLnflUooZbknFFL0uDB4Hy6WbcrlyldXEbtXSDbBebLfuYaNAgcps4Ju+lJRADpWraFNtml4fEO+gnqSwdZq+IBRp2nHnV9wizG1toQYiwjvNzw23RBOOiJao5SI0drWKAdb8HSmvdVpuXGsd0+83pjeLeFYGT9txagentJTsdVVLASvFzEpQWi9akTzEaRlhZf5FlmvWB0Px8i7UbHcu0R9/13hmf4Z+998EXXM00OW314kF0pIzJhSOshbyCezOZZRL94+/m8njymXc7cLh02eIfldYsqEVtyZSmbPaUiB3QJt9aAYwX9DR7pCuxiikKX1Zn4bGHBjFjDuUy6mS6u/3ugvVrses3bQloxTPLHW5a6hRWCY9SXN36wFqHTbWUAXKpSuU2bDXjWoqdC5Hqdy5FtqtO2z2w2BldshOb1lo+XZGh6U4ObA7WljdHSmqW6ZGGlaYgx3dlNauXMmKLXLtd4e5W9ZvB7VJyHe6YvP2rPVoaWkX2gUckMjuXHYR8kai3xEDtLW+Rf/O2hD0IX3mu0SP1Gtr5ZNX0f4spWtxJe159AoasdbsRD5/XHWlsflGWLITygVpxTkbW9S9JBSejH+EaIt4Tq41VoaV9pPC0rTW5j5z8UppmXk3Dj0iFER2ecKiyr/SKp84pBtUll+UXUwu7LVK8ZxlIq2oAh0XE44gsEuX1y/zuXL9nlNMfaKXWcmCNxJZsvjEE0T//TtXhZicqA0LvBYUaIDVmy12SPePOA5X0SkxgNHwaRqMMj7n46Y4PbiNT8bp0W16Y1Gon7uowdVZGzxKsX52oTkbNLwolxmv9egBR9T3FG/IsdfKmujExoOhrPCsPAtRgmeWJA+Dis37RH5pu92VS9JjUVkbZVybnKwNJ012OdL3HxSDvLkRySSi4pL9Up9rCpXZ2y6c3tW317URCcvR2TzjJly7BpADy0+uZeb+aY3aAFbtuG61zGO3mO0qntXJG4mMNcskZbeXRaR3Wrxb/WZ9hHxPrqdTkTw+2Sy4P/vHliUrRnMHaSjk7xUztOXRefAHE9iSO3NF9LqCUJy/9AFV3nC1DkVn6u0PaNmS4vMBAMw+83v0zXIHqp/e5HdvLhzOninkygUAADCTzO8RWP821delvJDRO4x/h92rC72uAAAwh8FXXAAICNy5AAAv8AUCEJCi/ni8phR/xB4AMHeAEgUgIPxBbf4eaFRFyvfx/ZwPAGBhAHcuACHgD3Pz90CjKFK2QFmB4oPcACwcoEQBAACAiMCdCwAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAERkASnRiF+ZLxMjXVtpeZff1/HLSWllND2wl5Y3p2hah0MxlaJknq/ih0GWY9ZlG5Up6m/WX+lf100j+urMUNr2L3WfduUXqn+461WW/jDa7er7Rb0LQZmNZ4bAXZ65PR6XkgWkRGuoeaiPmlfoIPBhDsmoMk5dQ/uovlKHFytTr9KJ4TgdEe1ybihBK/XlmWEevSOh+gfefTB7hFCiPLPopn6ebfCs2TPjUDNpz8xUzibF7JpnUGa8vG7d4519u/NLDlhTUTVjd8IKnr2qa+6Zj7qecuXlnhWZFoCIE2kLzXzlTMvOz13uws/T+M2wpXzyWCGm/OSR32Jxl9N8lltGMl1XyiUHP/k6cap+uWeXefqCF5cc+D5xPmDW013HXHXi6xs6xol624w+6W5bPsx6BWkrs95Z8va0R255aFzpjfbg6/XdNEgp2iHivLK3Cdn+ucs+0+9IiPZnPOPAi/qyxPueeNLKccjH6vHvD/nhe0w5mPKx68KHVR9uj2SKaLibNrjkO0E9ed6lfP0mVxlsIj4zZx0E8p0q8P57yZffooX/AH0wRjP719Znbn9iVIcZdW3/iA5mJjN9e+ozTc9N6uDzmSbzHiu89snMa+qCO73OL1f48nMtmdv3PJ+5LEMMx7dk+mS0uyyvPcHPseL0vfZzdbydlyqHmd6L937f/Ao9T8rBW2cVZ4ZdjDzpKZeqp7sdDGR657nusFtGqoxG+3me5V9Hz/22DN15+9XThewL1rN0nbztYdUxb510OWx5eO4VqHo49SrUVu56ecLesrjq4YNHpllheb+Rnxdv+gLtn7fsnjYK1Ge9bWKkl/F2OaK0v7fvGfn59A87L31vrnrJeuSQjx+q3qaMvXUX6PK5yuuVszfezFOGc/cbvzJkEfKZhepQsMweAuVnx3v7w8IltDu3cV2NPuOZzFHqaWgz3CiVVP9wgqjjuDFTqqb2e/U9latoUy1RXcsW7baqpLqN1TR4flKGZH61CWrfbPlwaqi5K06DOr+K1eupbvg0DVqTpdEzIr24lsvl07DddgfJeylNr8t7x+jFXlGuh+NUIWNFue+PyzN/xqhHzG4buxx3W8Xm3dRem6JD5swt5/NMdJ1PvmrPorksm1bnqMSKBJ1zubVq6K4GfRoEeX8eN6GQd6PVfivWUCONU/oSB6ZEGd11XnlvQtTJn2B9IT+Nog2s9mAZUfqivyWRt07iuZ19dC7p9FPVFh7y9A3Z1nZZuK330blODgvL7HDKJRN2O7a3ELU+4zcjV+nrWnY77SfKfqRhPEd6H4psf6fsOSjROxK2/afPivfY1fdYLvrci3zPjXFByHxnmHcgCJ5xZGVS9CFTbvLdKECedylQv8k3luUi5zMD1iHP/V4iyWQRUNSa6MR57TYxzXvpnspP7Bb/niLziy11v/BLqpwBUCrhcTpxVmmmkSExQG1c5U4fhKmLYqiI0W1mMczneJHpqym2RIcllXRbTJ+GRA5WwxM0wQHOO8jLY7izdvTqa36s2CKVO7sHOW2WWygwk5Qe9tS5cqmQmj9R+0IgItbJdj2FKYdvW1uwTIh6kjpffUj3oS8qvbe/Vy0TE4SwBGz/is3bqVG6/DhtPtdrAUK+I2Hb3+9dzyWX6QvpwGlLjXR5yvq0UY++Fp6w/aa0lKYODqXOb75T/MYiMfs8JzdFmEcey6coTCuugAU3l5GTgRS9KJQBz8gp30TAGjzFgBTrUvLNOWOXaEtMp1MvbhGDaRhmrC+Eq5OlPHekE3SKy9Cf24KOQqNuB9dhWL4lJXT7q00254YOiomHsHjrWRb511BLRlnHgpnFUhQbOmJ601db0VZXWfuNoNR1mAmZLASKUqJyNpjL5RYB3/wuTbhms8qKO02DAwVcufmQFpXH1ep5jguZ3uvmmKLXxQQ5Gmoy0CMs6cGTlHciIN1eenAKu/tQul/0YGpZ78G5mWLiPledpXXiT6n7Qi4K10m7IftFunxuzFz4trUFy0RU80JQWfqnl1ZYQKK3vzXx4IFOTdhCEfIdCdv+fulzyaXilljgtKXBWspg+ZViEhC235SCUteh1PktHIpSopbrqNVYF5SzlYC74rxk5zdGnUleU7LWUAXapdvakcp2/QaG15VEHo8ZuzkPi/xyUkONLULpJZ0Z/fTAAWodjtNOe/02HHIy0CvqSgEmAsYAwvLN686VOwANy0P+hCKKxa4VvVHnkWdyu+dK3RdchK6TqQRFHwrlVtZtLfqDXW77+WpdcLDjgGEFqx2s/rsafdKLvHawkrf2CQQhRPtnyZzXEylOd4WcgIV9R8K2v5W+x1LuUi763AuvvZl5C+v8UL53oEQ4So/buBjXZdh+UzpKVwdFqfNbCBTpzq2h5n7ePNAkzXxp6p9cT6eiWAASdkW1UczOr43SLQepy6Wo9KYTgbnJKSwrk8KaIWvtqInSG9nl51kDMuANGqda0va6nHJpFDEjszZZFVjTlRuY7HKK557fLsoh6t97xlEqJnKDhrN+qNyA0X6PyXU28zq0LCGsmlzrhaXuCwYF6qQmJLwex4pObUZz1p+OUqyfrbHg1risd8yR+fJkWli2uq1FWU7xhhDpJuWjiU5s9PZRA94Y1BVz0su8grdH2Pb3pneVPSTh3pGw7a/Sp612OlxF7Tnd1J686ydoE8sgxyTa3R8E3klYQYTSk5uirLqIut/P3g+iniG9EUgr9g1Bl0rC9hs/Qj0zQB1CUer8Fg5X8BZdfb644bUn8XLuLJurgmdyB4gejqbgZgf+PR4rpflUZlAyyv6O5IatXJ5QBF1THOnqJkrOfrnBwqP4jUXzEufH2RbSVdmwpnwvGbskg7hyZ41sd5P6CdJcLjMoHXPgHbHIsiT1z5CCeqLY/UuzUG6wKFi8lii/mPwXQCx488YM7pQz4d2jcl1srlt00vIw1hNrE6Vxz4L5wSy+I17UO6MDAt7gEnajHQAzAdy5AAAAQEQWqTsXAAAAKB4oUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARPC3c8GcZvpnH9K772foo4+iddMrr7yCrr3mCqq4/ip9Bcwlim3fuQj63OICShTMWXiA5bH1umuvlANTFHhwfufdj4hvx6A2tyhF+85F0OcWFyHcudnfF4wMf2KpOUXTOjj/YFkE/KL9gqeE/cIDWyjFDrB8L+fBeWWjvpmqvtRvfq+yjHjeBf7YdPnejQD9mD+HN0N9vRTtOxfJ3+dmmALtVd7+VQjP2FFAL8ytsjuEUKI11DyEb/gxI11tRF1z/FugZWPm+gXP6EsxwHIevu5C/jD6cJyOiPKfG0rgo81+VMapa2hm+nqp2jcUl1O0+86ttPqrKXpLX5oJcvY5EJmKzfvo3Bz8nnFkS5Q/kpscSMlraibvsUbkjMiJSw7oqZH1od/hbtpgzP45PyutPLrGdIyegXSlDKvByE8j09j3e2diqux2vJE34352AYuEv5KfTlCjS2mYFo04vLMllyy6qd81oypkyXG8vseVd75n8j1CBqPGc2W8KYf8MnLkq57jlbdqf77mLn/BfuEpd6dIG9nSsQZEcexOhcyA+6H84HiKdohyyLpwOwk59Vv9weonnFaX1ys31TfHXH2I6+vqj57+ZpPjXSCaoJ48fd1dnnx9R+Hfv7nd2qiHxqm13sqDr3n6msuy4XhxPmA+3/O+5O3rpWSMHtdtv/qQj3yL6RuF8i4BYcYrV/u72kMh2zdXH3PltZd6zuvLvvi0v7yef3zLV5essvmUX5LzXXCQz7GfHaAvlgteEw3GaGb/2vrM/hEVeu2J+szta1syfZMqfPm5FhF+MvOaDLnTZoVHnszcvuf5zGUdlHkZYRlvpFd5e+43nq3C1rMFrrC3LJOZvj31mabn1M0yb+PZ3rAXLqt1r8KdHyPr88SoDqnn2/GTz2eaRDjfM9yo+538mGDPdJ6hw4bM8pbRE86WCcdbeam0lnxlvjn7hY6381L1cLWlwZs/eT/zi/cyPsdopkPX50tf4f/rM1/67qRPOufgvLKQbWH0G902plz9+5q3ftl91ZatzNO/fhLOz5CtNz//53vLnDt/b9u5w2Y7MqotXX3Nlb+O97Zfrn6k5Wk+3yR3++Y7JjNHrTb/ipb1t0eN+AJ94+LzmS9x/Feez1yw77GOQnmHO3z7HONtQ1fYI0Nfmbrb2/Uu+7RX0Paw29ds/0JjTd66eMcZgU/5XH09Z9n8+q5ZF29fLB/F/cSlYbvt5qlYvZ7qKE2ve2cYkvwuv5XJPreZvmINNepTm1rD+pPx45S+xAExSzqcorqWLY47bkXCds9NDxylnoY249mVVP9wgqjjuO+sJb/LYIpeTxPFbjF8W6PHqZUS1L7ZubYy2UaNvUfVbGv0DPWIstvxlXHa2aBOw9C4rkafCQo9U9N4v1WPGrqLn2m018p1caL0RTmrkzIyy8jt1RWnQS0j2bbDp2nQylvWSVxzHu8mZ78Yoxd7q6n9Yatcoi1EGcNTQ7te6qOzL+2jB2/Vl0pGNW1abVXM6lu7HXem6FtHGoT19owxuzb6pqqvqOO9ur0qV9GmWquvBqRAX2/sMlzPoj+1t5C7PHkI4hJz9TUfnH5VSXUbq+1+VKq+zryV2qssQfOQVmEl3fNNbvs++rMvqLRuAvaNV7rp7tB5K8YOGffp4/Fg4hcEGK/yvIuh4PYg0QZGe7S3iPYqQJSxxsaoSznI2RfLyAz9TrSGGkVj9SS1mZ3T1eDGcQuwmykok5Qe9ig2g4nz40S9bTpffUg3nqJi83ZqlC4EjvNxM7jgZ1VTbIkOCqYvCK1q328dTvllfGypa9CqWla4I+ej0DNzUbfsZn3mRsrIU0ZaUiWUgUYrghNnlXBGhsQgsHFV3oHYl6mLQp3G6DazqcznzDn8+1bh9vPUsWSo8tjvlT42dIj2y0G4/l0cJe/r29qkQjt7LEFrOXzsKD17WcaUBs7fzrstkCJkBfrAMXFyR4JekMpaHbvyzzsMAoxX+d7FEMj2qK2iKh1mKm6J6bNgFBxrVmyh9lq1JMJxhZYWFiIzpET1jJc3bIhZlKXEstZ2NJby3NAR05s8xExHx5UEYYnKsrgOa7akrORzQwdFZ1DrQzl961IJ+CBmjqey8p/hjUdlfaaa5Q2efFXM8pQ16VhroNw0dnnbXRzJXKN4iP49h7gxvp3uE4pNWnrbuullfb10xOmpnUJmN62ijXeoK29cLDTDGKOXWIEK7tsRpxvV6cIn71hTSfWd6tqRBmuCN7OTtbnGjClRG2ne99EpYZmqQdjLlLg+rgeGKG6AmylWK6z4C/6tJmfCgUx8qzOwAk/Ri34zqsqlwsZwI2d2wxM0ocNeZLzn+XK2WQSFnhkWXxldmrCtdcZ26Q4UcOXmQ8rP4/L3PGdu4d+3im2/6OTv6/kJ0L+LpHR9fYqe/WobPS3O1j50UFh6bXSfiphRbl1ajolhhPEq4jviN05IyzIEYcYauSynJ2uW12oxMENKVO0Ic0x7pSjzuQCdTsU7wcK4c9W6mmvNwNgBZrmzWg0r2Nzl5d7xJdDrCHf5rt/yC+BZ37LcGabLWu6e1LN9XtMyny/KdqhXnUam0DNDki0j0X5Jz7qNdum2dqSy3U2B4bVZkcdjxq6/wyK/OYvVtw44M2sh5x28rmuteZYVn/LI96WAlydw/y6SkvX1SXrzFXUmFdvli/SGCpaQFL3Er8/YcXpUPquaPm0s0/hTQ3duU2dP7+oWb0kUwo5XnndRTkQNJZVPxnqcOGS0R2se178vhcYa77gjfzbmeKrkpKD3jB0/8oyzlLZQmLE1UV4Md9Zumqg11kZd1uK0ftk2yI4jOpXc6NNkp03fz7MZop6hgN1UWLunWtK2X57XPGP27zhFWfrN/LfShpPr6ZTeXFGxeTe1k+HzT6apXaT3t4gr6TaebLtmkaL8nbzQbqy7JomOmO5i8/n1E7SJF/dtReSdcASh0DPDwi6/NorZMmqjdMtBp70keuFeUGjjST5WJkXb2vIWbb0xQXWh1xCdnyDI9SnBy/ublOuv1L//Y09KV0y7QVnO3D9K6DZ3vQv6Wj5kXyenPEKGJzZ628ohf//WkxqRVy4lHI5CfT0oNXTfQ6qvPb2L3bmniaTLdZwe3fYQ/Yd/r9r+7v1aIVhu3ztZsQXpG9W0VuQn896lJnH3Pb6P7rmJLeB8eYuS7eyjp6QiTdED+jl8hPoZTaHxKu+7KOLlRiMd/xjRzpybhdQ4YedltUcoCow1oi5HGpw1UXdddP8z1kxfFPXJuVQX9l2YI+DP/oWFZ42iM+6MrLCUdbDh/PY861iLiDzyPH/pA6q84WodKo6ptz+gZUtKkxcITr6+Xsr2nYugzy0OZn5NdKEht+2HWFPKcrOOUU/HeFHW3Pwl2+qW7p2GNZEnJGAOgb4OFiGwRCPByuAoxQK69fivduww1i14E9Wi/fOJPNDyXyax4J3TOSxyWKLzjzB9HZYoWAhAiYI5y4WpX9INv3ZV0X9flf+G6dv/9CHdUvkr+gqYC5Sqfeci6HOLB7hzwZyFv8nIn5Qq5g95872cB+cF5halaN+5CPrc4gKWKJjT4KPcCxt8lBvMd6BEAQAAgIjAnQsAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEQn1O9H5+sPocvz4eT7KZjH+KHy22gk/wAdgYRJYifLgw+POdddeKQeE+QQPmPxnuLjYMzGIzVfZzLRc5hqz2U6LTdYALBYCu3N59j4fFSjDZeaycx1mgvkqm5mWy1xjNttpsckagMVCYCXKM+nSDz7WV+jVV+NnEi77TLnwZkY2+Rk7pL6o/3iRggsjF/7A8vLmFE3rcGj4M2jF3F+IAvlHbaeZkDV/Msz8rioAYH5Spo1FlrIUx6GwI1Ex98593krtVXW7cy89e1lfNLAG8HJMNED5WJlsI0qaH7AGAMxHZliJTtGzX2UF0EZv3FGtrwWlmHvDwh/Z3krL9ZEcmNLXBVMpSgrrpl9YDjK+q0SqbKxbKse7v0e0Vl8ysZTrA29U+8bPHhPU0+zIyrSmsi1VJVeZxvoY93A3bViXQ3mwrEVcP+ej88+2LHO0VZD85xQ11NiSph2l6k8AgFmhJErUsZacY3eKB7dKuuebfXT2pT76sy+otP6k6AHz/q+m6K2g92pl5DpCWaw8KLdRuuUgnRvqE0cbxTqa3IpUDMwnlun4ZI2+GATDirYPbXHWJGTdzn5zO92qEru4Mb5Pxe9Zr6/48/Qun7w1fu1SrEuShlOU3qhl0Z+gdDKgW3JFgs51xYlqE3RqKEEr9eVsUtR6frvdFo1C9q12W+Rpq8D5+5GnnQxyy9qa8OWK96di9Xqq6z0DaxSAeUzJLNG1Dx1Ug/7jYiATvLz/uBiaQnBHgl54qY3u4/NXuunrUgkXgBXoLmF9UDU9ckwpXHnsDK7opgeOUo8YeNs3V+orNdQsBuPBjuPG4FZNm1Zb8WFxyvbUNg6P06P9pbQ+VP523t/iCYhSoA8cEydSro5sdoWZA/hhyqoyTjsbiHqGSluf9nutQtbQXSL/wfOTMhSsraISpJ38ZM0KtIkefUVc2tZmy/nsS/vonps4XR4ql1JMTBpexNooAPOWkijRmvoE0f4mNQOXSi0sYnDaE6cbxaB4pxyghBL+sRo48zH2ff2sbdsLD1g5mDg/ThRbShU6LFlSRXX6tDhq6L6HiB7dpqwTqdRKzNqHdsu613xeTV7olQn6BzF9eUk/674dLNcS4pFV1bJqovTFmdssZDBzbRWsnXxlfflVOskKlPtwfdgZys0UqxXiuxBgwggAmJOUQImO0ePbuullcXbf42IGfixRkjW8tZ+6WZ/NY4SlfPd+MfBTnJ4S1skLD8302q7gjir6DX0KAhK1nYqWdSXdFtOnAIB5SfFK9PJFekOeVNOnl4j/Lk1IhRqOcTr5AzEbv5yi72gr4Nalhd2ntkVwrC3yWp+vJSXqMKhPi+Gti2l1ogfbf/gxD9Sl5eXvvapcike0VX7rUpdF//SuEu/q9cjK1zqcIWaqrYK2k6+sb1pFG+/ggONKD84Uva4fDQCYnxSvRG+K04PWGhG7w3alaa0cVHiz0F9Ql95woWb6AqHw1MYLZ3Bfe0c1vczuYG3R8vrqrhpns0bOe3lzjl6DdW36kBuTglGxeXv25pVkiupatoTcnJLNjfHt9hrv3aJc9k5brsc3/lyXt42e5muW/MQ13pRl//RFy8TcfGVPGITc1sq89Zocr3/q9eCandbanXvTltrwVQRCVj3WGt5oN+3oddYwK24RZtXwaRrUj5BrmOq0JMxUW+VtJ2uTWk5Z8wa4g/QI93l9vyXrwhO7SUoPiznILVHX2wEAs03gP/t3/tIHVHnD1To0P5l6+wNatsSvDmrXpzXg17UcpC5r8wr/7KL+NG3q30f1Oca6+S4bSy78E5UNJ9fTqc64r2Up48+vp/a0UGRi8Gcau/qoeYU6Z/iPCOzoVed1LW206WQbpe+30lhyForXT54+spb5UZuxKzpPWxXIfy60k6sPyvpO0E65m3iK+pub6MRGsz4AgLkOlGgJWChKVJxRf9erVJf0V6LznbmmRHlS0kq7oTQBmMeU7CcuYAEwepxOLFu1IBXo3GOMejpitBMKFIB5DZQocFiRgFVUJka62oi6wv5RCADAXCOwEp3JP+BeDmbyj8TPZ9nMpFzmGrPdTqasVybda8kAgPlJYCXKHxTm7yHOR2XBZeaycx1mgvkqm5mWy1xjNttpsckagMVC4I1FDH/UmL+HON+UBc/+efCayY8hz0fZlEMuc43ZaqfFKGsAFgOhlCgAAAAAHLCxCAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAAAARARKFAAAAIgIlCgAAAAQkWhKdLSblq/bSsmBKX3BYXpgLy1vTtG0Ds8dpqi/eSt1jupgBGTdusZ0iGika6srHBZvfoUZo04hd6sOoWQ9laLkur3UL5useFksWFxyymY2+nf+Z7r7RDHMRt1KRoF2KxgfAvO9ny8ym9kycx80ZVu6PjkfiKBExQB8OEWNDXEa7DhOI/oqKD8Vm/fRuc44VehwXirj1DW0j+ordRj4s4jlFKo/zTfQ/8EMEV6JTr1KJ4bjdFdyDTVSil4sMNuQMyAxK1FHt0fpKovIjs9rlenZzoCygsPlx9ebqHWYqCfptqDlrMzOL78FsqFjnKi3zTOLOyNnXVYe7tmXpzzisJ6dOz83rvJ1ndFXFVkzSu0hkIe43m9ayvZMPIcsZLy+Vxx+XgYTd7uKw2g7LldyIGXLxWU52/cUtgrypjfr6omT93WJ+huyd9dHzZTt+81+l2WxmGn3Us95fdnG08autuR7u0Wf1fWw4/LdwxR6Zn5yyk23cXb/V++RPDfLkrdPeOrgfXdd92oZ2HnnkIurTdV99vst8xNhM433mYL0M0bds+qSq129eeV+b/OR7ZlS+eS8N498VR8ec71n/B652rYEZVbkkQWXUchRjiXeOAnf20Y9NE6t9Z7xbyjPWB2gre3+wYfZlnONTEguP9eSuf2JUXn+2hP19rmFjN/zfOay55xxhyczfXvM+71hL6OZ/WtFfOD7/cP7R3RQ4C1fZuTJzO1rn8y8poNezLozsv5rWzJ9kyos4+37s+uj4j3pjXgv7vys5zl1kPFW+SefzzQZcaouxvNlvPVsryyUbHOH3chyZMnNUy6jnoyrrEwBWWfFm2F5buTvCavne2XhrnvTc9bNnrBLTkoO7jiz7t68vO+E7rOuNg52T+5nenG3VUE5m2FXXb33evuAGVZ1cMrsDReqg4p3ycXbpt40OWSfFZ+3DEH6gLcu2f3ZbC+XzLyyls80wi5MeTLusLcPW2F3fd31iVTmrHJ4ZKPl6sjKD87Dp+1ytVXQtrbro+Lzl2H2CGmJjlGPsJ4a19XI0Mp7E1TXe9RtIeTB5S4aPS6soTgdSaq8iCqp/uHC+TXeb7mbKqluY7WYel7Us9iw+XFdiNofNtxXKxJ0pCFFhwLP4AQN220XUcXq9VRHaXpd3i6e39lH5+zyWPFBmaLBk+NU17KFVuorK5Ntwvr3Z/rsaRpsaKPmFfrCii3UXqvPQ1NDzUN9Tl4eViZFvUy33wr2SnioFXW1XWdhZS1m1YdTrrpz+nNDCRG24nY7rjmZl5gJP2PMkmsT1GjLgss3TulLOuxCtVPXZh8/3+gZMcOO004rrjJO7S2iz1lwn6MEtRv3yjby9DnrfZEUuqfQM/MSQM6yX6RoB1vqj3UTmXI0mB44Sj2mDM0+Uehd4zqIe+06ijrsbFCnJi65yPY13a01dFfWPdVG3cQzxVhAvWcMC0fE32vlqe4fPD+pwwa6/LaMXX2giPdW9jPHO6feyTVOH86LzztnyF+Vwahf5SraVGv16ehllu1sjhu6Lcm1VFdNm1b7dJIC5Byrg7Z1kLacA4RTovrlsF8s3ZAnzvoNhKIhN2+nxuFu2iBNco/L7UJadJIqqtJhSeVSiunTsITOb+qiUHfKBWG6FXb06vgSYrtk6rtpUF8rzCSlh4lit5id92aK5VCME+eFwl12sw4xlXRbYGHWUKMYqNm9K8uZ5bLxx3EtsTsnD6Fl7Vd3C/+4qmVBFY0afAc7mlQ58riJ/PpUxS2OUGW83b+tI78sCt1T6Jl5CSRnNUjW9XZnKXMT7k8UW+ooY4NC75qM99wbuH0MF2d2/4jRbWZxl1QZk9bg+Jbfh/DvrRrs0xdUgViGromCiyjvnKf+PoQts2xnXlLSMg9X3yLJ29bzhxBKVFkA7gFAra3l3mCkZlfnhg6K2a/1cnt847OKmO30c/nch69VEgGrQ+9IJ+gU590vBi8dN9eQXgIuYxfP7tVLlWtNxVKeGzpidETKLLeF7DCzsg6FnAmL53N7WP054MQhCzGplG3rOgpsYIlyT2BCyHl4gib06axjDahiAI91qTIfybJOykMx7+3KdWKCdvJVMTEboxd743SXaVl6CPPOFaKosUZYomZfUQd7fWaIOdTWpSC4EpUbinxeUNlYhTYYaXeDHGxVWjm79r7EciYdjdD5yZlzLhdfKeCXSMsr0o5HZXVas1qFssL84Jm+290xRa9HEaZWMKfELFkNBl6Um7lRdv6AL1poWfvV3cI/Ts6owyJ3bIp6yEHMdAsq/PqUtGI0vn2uAIXuKfTMvASSs5gMSzdum3br+k8epOVoud88FHrXZLzn3kLtYy1HcN/LtYwgMnVbnZcmhMVU2Drzkr8Ninxv2aU7LOoycIZ6grpyC75zhYhe5nztPFMEa+v5Q2AlKivuWufS6PWOnqHslzFrt59e75GzM3ttxrpPvdyDxhpjKELnZ7lTTMtY7VIr3e+bzAFN5B3KTWK5HR0rf6Qrt6tQroGI2axddrnuo88L4q23Xo/duCrnC+koMSHn5gLu3NCyzq67mr3ykoAVd8BZHhjtph08iNhrKPng8rpn/CNDKTEb9xnwdJ+y1xNFGVp5R7VFVp8TyF2Hebwthe4p9My8FJbz9MAB7cat0W5do88YWEsxPUafsOVW6F2TiqSbWo06HArirjMGcx47sl185rq3eKZ33TwoXhkLpCVn16eY95ZduqKcHak8rlwm/DuXn2hlttrZbitB1rg9ExRs6/lDQCWqNhTlamB2YZDPBp6KzbupnQz3bzItZkuW9cLW6UFqT1v++CZqjYnZibE4Ho5C+anFbbkGoV8WdqfwposdVvnWtREJCyvX7MhSVMFc0jXULCwce81j3VGK9bMl7qwhF8xPzFBPtaTt8h1alsjtNmWrynze4SpqF5Mb9zqphVcW3rIq2fm7WoWc5cYDvaYo0qbvZ3e9/0TKIqysvXVXrh/t8uSZe1fMWfuT/SqoO9Rbfu0C8+133KfaKGalrZ+gTUJJOaj4Ru2KU2UhOpLXQi90T6Fn5ievnIWy5p9V2Rs+9KYlt9K1EH1CvKtp3z7BZcz3rql7bRlbdcixxsp4x4oN57dLy8y7caiRjrqeGW05wCNjcTh9oPB7Wwg5HlrGQk7CvHOFKKbMnrYSx4aT6+lUKItWTxzE+xjEHR2srecPV/AWXX0OFhg8uz607GDEFxOA0sHWBg+WkSfJ7ImoP02bAk+WZhH2LAytKcIgAPOJcLtzwZwlywUjXWjRtqYDUBRZLm33T+MWOrw8sFjqCmCJLiB4zarJWAfljQbzYNYOFiTsBTHXuXgjWlGbSOaDJSrLyGvDxSxLgfkGlCgAAAAQEbhzAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACISAglOkad67ZS56gOFkB+37JrTIcE/I1B83uXAAAAwDwHligAAAAQkaKUqLQ2hXWqjr3UP+Vc39AxTtTbpqxPtkKTKaLhbtpgfvFefgHfut9t5XIeyYGUtH7tOP7orZE+OaAfCAAAAMwG/FHuYIxm9q+tz+wfUaHLz7Vkbt/zfOayCmYyI09mbl/7ZOY1HZTxT4zqkIDj86TPTD6faVrbkumbVEF5vxH2Pj87DAAAAJSXiJboGPV0ELU/HKcKfYVWJOhIQ4oOBbIOp6j/cIoauxK0Ul+hyji1txC1PmOso9aup7pKfZ5FDTUP9VHzCh0EAAAAykw0JTp1kdI0Tq31jmuVjx29Or4gk5QeJupJuu+XLuCc1FBjS7Vzj7lpCQAAAJgFilgTrab2/j46J6xB8+janNN0zKKxK/v+c8kaHZtNxeZ9Kk1XXK23CmWKdVEAAACzRTQlWrmUYsISTV/S4dDcTLFaovSFiApwRUIq01PCMh08+Sp+NgMAAGBWiGiJWq5VY6dtqN+RVlL9/XEa7Dhg7+iV66TN+SxLb/5TQoGOU93GVc66LAAAAFBGIrtz2bXKG4l28PqkPNqIupyNPhWr11OddLlqRbtiDTXKn7jon8IIa/IUbySy11Wb6MTGg3ncwTXU3BU31lGbqDXW5qSXP5cxlToAAAAws1zBW3T1OQAAAABCUMTGIgAAAGBxAyUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAickVGoM9BaN6hkb85St97S5zeuIb+7e/V0MdVBAAAgEVAOCU6laJkfTcN6mA+6loOUtfmSh1aqExRf3MTtQ6L09oEneqMU4WKAAAAsAiAOxcAAACISHRL9N7d9Hf/9rPysi/XXkcfv0afL1hgiQIAwGImuhJtaKNzyRp5OTfv0Mjxo/S9KT7/BH3h97fSyl+XEZLp4V7qPfcLcXY13XZnA22OXU304Qc0fXGMBl/+IV38xfs08ZP3qeqTlbR05W/TXZ+9lT5+lbpX8s9jdPS/nqHLfP5/3k1f/swUHf0vx6n/R5NElTW0/Q/upfoVlSLPdyg9/AIdHThBr4myVP3Werpryz20+Tevk9kwPx89Tn/5iiwo/cu7E7SeTlP/sf+h86qm+s330L+u9Tw/gBKdHk3Rcy+eoQGdz+a1X6R/fXcNVbjyAQAAMB+ZYSUq+Im4535xz7tEH9u0m061rVebb8zrv/cQfX9PLX1MXB7p+gPa0fsBp8jiY78Zp6e6ErTyWn3BLM+ySvqtqSn6kcjP4Wr6rZ1/TNv/15PUetKb59VUv+8/U3vd9TI0PbCXNnSMy/O6jTX0/54co5/LkMGy9dT1F7up7gYdzqdE332Djra10Dde9qnLr9fQn3e30eZP6jAAAIB5SfQ10fd/Rj//x3f8D1ORfTJO7XuqpYJ878QT9KcvCGvvQ6F8DvyVVKC0TCjGpFKgzMo741T160tp87at1P7nX6Pv/HmCGlcLC1Xw3v9O0QNdw/SeDHk4P0XppZ+l5rbd1L7tVp3fB/SjQ11Sgcbqtoj8ktSslSbH9f/Fs/QjHTIZFAr0/d/kvMTz/1OSvqyfT+dPU7Klj9IfqmBufkYn/txSoNdT/Z42+m8DB+n4n8fVBOAfx+hPm/+KflQwHwAAAHOZmdmdm2WlvkOD33qQkn8jlMq11fSl3yP6f3rZ6rueGru+Tc0rHLeqPz+jgT97kP70JJ8La/AlYQ3yeqtZnk9+kb5zOElrpJX6gbBoHxQW7TscINqYpL/7+hf1z08M65Gqqb1/H9VXui1RVuxHug2L98N36ExXEz14jPO7mrb/p/9CX5OKNYcl+vd/Rf9X4jhNiNO6hw9S1xZnl/J7wwfo882nxUTAzAcAAMB8pEy7c6+juuTXqHGZOH13XCtQYXXu/g/+CvT9KfrR2R/SGesY/SktXXmrjpyi6Z/pU5ON67UCZa6mlbW1+lwoslrz95uVtKbOysuf7X/yR44CZa66jtZsuYd+SwaEBTvy9/IsFz86+z+kAiX6LNXf6f6Zz8dW19F2efYBHR0ek2cAAADmJ9GVKFubQ33+h99a6bU19Cd/sl4HBLGt9MjvLdUBi3foR73N9Nt3NtHvf+Ub9KB1JJtpx4E3dJqA/ErurcEfuyrftuFb6beW+ViHy/5PWqNP3/vfF2lan/vx/s+1BUw/pN13b6Xl64zjC9+gHh1L5yfz5gMAAGBuU77fiX44RQN/I32oivRx6hl0m5TvnX2S7ut6Q27oid2bpOPH/yud+95/pb8beJy6tpXrDzdcpItv61OTf/6Z2gXMLL054E9ZKmnzH8bpS405jrVL7bVgAAAA84+yKdGJgQPUKjfaLKU1n2VL7wMa2PcY9f9ERkv+/iyvFTLrqTn5RYrdINJddTV9/NeX0r+MfULGzDyiXN8by9q89POzg3RCn9fFvBa0m9hvWb+ffYdu+0KCvpzIceDPBAIAwLxmZnbn8mHs0H3vf3ZT02PWOuhD9J0/f5ga+ecd747TNw6kaMLapXqN5Uadomn+e7QWIl3/cb3ppwxM9H6D/vRvhEWsy/Xzv++jP933Q61Ya2jzuvxW8cdrv0jb5ZrqO/Ttr3fTmX+WlxVTp6nz395Puwcu6gsAAADmK9GV6DMH6Lc335/7+Eu9aebdMfqLfSlK83ntH9FjvA567WfpT/4sTjFx6b2XhYK1Nhp9QV0jGqfWxC7607/opm//xTdox7176dv/U0aUhY8JBXjiW830219Q65i/nehVP8ehq6muJUmbjT8Y4cu1tdT8LV2X8yl68O4/oC2JJvp9oTxX1R+gnv/9Dp3oPUqDfm5jAAAA84YZdue+Q2e691PPeXF6bTW179lCVfov9XxsxXb6eoP6zWb60GPUOfoO0W/+ET317S20hpXUP16kgWMp+n+OjdH7X0hQ159Uy7TlYHtbB7VvqXStV37spmr68rf/c+A/qv+xFQn668NJalx7ncjnA0r//RT9SChP/mnLyt8TcYceMv5oAwAAgPlIuN+JlpH3/vEdep9PyvQ3eM3fiTZ29VHzCnHyvnZLX3UNffxXi/g9p5WP4JpfFUoVf/IPAAAWBOXbnRuSj/26UJ58zOYfsb9Gl6EYBcpY+YgDChQAABYOc1aJAgAAAHOdOevOLTtwuQIAAAgJlCgAAAAQEbhzAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEJErMgJ9DgIy/bMP6d33M/TRRxDdTHPllVfQtddcQRXXX6WvzC5o+7nBXOsXYPECJRoSHkR5/Lzu2ivliwxmFlZW77z7EbGoZ3vARNvPHeZSvwCLmwXkzp2i/uattHyd39FNIzpVsbAVgkG0fLCcWd4s95lnjDpFf+kc1UEPaPu5Q9h+MT2wl5Z3jekQ0UiXGBeM8Kwz2k3Lm1M0rYNFU0x+UylKrttL/VM6XGoK5C/bKk/Z51rbLbg10cauPjo35D0StFLHFwvPgOfWIDpGj9+5lVaL4/FUinbL87307GUdnY/LOv1XU/SWvlQu3krtlWXmZz97SJV/9SH/F4PlPRfcpwuq7ecwY3Z/EH3jq+p8dyp7xJ0r/QIsbhbhxiJlbVhWanLAeDl5hiRmQP080+H4uTRTzcnN9Ok7+P9q+vTnltKt8loJsRStz0BmD3b2EXwAv3FpTJ3cupTWfapanUdAzkqN9jTbTFkfoj0ND4WrvQUyjX3vGX01PPakIMdEYGYo3PZ2uWZIuZqTIWsi5jzTObKU4Fi3J41Tvt/Q/WHtp1ZRrAQdmtt4Q8c4UW+bx8I54xoLvB4IV98IYpmx9ZcjfbZ1ZXg9+L5kimi4mzZor5nqu2Ou/m2WL2x+2bjHQb+xLv2MUf8sy7DAOOqpf37r0cxrL/Wc15fzYrZddtuEbrsiWGRKlBurjdItB7WF2kaxjiZ3BxAd78QyHZ+s0RfnGzGK3aRPI6OtnG2nieRA7WWK0m+Ige6hg3T2pT564SEe+Mbp0W9Ft2rXfupmfRYMfjF3pBN0yvI4dMXlQOkaDHu7KX2/Ez/YccB+ofhF29ARoyP6/iOUoh4VNY/Rba+V1N3fE3JVEaVHTLC+vl8opxzc93if7Bt8HIhX6qsCLtsuMcjfkaAXdPzZl/bRPXn67K1LjftDUrF5H51qEf2zoY3OdcapQl+n3jTF+lXbc3xP0lE4sm+cXG/0rRi11udZFpKKK03tOj+VPuDgvSKh+m4t92XDayb68iFrLOpPUDqZe6nBRa78bHjpyxwHD1J7us0zwRwX78J2Hd9GjWJcbLXjA4yjgfHk1b+e0r25+5RNr+g/ltfRI+vQbVckc0qJfvf5k7T+X/9befB5FHpER3NmIO5ZyPTAUeoRHat9s/VC1lCzHFiPGwKupk2ro7ywjmvNObrF1Zmmku75pjUI1dAuOSAlRM0UflZBlrX0SjfdnRVv5bWPHvS1BtRzrcHRtixfmaB/UGcuK9Y+LIulJqEGz501dGN8nzx3DbQBWJkUL4g5KK5YQ4361Ea0d+MKfS7jxyl9iQNTNHhynOpattiDzMqkGCz0eWB0He+2lMmxNruufi7I0pKn7S35fnN7Du+EX39Vx+Oi+X37DR+2xSnu39ZNL8vzMEzRs0fEACjes0f2xOlGddGF2R9qdnKd+mjXTMxnG7ZTve5yFavXUx2l6XXZZGPU00HU/rDZtxJ0pCFFh3wVhVBKh1OiL+2281Ppx6n1mSJGAHOsqozTzgYxvg3NxIhSSfWdfdRlj4tMNbXfawm9hu4Szx48PylDwcbRgIyeEcpa1M2oZztPeAohJkTN9nu9hdprx+nEWW6bsG1XPHNKiX6r6zD99Gf/JA8+j0L2mug+u2NPnBcDXWypI1xmSZV4eYrnrdRReppPtrWpwcsc0PKSezDjgwe0orHKdCyhrJJjR7Nde5zGjm8L+VxrYGTLdIuqMysXPciaFsnZb/oPnMXguG7aQliSk5QeFt3hFnPguJlitfo0KDfF6YCol7LEBUb7F54UlKHtc2IpXXXY5RfW4X2iAS1Fpo42uk/F0n07VPuNHWoT/T1OT1l9xoend+m6uCZtk/TmK/z/OD26zahvWd3gBZi6KNSpUID17gn5jl4dn4VfXyKqWhZAGeTDM1bJ/NIXc264CY5Qmvez0mtSdcty1eanlOPo9IW0mCxUUZUOMxW36Al5HuqWmV6rSrpN3CKVfOi2K55FuCY6M9z4ufW2Ago3ALoHM+9R7Az8xvh2us+yjnJaDmIwFBYh3bSKNmrX7RsXg87ahAL9ahM9KgZGdu1aiuOtH5xWz9KD8kxgKU/HJRvBkpxVZrbtg8JWp7KkRT/ImuSwomeFqdpXlmmsmx44JixJoUD9iugo4IP0CPcn7n9+SlK6c500M2+5h0FYYpZr1jjc1to8hl2+XKf+BNXJtVOhbObFHpAglLft5pQS3ZO8nz5x/a/Jg89Lje9M7tIEDerTotAWiTVwqFl4kM0cM2mNsIJzBkDToihEsDUoR4GytRnWHVscyh2rPA9Rdl8rqzN9wRy4lUVRPmbTElW4FGiW58StQFX7Wl4HbUlaEzO5JODt75W07gvaGnvjonYDW5uhLKvWSfPyj5W7cNapXEox2+0fBL++pC22YvCMVb4WYLFUxqmLlQyvofaeCeSOLeU4Kq3O4Qma0GFGWqcFsFzLiil6XdwirdPQbVc8c0qJ/pv/eyOdfu4v5cHnpaZi8/bsBfIkr2U462JR4Z2qaiat1qme2sZXx+nNgo05k9aI5TrTSvHyRXpDBT2k6CUesMeOS4XIM7lPL+H/8zN2yLFAveW0LXMxuH59Bi0MZ+BSmyWCu3Mtl5azjjPSFeb+HNjKIgiza4lyn82pQOVar1eBMtY6rD4sd660Kr2bg6Zo6Htakdy6VFu4jtJ8+vvc6Zw0931+hiscmBpq9Gw0kmOFsNb8N/ZYfcnZtMYbjXb0OuuKSlmcpkEdL9cV1WluxFjVYz1vKkWHis3PRv2m3twINDIkJkYNawKNgwXHUa3I1BqlQJZdnWYh1zON9UqRtpV3Uhei96ix1+UAtQ5b66ph2654Fpk7t4aa9U4y5StXu8JKZea/vL/JtiIeOCYubGsrm0vOnxq6T691ScvY3mnLVoSwGuRoX01rLcuZd0wK7nucB0PHSpJ1Edj1k5tLxugl73V56M1UbJnrAdY3vmjEwPVwgshuyyZK339QvJAhNl+sSNCpljTtkPdvpUPLEpHdwdJtzifmJq3ZXOezf0KiFKG5Bikne0JJfke3H0+iHrDKrOPH+h3Xf9j2c376pCZZcp2Ylws0N8Z3O25encZvIhacbKXgRW4c4p+4BPzDK7yjlzejWH2DxwreDWpvZvHC7lG5C1Snlzt1nf0Y9kYjHd9K22VfteFNb9KtauzorRXW4WGdX303xbqKzM/G++7oXe6Bf41QaBy1Nhrp+MeIdubcLCTK0mnkVT9BmwJsLKprWU9pXfcNvJGo3/FGhW67IsGf/QvJ+UsfUOUNV+sQKBdTb39Ay5bMrtzR9nMPu18IC6bz7CpqXiBrlvbPNMzd52BOgo1FAIB5z8gzpykW6adpABQHlCgAYN6zMmm4OgEoI3DnhuTC1C/phl+7ao79DdWFDf991Lf/6UO6pfJX9JXZAW0/t5gr/QIsbmCJhoS/YcifYMIfvi4PLGeWN8t9tkHbzx3mUr8AixtYohHAh5nLB1t9c+njy2j7ucFc6xdg8QIlCgAAAEQE7lwAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiAiUKAAAABCRBfXHFvDXZEAx4K/gAADCsmCUKCtQ1p3XXXsl/kA4iIT191i5+0CRAgCCsGDcuWyBQoGCYuC+w32I+xIAAARhwShRtiJKr0DH6PE7t9Jq8zg0puNKhfOM3akpfa20vJXaq8u/l569rC/OAmOHLDl2i1rPTbgPYTkAABAUbCzKSw3teqmPzorjhYeq9bVwWIojt4J0nnEgXvqvCvPz794/TnRHgl54aR/dc5OOmCkup2h3DkVZs1PU8/G4OEvRA2VX6MaEqOQTIQDAYgVKdAHDFugDx8QJK9BvxulGdXl2qUloRTpOj24rh0U6Rc9+lZVnG71xR7SJEAAA5GLBbCw6f+kDqrzhah1yw9aYVCYG9z3eR7tq1Hl2fJyeeikhbEQHVkjSotvWRmd3qhjvNVf482do9a6UTOdFPnuJsNiEEnlZX2PMMjG5y8VWlVAKDyXo1v3d9LSONcumlEcTPfpKdr7SWvQ8u3hF6zwvi6y885RtBvFrQz+m3v6Ali3x70sAAGCy8C1RoTC+IxURKyDlNuXDGrhta40HVnFduW1T9MBXU/SWTBERtrhEfk9tU8G1Dx10P/umOB2Q4YP0yB0qjUmQcr0sFaio17EEreULx446LtLLr9JJqdCq6dNL5BWbsX6lQM0ynS3aUq2ke74p8rHKYso7K+9KWvcFZRU+/f0gtqjP2rRxPA7vLABgllj4SvSmVbRRKilehxODrms9bIqGvicsE8F9n1da9cbPrVdK4JXTNDRrm3CClquaHhFKq+ampXSrvpJNjGKeddCaz7M7lZVwk1BCs7vZKBjOurHfUS5LFgAAvCyCNVFtIYnBVlpzx9qk9TJTO2HnHmlKe5WktpLPvtRG98m1Sbbo5u6OWViiAIC5ysJXomPdtFq7QG+M79ObWoQV9uNJ8W+2W/GtH5xWa4V3rKd1QXeyvnGR3hLPkettOVDPC0oJymVb4OP05iV5RaM22ijFwxae5U72KFuWm1ZS0SYcPsrbJtvSzg8sUQDA3GRx7M59RSg4y3KRm33i9JTeWMKKVa5bagtVKUIRH2CN8Mb4dmHJCTj/XUSP+PwMpqbeWq9U+QdVSsWUS2Eo4iPZ67tP79LyuFNt8Fn70O7S/Pzlpjg9KNeBLQuXD4+VO3Zcb0CK050zrgCt3bmWDAV2W+Szvseoc91W6hzVQQAA8GFR7M5dzNg7fCPsvrXuLekOWrZw5USG13PL8LvVCGB3LgAgKIvDEl3E8B84kGvB0hoPsYlIKDtL+d5XIgXKStn2BJTjDz8AAMAMA0sUAA+wRAEAQVkwlij+5ikoBTPzN5gBAAuVBaNE+TuQ/BkrKFIQFe473Ie4LwEAQBDwUW4ANGyB4qPcAIAwLCglCgAAAJQT7M4FAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAERkASnRKepv3kqdozpoMtpNy9d104gOLhZGurbS8q4xeT49sJeWN6doWoa8jFHnur3UP6WDMpxDlvMMV72nUpR01dNDofgFzcJpcwDKCSxRsKCp2LyPznXGqUKHAQCglCxaJSotFDHzVofb+mALrnOArRJ3XL57slGWsZN+KyUHnBv8n+G5J6flaJH/GcFgC6SNemicWus9lsgQW/BW3l5LPkxZtaU7atXXL70nP21BW+SVvbQgnXtNGfhZ4OlnjLw8z3ETto7d1G+V006bL49cclFWobrH28/MOLOu6jne9ud+Zl/zyClvH84j08Xq2QHAl8yCYTLTt6c+s39EB01GnszcvvbJzGs6ePm5lszte57PXNZhb/xrT9S7wkyhe9yostz+xKgO6/vXtmT6JlU4+xnqnqbndAKBTGPk4SbgM3R8VvldjGb2G/epsLjXTu99Vtiy6vy8Mi6Qvx32ytoVVnk77e4Ou+o9+XymKV+9ZLwlh4h1dMUXysMrZ0tO/m1oxTv5ucPZbczxOi9dd0dOuu6eZ6t485zxhgEAFgvOEu1JmjNtfSRTOpYZo54OovaHDRffigQdaUjRIXO23bCGVurTwPfYVFJ9Zx+dS9boMFHF6vVUp89tzGeMHqdWSlD75kp9gWhlso0ae4/msBYCPqMIGu+36ltJdRurhQl3UVlRocuqaOxK2PVdeW+C6oZP0yCn5/yG43TErouo28MiPld+Qvbnhpy83NRQ81AfNa/QwSyqjXYUzxF1pN4z2VZV1Dquc9ojaB6OnGvorgbxX8N2qte3rFwnyqflPj1wlHpqzfxEXbviNNhxXJZftr8lU2b0jEgvrnHyyjh1ueSi2zQQhWQKwOJlwSnRxi6hWMQL7zrEQGMzdZHS2nVpKtodvTrejyj3aOTmHk5f302D+pof0xfSRMPdtMHIf7l0sxYm6DNKRbSyVlNsiT5lKpdSTMg0fUnnV1tFVTpKIuM1K7ZQe22KduhnuTe/1FBjS7UzecrrnmVidJuj04iWVImJR5pe9yjGYtrDImoedctu1mduJs6Pi+IvdSZyjCy/pnIVbaodpxNnVWVGhlJCUa5ypzfcwRs6RH6+hJUpAIuXRbomKqyR/mxl22VYDNmEu8dSbDvSCTrFafuFZaXjciKsDJnWdeyzrRIvkZ5RKkKWtTi01S2ecURYampwd9bz5OYhfj5PlnrbpEy8a4ORKEUdyywnti4HT74q11Vf7K2mTautB1nKs43SLQdlOU4JRZmLGZMpAAuMxadEDQsoMKHvUQOYVLoBd4ZW3CLsruEJmtDhwoR/RqkIX1bGIz9p3Svr1Dc/GZ/NyiQroYPCMnUsLhvp5lXKQSkSPzxW56UJYb17rFNBtDq6KUUeJlXLDJe6hSy/g+3SHTBcuYx07SqFnn+y6CGQTAFYvCxCS9RyVZm7C9UsPfdv5KLcYyoNkbaQq9VyWZqus4K7IEM+o1REKquwIA87O1NHnhFltdb+svKbov7HjHhv3lOv0olhy8rytsOUGOzHfdyYFuPU+oz1HHFvMkV1LVuy11cj1tFFKfIwqNi8nRqHu6nVtgh9yq9duq0dqWzXr6nQRTlyu3PDyhSAxcuidOeyq4o3BVlrbOzioq78GyfC3aM2fDibnI5SrL+NGsUAnmU92bDLkjedKNeZPJJER/JtoAn9jFzwhha15hvMZRe2rIrG2IS9Pihd0OZGok5hXaat/JqoNdbmbJrSm7hs2YvJQqzLcol65aDuzW1txal92VGdto16GnKljVZHN6XIw4Q3+LRRrKNJ56dcs+7yOxuGXJucvDI8XEWn2FVrbkSyKSDTIiYCACw0ruAtuvocgBmCLZvCExUAAJhvLNKNRQAAAEDxQIkCAAAAEYE7FwAAAIgILFEAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIlCiAAAAQESuyAj0OQAALBimf/Yhvft+hj76KPwQd+WVV9C111xBFddfpa8A4A+UKABgwcEKlHXndddeKRViWFjxvvPuR8S3QpGCfMCdCwBYcLAFGlWBMnwf38/5AJAPKNEyMdK1lZZ3jemQZipFyXVbKTkwpS9oRrtp+bpuGtFBUCZY7s0pmtbB6YG9rnDxTFF/s+gHos1l+8r230v9nuYPhsqrc1QHg+B5nm+fzIFbFmPUWajcsg+rumb17zLAlmRUBWrB90dxBftRSNZSvgHbggnTdt52B6UFSrRMrFwXJ0pfdA/IlyZosLaa6OSrruvTF9JEtVVUpcNggTD1Kp0YjtORoT46N5SglZVx6hraR/WVOr7MrEyKciRrdCg/FZv30bnOOFXocCFGhlJU13JQ1LOPujbPUgUXMGHajma5ny10oETLxZIqqhs+TYPGbJAHmsb7d9MmMq9P0eDJcarbuMoesOQsVc/qlweYUcpZqp3ebdG648RhzGbVbDhlWEv5rQhOnxxICatEpbWsonzl5ecnB8aMZ6h4s1zeZ7rzM+rjZ7HLWbc3jZN3TsuN0yVTRMPdtMGV5wT15JNHmPzru2mQUrTDysdlIbB11039Vl211ecvS7ZCm6h1mKgnmb+NXHJ9ZkJfVcg4o/3dbaDa1dWmskxczjbqoXFqrferr7KQd/QSDXY0ibyULDnvTpEne17c9XCe6bastLU7at0jDvv51j1WPnODnP3U5oxv2fm+DR3jRL1tLs+H2R7y8LaVFdZ93u47fBj5ZPczcT5g9lu/d8iJk/ma+QE3vLEIBOPtn/5j5i+PPisPPg/HZKZvT31m/4gOZkYz+9c+mXlNnL32RH2m6blJdVleb8n06eDl51oyt+95PnNZBTOZkSczt+v7/PCmN8P8nOy8nDLJtEZYxTtl8aLSu+MLlVeWwbhHhY36e9KrZ+QKs6xMmer4J0ZVwCuryeczTXnqI9N7ZZdPHmHzl/G50qu62GVnvPm7wt7+lI27vVX6LNnr53nlbLWLq2/Yebn7qB98v9OnrfyMuljlsevrDWt5uJ7JefiX38ubP3k/84v3Mr7HmW9zPu6j4wf+aTmfIHjlV0ie3r4k0xt1kemz3iPnflfdZT8ywlpWtvz9+pm3X+S911MW4AKWaEB++rN/om2Jh2niH6bkwed8LTiVwrqspp4ha/Z4kdLaZcuu3kHLpcvXKUa3SdfLGPV0ELU/bLjRViToSEOKDvlaH5x+XFi3TnrTDSddQKZLbsUaatSnNrUJalyhz2X8OKUv6bAfteupznYTBSxvw3bbtSTd3BSnnZbLTz4zTa/rWbOsT1eCVspIrs9uaq+18quhuxqENWbJVFvxjevYzSWsnMPC0jfuZbdWewtR6zOmxVOAnPIoUf4eVNlzIGQp3cA6mJ8xelFYg05fqKT6hxNUJ8+9aLkZdVl5b660RdCwxin76HFhScfpiO2S1OXrPeqyLp3yq7bO6jveJZJCXE7Rd47xSZyeeqmPzupjV0DPqD+F+qmmoY2a7b60RcSP04mzRrxBoHfVRTW132tVQslq8PykDmdj9gsel2w5jp6hHtHn2633UfTpnSx3kBMo0YA8+8Ip+sLnP0df+/cJefA5XwtDxS0xu7NOnz1NZLls+QUZniB2tvH1QWuwkQpVuc0c14tylfki01dTbIkO58BxO7FbroSELa9FrvVf3/pU0m1CjBZyIO09o9xRes3xLjlQTVJauzvNski3WUmY6fwFcqBV7l/OO6er2A8/2VUuFdMzP7guQdOWBt91/wDPrFt2sz6LyE2raOMdfJKiB+7cSqsPRZ/w2ATop4y77Co+n6JjZuxdzYFsl9hSR3kLqpYJJQtyAiVaTmxlyTN/ok2rLROOZ44pelEMkhPnxz0vm5hh9vNGFPcRZbOG9UJu6IjpzS1tBWa3UShdeQMhZ+hKdq4JiKaxK7ssgTdkBGBm8xfWWafK8whb3FJhz611wPlHJd3zTWV9vvCQUA7H2mi1UKa7U3NLqOV5V0EpgBINyD13b6Dvff8H9I3/2C0PPudr4dDKcoAtJstlq+DZXvqCiOutdpSrnJkXcKea5E1vuez4hQzqEgxJ2PIWwje/KXpdTJYdLJduynDlMjdTrFYY/hdmanCc6fzdSPfe0MG8LkAXfrKTFpMfXJegaUuD9Mpo74vNDD9TMtZNq7+aorfE6Y3xfXT2cV5OIHr5x/ktwrwE6qdeq1PF+1vWZXhXc2B6yyx4Yg9yAyUakE9c/2t0rPsxqvqNSnnwOV8Li1SWJ7MtporV64k6uqnHtcZYQ40t1cICMXfPqd2J/q49nf6wsZPOs4PVGfR5Z2SpXURhy1uI7PymBw7ItTR7DVWgXLrd4rrpUhNW3P1xGuw4YFhuajdovt2swZnp/AWetlPuamOSlRdvXxBle4x3B/uh1+sNOY88kyttibBc1faOU10+Y81zxnilm+5mVy4fu1LiQpye2lmM9yBYPyVjvdc33sPMvqs5kN4y8S5ZfXgqRYcKLccscqBEQ8BKs/EPtsgjigJlpLIcNi0mTeUq2iQsG+96BG8M4o051roYr42QmKHaGxQ8yPQx/pmGTp9MU3s/z2bVxg2SPzvguCZK38+Wjbkxp3jClrcQnN+plrSdn3JveWbn1qYL1wREsCIh7iVjjbaJTmw8mNu1rAeQDUFdpmHzD4velGXLsr6bYl3W7/0sxSeuu34a4uDuC6K9N+beLORtt0PLEkKm3nU+C7b+1dp39AkDu6pF/0u32bJrjbWV1NXuS03C3kzkHAlRo/xI92qen3kE6ad1LesprfvKBt6AJ99LBY8LdfwTFzlpKs+76k8NNYty2c+un6BNYoLgHZeAA/52LgDAB/YgHKVY//z8kf75Sx9Q5Q1X61B0pt7+gJYt4XyENdj1KtUljR2ziwSeQGw4v33mJzjzFFiiACx6st3Q0wNHPUsLi5zR43RimfMHUBYs3iUE6+c7+X56tciBJQoAkGtfSfkXlTS1CToV4s/8zTVKb4kuHvivIZk/S+MNTlGXYxYDUKIAgAXHhalf0g2/dlVRf4Se//j82//0Id1S+Sv6CgDZwJ0LAFhw8Ae1+XugUb/CYn1PlPMBIB+wRAEACxL+MDd/DzSKImULlhUoPsgNCgElCgAAAEQE7lwAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiAh+J1pGivnx91wl7I/SF6IMQGnBHzoA8wko0TLByoP1xnXXXlnU3/Oca1h/Ho2rVGjQW6gyAKUlTJ8CYLaBO7dMsPW1EJUH14frxfUrxEKVASgtYfoUALMNlGiZ4Nl1LuUxdmgrrb5THIdS9OxX1fnulPNtx9yM0eN8353d4qz0BC0X1yuIezafDOhyinbLuuylZ1Pd6rkB6/VWam/OshVNEeUqitl67oxi9det9HjKqN9lHW0QtE/NZ/iTY8u7StOi/OFsOy/+JmhziqZVaI6hvl3bOaqDWWTHF5JTKeUYBSjROcBvfKpa/r/2U6sodqs8LQ32QGwch4J3thkrlx83LSX1iBjFPldFa+V5abAnA/bhP3D7MoPlykuA5zr1mhnlak1OVn81RW/pa9myFArR+/AxS+lbhyXvm+nTd/D/1fTpz1n1A6A4Vib76Fxy9j4aDiU6R7l1aaU+K4JLE/Qyxempl/ro7EttdB9fO9aWPeiFoCTlCsodVfQb+jQ6U5R+Q0wEHjooZNBHLzzEE4NxevRbjmIITUnKFQH9XEu5PfBG9cwpdTEB+/r+cR3wUk2PHOM+pY5d5vjFCnRXSpQ1QS/o+LMv7aN7btLxWYhJQs64YEgrbJ2wRuSxl/o9Dgl3fDeN6OteZDrTguMPlXvyY6vHsZLGqNPOVxyFrCGZn1OOF/VlB3d+yQHjwfLebuo36+JnbbIVmhTyH+6mDXnq6i6L51naGrSf46qXKqNpKbrlxvFCZgOiHNb9djk43yZqHSbqSXqfyeSLP+OSTW5LNWSblALeWARmnjd/8n7mF+9lIhyjmY619ZnbXUdL5ujFXHHi+MrzmQtZ+Uxmjn5FxX/pu5PO9R88mX3/t0eN+4IdXL9CRJdBJnPm254yisOqx4XvtmTF8dHxA5+87Po+mTljX3dk4xyWjCMeF5/PfInz8W2LEh3WM1x1EYdfm9rp/OqqDqdfePqVUQfVDrlkY+VdpOz0EaRPZUa4rk9mXtNBb/jyc9w3coddTD6facpKW5/ZP6IvZEYz++14PjfjJjN9e+ozTc9N6rAHmbeRXpZTyOqJUX1B5efc7wnr+3OmF/mZ57fveT5zWYV88JbdDKt6OM/xhr33ajnZz1PxTtg/P/N+N9nxrz0h7hd9qk9Xz9uGMl7mr+51ZOgNzwywROcFzsz/qW0cFpZUv2eGJWf+2tp8pZu+7l0fHDtOj77CJ3F6MK6tSctq8FgWZ3fOnmskH5Y1efbxuAy/vP+4mHe6ue9xy9okenqX1805Rc8e4fpyXltI1VJc+2qTks22NkcGea2nANwUpwPHErRWtMXd0qVZxvXMmoRRj4P0iHShWnWupHu+acWJQ8vS7Bdjh9roafZgcPnlFS+i/21Trlr3OvQkvSn7mBMvjxBLCEWzIkHnhhK0UgbGqKdjnBq7rDBRxebd1F6bokNZVpCgchVtEnEvaitn4ry4tyFOPUO6/KNnqKdhjcxreuCoOG+j5hUqStxM9Q8niDqO+1p/02dP02Btghqt9KKcRxr0uUDmJ+LbN1uenhpq7orToCu/amq/13o3a+gucf/g+UkVFPl12ffmx3qWXRZ+1lCfqsvocWEJxumI7R5V9arrPZpl4eej8f44VcizSqrbKN7H9MXi1mgbtlO9rl7F6vVUR2l6vWB5RNk7+wLLJSpQonOeGrrvIbIHpQeO6csuhBLcE6cbRdo7pZIVCubH+uVibGXJrt2ESKUY+75SKLRte3EKowzU1IsBan+TGpRlXXwQSpBdizd+br0e/NOUttc+HWXJyviANZG4/CqdlAO/kGG9JZkSwYpUKiue3KToAalUyrk5yD1BsOts4ZpE6X4hrj1wzAh7qNlpKWA1YXtZtInvhi45qdMK/FjbzGz6YlZskUpxh4+bj6Yuih5QTbElOiyppNti+jQLFZe+wGUdoxd743TXvVVUpxXAyFCKGtcpqbCCpd42x23IR303DcrYbGT62FKtWBRVy9Rkj/GLpyXi2fq0lPg+SzN9IU1UW0VVOiypXEo5RTanEEpTKO/BjibVHmXaXAUlOtcRg9rdcm1KrW1aVlYh1n7qZnViDZRyUPMfGOc+Y/T4tm56WZyxpXk2p4XkxVpvc5QJ35+lTMoKK9NyKFKPhe31LrgUqGV1i3ukpa4tSS1z9mzcnbUZy2/CZm0cEnLewZO6Slr3BdVfXZO6kqKsjXPCkmLLjtfS/NZFg7JynRiET75K06yAWZmwdUrCipyaotfTQqna1ptAWKL8XPfhWL1gFpCeCNEO/cJ6luvCoj/M8LoolOgc562LYmbI6E0l//BjVqhexunkD8SocTlF39GWqtwAxLtzLQv0mzyouan5vHblFbnZaMa5fJHekCfV9Gm2KuSGKR+OnZHKaaxfD/5aZmOHHAvUtQmGuWkVbZQDf5Gbjfywd0dr96jlQp3xyQz/lCS3ApUbk7IUKONx9VqTFTkB87q3x+gl3dfsCZuhNJ/+PrfEFA19T/XX+z4/89M3uUtz6KCwTMfpxFnxPkgLapzSl3QCCStDferHijXUODxBg2dPE21cJaw1tk5FHmdfpRMx5cplpBUZwkXpl15ahBrf/EQ/z2XZFkO+slfcImxOUf8JHZZIi36eURmnLlamXWKM6z2Te4NVCYASnePcGN9ur3Py2pq9I1MovtWHlGpZe0e1dKtZloOlLN76wWmtbCxXojps1xqvnek1sad3OfHmTxrmBDfF6UFrLZgtpF1pUWcOK6vuR3wqZLBW11O5vK2JgzPYSxlZdbStQVYc2u1or1+qo6iJBStQbg97l2rpFKf90xPLUjTal8v8VuqoUNoa7ic6Tv3UZIyetnfdhl27ZOvWSs8TA9XXTMv+xvhu24W7Wity38lLqeDdqOYu1Cmh7IaradNqLlMNNbZUC+vUiZ8eOCDX/HbmXCe7mWK1KWrtGKfYLSoNK52ejm6KaVcuU7F5u1C23dRqrK1m7e41sNL3WO5mUe4dvfpckJ3fGHUmU1TXsqXklm1WWUS78m5cuRvWco/b1puIe6ybBu01SZaPsPitdWJRTl53nhsY9dCwC570OvZMgT/7VybOX/qAKm+4WocWHlNvf0DLllwtB5INJ9fTqU5rY4HDQpcBKC2qT/1U/uzhxMaDOTeI8E8cTIXU2KU3yWhkn7QH+jgdKeByVeljTjr+OUj9adrUv8/e3CKR14110NqEb7+3MdPzJqKYUJrUZvzGkX+e0UY9OlTXYtTZpwyy3q77Lax8qqndW2YLb9nZNW3n4/zUROKKE7juFfLsItpxuErXXT2bjDbwjgl2e3jz1Xjjs+rpkYUr3luvQm1SAqBEy8RiUaL5gBIFYbD7lBgYO8+uouYZ3mUJQBTgzgUAzGlGnjlNMemeBWDuASUKAJjTrEzmcEkCMAeAEi0TC/kPauf9w/IGi+GPioPSELRPATDbQImWCf7IMH8jcaEpEa4P14vrV4iFKgNQWsL0KQBmG2wsKiP8UWr+RuJCUiJsLfBgF/TjyQtRBqC0hO1TAMwmUKIAAABARODOBQAAACICJQoAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEYESBQAAACICJQoCwh/b3Uqd9tfwAQAAQIkCAAAAEYESLRtsyXVT/8BeWi4suuXNKZq2r4uwdXSNyauSqRQlxT0jo93ueHndukfE6+QKd37JgSl9fYr6m82wYqTLuObKl4+91O9ODgAAwABKtKykqPX8djo31EfnOuNUIRVeG1GXCPO1oYPUnm7zKLoU7Rhao+L7E1TX20bL6ydop5W+NkWH7PQqv3TLQZ1fG8U6mnR+lVS3sZoGT76qlTczRi/2VtOm1ZVKgdZ3U8wsS+04tT5mKXsAAABeoETLTOO6Gn1GND1wlHoa2qh5hb4gFF39wwmijuOGdVlN7ffqeypX0aZaorqWLbRSXVCK8fykDMn8ahPUvlkoRUkNNXfFaVDnV7F6PdUNn6ZBS+eOnhHpxTVOXhmnLqE8zbJw3gAAAHIDJTqLTJwfJ2LL0nShCmtwUMfnInaLpSTdyPxiS4WFa7Ckiur0qVLC43TirNKiI0MpoShXudMb7uANHSI/AAAAOYESnW2EJarcp+aR0JZmqTFduoYrV2IpT8cdfKoFligAAOQDSnQWqVomlFT6YsnWHH3zuzThsmxtl+6A4cplpGs3QaeE8uyy3cEAAADyASU6i1Rs3k6Nw93Uamwkmubdu/bO3XBk5yesy2TKWEMVaJdua0cq2/U7PEET+pRGu+HOBQCAAkCJzio11NzPG4ma7DXRDSfX0ym5czcKIj+9I1flp1yzbsvS2TBkbnKiFQk60pCiHbocyw9X0amuuFCsxkYkAAAALq7ICPQ5AAAAAEIASxQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARwafQAAAgJNM/+5DefT9DH30Ufvi88sor6NprrqCK66/SV8B8BkoUAABCwAqUded1114pFWJYWPG+8+5HxLdCkc5/4M4tEyNdW2l515gOaaZSlFy3lZIDU/qCZrSblq/rphEdBGWC5d6comkdnB7Y6wovJsLW3Z1+jDpFv+4clYGCuN8Nvncv9XteCRP5LJE/H0GfUUrYAo2qQBm+j+/nfIqnkKynqL85nJx8x6ocLOZ3xAJKtEysXBcnSl90d7ZLEzRYW0108lXX9ekLaaLaKqrSYQDmFzXUPNRHzSt0sAArk310LlmjQ4WYosGT49TYJe4J8YxSwpZkVAVqwfdHcQWXgzDtUbF5H53rjFOFDi9GoETLxZIqqhs+TYPGDHtkKEWN9++mTWReV4NE3cZVdsc0Z97LC8zSGTmTtNO7LVp3nDiMGad8TldKzlyt+Cwr2YDTJwdScibMaa3Zbr7y8vOTA2PGM1S8WS7vM935GfXxs9ilde9N4+Sdc0bO6ZIpouFu2uDKc4J68skjaP4SZTXY6bNm+wXitefCineXRVkc/vdq627ALKtHbq5n76We8/pyTvKlV3GOLNxl6xR9Jmn0C8fy4fvaqIfGqbXeT5Yc30Stw0Q9SXGPtID4Wreom+4jHmvYeqZLVlYfMduOn++Sr1c+s0m+ttUMGXWxZcD3OfJyZODJTxymfJz2KDwmyHjreVqudlvw4bVSTZmLuH7jWfMWXhMFwXj7p/+Y+cujz8qDz8MxmenbU5/ZP6KDmdHM/rVPZl4TZ689UZ9pem5SXZbXWzJ9Onj5uZbM7Xuez1xWwUxm5MnM7fo+P7zpzTA/Jzsvp0wyrRFW8U5ZvKj07vhC5ZVlMO5RYaP+nvTqGbnCLCtTpjr+iVEV8Mpq8vlMU576yPRe2eWTR6j8Vfs77ewNe+tSKN4Mq7R2vbPCKq1TN/94+1myHmZ6L4XSu8vq7nf62d4+4CpLnjbS93vl4NzPeMqXq7zWPVbYbkv1DOd+N2/+5P3ML97LFH1wPoXxtpV/25n90E/e3n5lykv1c//2KPQOyHjrWV655pC7Oy93WeYjsEQD8tOf/RNtSzxME/8wJQ8+52vBqRTWZTX1DOlZ19RFSmuXLbt6By2XLl+nGN1WyYEx6ukgan/YcJesSNCRhhQdMmaDDpx+XFi3TnrT3SLdNKbrZcUaatSnNrUJarRcZDJ+nNKXdNiP2vVUJ8vKBCxvw3aq1/dINzfFaedmfUE+M02vy+S6Pl0JWikjuT67qb3Wyq+G7moQs2xLpmKGLV1969gVJWbbh4Wlb9xLlXFqbyFqfSbEzDenPIrNv5LqO/uoS9d7euAo9TS0Ge5JEf9wgqjjuLSIZLxZFtNlOnpcWBtxOmK74NS9db1HXV4Ap1+ovmgvL4yeEdaf0QayHiI+F6HSj9GLvdVGnxBlE+UoNarNFZas2q3ysay6xDumZakQZbpX31O5ijbVEtW1bNFtqeQzeH5ShoIzRo/fuZVWu45ucbUIgrat0Q9X3iviPV4vB9XvTHdtxWrxDutzX0KNCYZc9ftpyXH6rCiT2cdXbBHvsj6fx0CJBuTZF07RFz7/Ofrav0/Ig8/5WhgqbonZAxd3KLJcttwxhydoQl8fbFijXgipUJVry3aBiGNHL0f6INNXU2yJDufAcY+y66yEhC2vRa71X9/6VNJtQowWUgn3nlGD49SrdEIMOHfJl3SS0pbbzyjLBqGUS0PY/JXyGOxoUmk9bq6J8+K+3jZXXsvru2nQjI8tdSYnBr5r6JVLxVQsGH73y76ag1DpXZNCDS9t6NOZwFdWAZ4Zu8UsZHjeSh2lp/lkWxudfalPHwmhSqITrG0974iMLzD5FdhLKEY/m0m4XeqW3axDjPtdnq9AiZYTW1myxUS0abUzU75LWGsvjvp1NDGz61ebKMzDsmDCYCnPDR0xOiLzacu2RIumdOUNhJwZK9m5JiAaawOK6wi8iaUwofIXVrmM72dLgddexQBmrgeJWXpWXkOGpQvmNDd+bj2t5ZNjbdIKfbwoE3TmsJTnjnSCTln9UceB8ECJBuSeuzfQ977/A/rGf+yWB5/ztXBoZTnAFpN7dl61rJrSF0Rcb7WjXAPOKG3ypjd3Nc7QwBy2vIXwzW+KXheTcwfLpZsyXLnMzRSrFYb/BV+fVgkoIv/KOHXx4NXlWNHc/lm7tw3yxUsrUHsybKQFGAy/+6UFlINQ6WUbWu55De9K16czga+sZviZkpvidEBanwfpkTuInt7F7ty99OxlHR+BYG3reUd8PTgW2r3OE90y76rldnG7yL3v8vwESjQgn7j+1+hY92NU9RuV8uBzvhYWqSxPZltMvC5BHd3U41pjrKHGlmrqSZo7Bb07H010+sOGq1DuhnPudwZ93qFXYndu6PIWIju/6YEDco3IXo8TKJdut7huDhyW+/SAsXakdiW6d7VGJWz+2XG8O5t0P6jYvJ0ahXXaasSbOx+t+B5bjkZ+cm0pRTtsq1bEPdYt+piz9pwXfb+9bj2VotZ8bu9Q6XmSM06tj1l9UpRN9M+ZJFuWog8mU8aa58wwdmgr7U7xMyvpnm/20VPb+Oo4vVnMpDJg2zrvfJC2N5WukE2Z3Lly7bW3zRkL5HqvPp/HQImGgJVm4x9skUcUBcpIZTlsWkwavbnBu5bDG4N4Y84Odv3Jo41IWJO5fh8n08e0q5CPZFrMOtnyVBsSyFqTW9dE6fsPyoV9Z2NO8YQtbyE4v1MtaTs/5Yr2WNLSpStwTUAEKxLiXjLWaJvoxMaDuV3L0t3Osiv8MyJJqPy98tfuNNv1W0PNop3M+A0n19Mp21pQ8Wl7DbaJWmNt+lki707RlmlrTVXFBXdb8/1tFLOeXT9Bm3JuFGLCpV+ZFGUjq0+KfreR3YeedVIbrXSFTKNPdnjTlVE+0QfTLXnavYS8vL/J3lT0wDFxYVsb7crbDMZkyJcgbSssy40TtnxbyexXekMj9xupiNUmK2ct/yjF+nlZZ5xOnI0q74CwB8Z89uEqam8gz/LV/AN/9g8AUF7494RC8e6cp+u95y99QJU3XK1D0Zl6+wNatkTkI+TReXYVNZdByc81eH320LLyTHBmCliiAIAZJNudP/IMuxvdyxmLmZFnTlPM3mS4cHH9YQZGTB4OmXtA5imwRAEAM4v116AseBdyYFfz3KPkluiigV3X6i8oKXiD075g6/ZzGChRAAAIAZQoMIE7FwAAQlCKPx5fij9iD+YGUKIAABAC/qA2fw80qiLl+/h+zgfMf+DOBQCAkPCHufl7oFEUKVugrEDxQe6FAZQoAAAAEBG4cwEAAICIQIkCAAAAEYESBQAAACICJQoAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIvidaBkp5gfac5WwPxxfiDIApQV/jADMJ6BEywQrD9Yb11175YL6m5nWnzDjKhUa9BaqDEBpCdOnAJht4M4tE2x9LUTlwfXhenH9CrFQZQBKS5g+NZ/hD1Iv7xrToeKQ3+q08uJPz5nf7ZxT8OfQ3N+XdZMdX0hOpZRjFKBEywTPrnMpj7FDW2n1neI4lKJnv6rOd6emdGw+xuhxvu/ObnFWeoKWi+sVxD2bTwZ0OUW7ZV320rOpbvXcgPV6K7U3Z9mKpohyFcVsPXdGsfrrVno8ZdTvso42CNqnAFiZ7JvV79NCic4BfuNT1fL/tZ9aRbFb5WkJcQau1YfCDcEzWy4PNy0l9YgYxT5XRWvleemwFG2uQTsnM1yunAR4rj3JmSHlasvsqyl6S19znukcj3sfPmYpfeuwZH4zffoO/r+aPv05q37FI62wdcIakcde6vfMpdzx3TSir3uR6UwLbipFSU9+bPU4VtIYddr5iqOQNSTzc8rxor7s4M4vOWA8WN7bTf1mXfysTesD6MPdtCFPXd1l8TxLW4P2c1z1UmU0LUW33DheyGxAlMO63y6H81HunqT3mUy++DMu2eS2VEO2SQmAEp2j3Lq02M+9T2nrsY3euEMpw1JQfLlCcEcV/YY+jYwe0O/+npgM6EtFU4pyRUE/11JuD7xRPXNKXVjCX98/rgNequmRY3109iV17DKNAJb3LjGI35GgF3T82Zf20T036fgsxCQhZ1wAhNLY0BGjI0PCGuGjK0at9Y7y4AHejD/VkqYdOZRLxer1VDc8QRM6PH32NA3SOKUv6QtigH6xN053rVDnnevaiLr0c4cOUnu6zUcxaFhpiXLFrPRdQlH06jiJyi/dclDn10axjiZPfilqPb/djm8UirJVx1fcEqO6ZTcTrUiIvONEtQk6NZSglTLWi3iWWRb9LKWYtCKLtek4Va9wymicWk9Wiefr+2tTtEPeX0n1nRwmahTP7trsHUvyxPemKdavynuqpVooWb825LKbMizQJqWCNxaBmefNn7yf+cV7mQjHaKZjbX3mdtfRkjl6MVecOL7yfOaCkceF77ao698eta/Zxw+ezL7fL12Bg+tXiOgyyGTOfNtTRnF86buTMs6un+fo+IGZhyUrS3bmMZk5+hXv/X7pQhwXn898ifPxtEVJD+sZa5/MnDGv+7Wpnc6vruqw5JnVr4w6qHbIJRsr7yJlp48gfSozwnV9MvOaDroZzewX5d8/ooOSyUzfnvpM03OTOmyi4qz0rz0hzp8Q+T8xqi7ws/T55edEn7OuW0w+n2nKURaZfs/zmcs6zHD+rvw88a66ybxbMn1Gsc37XfB93rwMfJ9l4SdP17OzZerOr1C8W8bZZMdn1dMjCyc+X9vOHLBE5wXOzP+pbRwep0f7PTNDOfNvo/v4/JVu+nqQ9UHLavBYFmd3zt76Qj7WPnRQle9xMdMWvLz/uJhTu7nv8T564SFleT+9K4ibky32Jnr0FXG6rc2RQV7rKQA3xenAsQStFW1xt3RplnE9syZh1OMgPSJdqCy/LVQjZvv3fNOKE4eWJVGcHoyrmf/YoTZ6WoSf4vLLK15E/9umXLXudehJepPlaMTLI+QyQihWbFGWjo+bj6YuUlr07dgSHZZU0m0xfZqFiktf4Dppq/PeKqpLX5SuypGhFDWuU+/GxHlhpfcKC810HQrrblDGZiPTx5ZShQ4zVcscD5FfPC0Rz9anpcT3WZrpC2lhxVZRlQ5LKpdSTpHNKYQle3+cBoVVLdujTJuroETnPDV030NkD0oPHNOXXQgluCdON4q0d0olKxTMjyfVSR7Gvs8KVLBte3EKowzU1CeI9jepQVkqfh+EEmTX4o2fW68H/zSlC61/Xn6VTsqBX8iwvsSTB1akUlnx5CZFD0ilUs7NQe4JwgGtJG1ck6iE6D3q2gPHjLCHmp2WAlYTtpdFm/hu6JKTOq3Aj7XNzKYvCbsAlZvvSINaS/NbFw3KynViED75Kk2zAmZlUrmKNtFpGpyaotfTlitX02C5PM0jlwsVlAV2Z3M79CeoTq4Li/4ww+uiUKJzHTGo3S3XpoRlIAYvy8oqxNpP3azPFgJj9Pi2bnpZnLGleTanheSlyPW2GYGVaTkUqcfC9noXXArUsrrFPUf4mrYktczZs3F31oYsvwmbtXFItNMOntRV0rovqP4aZFJXLHKXplyDG6cTZ4UWlRaUuabJsDLUp36sWEONwxM0ePY00cZVwlpj61TkcfZVOhFbYytIaUVqCzUIfumlRajxze+SKIc+LSX5ys5rq2SsC0ukRT/PqIxTFytTXh/uPZN7g1UJgBKd47x1UXdfvankH37svHgO43TyB2LQuJyi72hLNcgGoJrPa1eesBSydljOJS5fpDfkSTV9ml1zYnCRg7uXY2ekchrr14N/kA1AN62ijXLgF4rjW84u1JJg/0xFu0ctF+pL/lZe6eAd2bkVqNyYlKVAGY+r15qsSKvS694eo5d0X3MmbI7SfPr73BJTNPQ91V/v+/wM1Zh3o5obhaaEshuupk2ruf/XUKNnE8r0wAFqHY7TzqxNLRY3U6w2Ra0d4xS7RaVhpdPT0U0x7cplKjZvd23sYbJ29xpY6Xssd7Mo9w5jY1F2fmPUmUxRXcuWklu2WWUR7cS7ceUGHMs9bltvIu6xbhps2E71UhwsH2HxD1nxY0I2fmPSbGDUQ8MueGpwJj8zAf5iUZk4f+kDqrzhah0KAw+IPAhr7qimta+MKyWx7Y/ovmN/JXffviyuWfDa4QGhH21LJAse0B33XZZ7lAfNb7IlEZyptz+gZUuuVrshT66nU53xrDWX6DIQxTxkurKFDO4QMpB1i9N/eihNX+Hdt5ZcJLqOfvXTKDnxyGBYbQZs9bp2noaBFShbchFkWQhWgso7kQ2X+b6LueJZaW6nN4VitfuTiVfhZtUhW06ODC2CpAmG6lM/lbtFT2w86LObU8E/cTAVEu/sbDbcrmqHriWPOB0p4HJ1dvTqdHJn7Wna1L9PKxKN3nFrW4u8I9an39uY6UXa9phQmtRm/MZR7dDt0aG6FqPOPmWQ9Xbdb2HlU03t3jJbeMvOrmk7H71Dd1gHXXEC171Cnl1EOw5X6bqrZ/OuZasNvGOC3R7efDXe+Kx6emThivfWq1CblAAo0TJRjAKZD1hKNB8LXQagtNh9SgyMnWdXUXNO6xGA2QPuXADAnGbkmdMUk+5ZAOYeUKIAgDnNymQOlyQAcwAoUQAAACAiUKJlYiH/Qe28f1jeAH9UHAQlaJ8CYLaBEi0T/JFh/kbiQlMiXB+uF9evEAtVBqC0hOlTAMw22J1bRvij1PyNxIWkRNha4MEu6MeTF6IMQGkJ26cAmE2gRAEAAICIwJ0LAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAAAARARKFASEv1i/lTpHdRAAAACUKAAAABAVKNGywZZcN/UP7KXlwqJb3pyiafu6CFtH15i8KplKUVLcMzLa7Y6X1617RLxOrnDnlxyY0tenqL/ZDCtGuoxrrnz52Ev97uQAAAAMoETLSopaz2+nc0N9dK4zThVS4bURdYkwXxs6SO3pNo+iS9GOoTUqvj9Bdb1ttLx+gnZa6WtTdMhOr/JLtxzU+bVRrKNJ51dJdRurafDkq1p5M2P0Ym81bVpdqRRofTfFzLLUjlPrY5ayBwAA4AVKtMw0rqvRZ0TTA0epp6GNmlfoC0LR1T+cIOo4bliX1dR+r76nchVtqiWqa9lCK9UFpRjPT8qQzK82Qe2bhVKU1FBzV5wGdX4Vq9dT3fBpGrR07ugZkV5c4+SVceoSytMsC+cNAAAgN1Cis8jE+XEitixNF6qwBgd1fC5it1hK0o3ML7ZUWLgGS6qoTp8qJTxOJ84qLToylBKKcpU7veEO3tAh8gMAAJATKNHZRliiyn1qHgltaZYa06VruHIllvJ03MGnWmCJAgBAPqBEZ5GqZUJJpS+WbM3RN79LEy7L1nbpDhiuXEa6dhN0SijPLtsdDAAAIB9QorNIxebt1DjcTa3GRqJp3r1r79wNR3Z+wrpMpow1VIF26bZ2pLJdv8MTNKFPabQb7lwAACgAlOisUkPN/byRqMleE91wcj2dkjt3oyDy0ztyVX7KNeu2LJ0NQ+YmJ1qRoCMNKdqhy7H8cBWd6ooLxWpsRAIAAODiioxAnwMAAAAgBLBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBEoUQAAACAiUKIAAABARKBEAQAAgIhAiQIAAAARgRIFAAAAIgIlCgAAAEQEShQAAACICJQoAAAAEBF8Cg0AsCCZ/tmH9O77Gfroo/BD3JVXXkHXXnMFVVx/lb4CgD9QogCABQcrUNad1117pVSIYWHF+867HxHfCkUK8gF3bpkY6dpKy7vGdEgzlaLkuq2UHJjSFzSj3bR8XTeN6CAoEyz35hRN6+D0wF5XuHimqL9Z9APR5rJ9ZfvvpX5P8wdD5dU5qoNB8DzPt0/mwC2LMeosVG7Zh1Vds/p3GWALNKoCZfg+vp/zKQWFZC3lG7AtmDBt5213UFqgRMvEynVxovRF94B8aYIGa6uJTr7quj59IU1UW0VVOgwWCFOv0onhOB0Z6qNzQwlaWRmnrqF9VF+p48vMyqQoR7JGh/JTsXkfneuMU4UOF2JkKEV1LQdFPfuoa3P5K8iWZFQFasH3R3EFl4MwbUez3M8WOlCi5WJJFdUNn6ZBYzbIA03j/btpE5nXp2jw5DjVbVxlD1hylqpn9csDzCjlLNVO77Zo3XHiMGazajacMqyl/FYEp08OpIRVotJaVlG+8vLzkwNjxjNUvFku7zPd+Rn18bPY5azbm8bJO6flxumSKaLhbtrgynOCevLJI0z+9d00SCnaYeXjshDYuuumfquu2urzlyVboU3UOkzUk8zfRi65PjOhrypknNH+7jZQ7epqU1kmLmcb9dA4tdb71VdZyDt6iQY7mkReSpacd6fIkz0v7no4z3RbVtraHbXuEYf9fOseK5+QXE7R7ju30uo7u0VupSNnP7U541t2vm9DxzhRb5vL82G2hzy8bWWFdZ+3+w4fRj7Z/UycD5j91u8dcuJkvmZ+wA2viYJgvP3Tf8z85dFn5cHn4ZjM9O2pz+wf0cHMaGb/2iczr4mz156ozzQ9N6kuy+stmT4dvPxcS+b2Pc9nLqtgJjPyZOZ2fZ8f3vRmmJ+TnZdTJpnWCKt4pyxeVHp3fKHyyjIY96iwUX9PevWMXGGWlSlTHf/EqAp4ZTX5fKYpT31keq/s8skjbP4yPld6VRe77Iw3f1fY25+ycbe3Sp8le/08r5ytdnH1DTsvdx/1g+93+rSVn1EXqzx2fb1hLQ/XMzkP//J7efMn72d+8V7G/7j4fOZLMq8nM2f84o2D8wmCV36F5OntSzK9UReZPus9cu531V32I1MWSla2/P36mbdf5L3XUxbgApZoQH76s3+ibYmHaeIfpuTB53wtOJXCuqymniFr9niR0tply67eQculy9cpRrdJ18sY9XQQtT9suNFWJOhIQ4oO+VofnH5cWLdOetMNJ11ApktuxRpq1Kc2tQlqXKHPZfw4pS/psB+166nOdhMFLG/Ddtu1JN3cFKedlstPPjNNr+tZs6xPV4JWykiuz25qr7Xyq6G7GoQ1ZslUW/GN69jNJaycw8LSN+5lt1Z7C1HrMyHsj5zyKFH+HlTZcyBkKd3AOpifMXpRWINOX6ik+ocTVCfPvWi5GXVZeW+utEXQsMYp++hxYUnH6YjtktTl6z3qsi6d8qu2zuo73iWSvEzRs18VFui2bnpZhlP0gLRIxfHVFL0lr0WhUD/VNLRRs92Xtoj4cTpx1og3CPSuuqim9nstWSpZDZ6f1OFszH7B45Itx9Ez1CP6fLv1Poo+vZPlDnICJRqQZ184RV/4/Ofoa/8+IQ8+52thqLglZnfW6bOniSyXLb8gwxPEzja+PmgNNlKhKreZ43pRrjJfZPpqii3R4Rw4bid2y5WQsOW1yLX+61ufSrpNiNFCDqS9Z5Q7Sq853iUHqklKa3enWRbpNisJM52/QA60yv3Leed0FfvhJ7vKpWJ65gfXJWja0uC77h/gmXXLbtZnUaike77ZR2ePJWitDMfpqZdEmI9vxulGeS0CAfop4y67is+n6JgZe1dzINslttRR3oKqZULJgpxAiZYTW1nyzJ9o02rLhOOZY4peFIPkxPlxz8smZpj9vBHFfUTZrGG9kBs6YnpzS1uB2W0USlfeQMgZupKdawKiaezKLkvgDRkBmNn8hXXWqfI8wha3VNgR1wHBvKI87yooBVCiAbnn7g30ve//gL7xH7vlwed8LRxaWQ6wxWS5bBU820tfEHG91Y5ylTPzAu5Uk7zpLZcdv5BBXYIhCVveQvjmN0Wvi8myg+XSTRmuXOZmitUKw//CTGmcmc7fjXTvDR3M6wJ04Sc7aTH5wXUJmrY0SK+M9r7YzPAzZ4xA/dRrdap4f8u6DO9qDkxvmQVP7EFuoEQD8onrf42OdT9GVb9RKQ8+52thkcryZLbFVLF6PVFHN/W41hhrqLGlWlgg5u45tTvR37Wn0x82dtJ5drA6gz7vjCy1iyhseQuRnd/0wAG5lmavoQqUS7dbXDddasKKuz9Ogx0HDMtN7QbNt5s1ODOdv8DTdspdbUyy8uLtC6Jsj/HuYD/0er0h55FncqUtEZar2t5xqstnrHnOPGlKX9anRRGsn5Kx3usb72Fm39UcSG+ZeJesPjyVokOFlmMWOVCiIWCl2fgHW+QRRYEyUlkOmxaTpnIVbRKWjXc9gjcG8cYca12M10ZIzFDtDQoeZPoY/0xDp0+mqb2fZ7Nq4wbJnx1wXBOl72fLxtyYUzxhy1sIzu9US9rOT7m3PLNza9OFawIiWJEQ95KxRttEJzYezO1a1gPIhqAu07D5h0VvyrJlWd9NsS7r936W4hPXXT8NcXD3BdHeG3NvFvK226FlCSFT7zqfBVv/au07+oSBXdWi/6XbbNm1xtpK6mrPyU1xenAbn4zTo9v0xqICP3eR7tU8P/MI0k/rWtZTWveVDbwBT76XCh4X6vgnLnLSVJ531Z8aahblsp9dP0GbxATBOy4BB/zZPwCAD+xBOEqx/vn5I/3zlz6gyhuu1qHoTL39AS1bwvkIa7DrVapLGjtmFwk8gdhwfnt5JjjzEFiiACx6st3Q0wNHPUsLi5zR43RimfMHUBYs3iUE6+c7+X56tciBJQoAkGtfSfkXlTS1CToV4s/8zTVKb4kuHvivIZk/S+MNTlGXYxYDUKIAgAXHhalf0g2/dlVRfz+X/27u2//0Id1S+Sv6CgDZwJ0LAFhw8LdA+VNmUf+AvPUpNM4HgHzAEgUALEjwUW5QDqBEAQAAgIjAnQsAAABEBEoUAAAAiAiUKAAAABARKFEAAAAgIlCiAAAAQESgRAEAAICIQIkCAAAAEcHvRMtIMT/+nq+E/dH6YpQRCAf+EAKYS0CJlglWDqwXrrv2yqL+nud8w/rzaVzlQoPeYpURCEeYPgXATAN3bplg62oxKgeuL9eb61+IxSojEI4wfQqAmQZKtEzw7DmXchg7pL+ufyhFz35Vne9OOd92nJuM0eNcZnE8nkrRbnm+l569rKMNuN5B3LMzIyOrnN3irNwEl1Fpma3nFsdbqb2yzKu/KtrYbm//Vgvap0AA+BuizSma1sFs+APte6nfet34s3lm2Euh+AUGlOgc4Dc+VS3/X/upVRS7VZ6WmClfxWMrJuN43DNm2QObfVjK6Gb69B38fzV9+nNLaUaKbTDTMnJk4VG2Y91G3dURfIJTXhk5lOO5hqK2BeZccw7v5MXpi/ahFeWNS2Pyf7p1Ka3T7Q3mIZVx6hraR/WL5IPuUKJzlFuXlq4HvpU6QI++ogNZVNMjx/ro7Evq2GV8wJ4V6N37x4m2tdnxZ19KUO5v3McodpM+LQOlkJE1SXjgjWpaq6+ZvHUxTXRHgl7guh9LyDQv7z9QhFVXXhk5lPa5Y4fa6Gl9noUlr6z+wgq0SfbF+x634sWxM3ePWvupm/VZdPgj08vXWUc3jejriinqbzbiu9wq30GlSw44E6jpgb0eC44tNid/GW8/t7BllrecbC3myMu/HFupc1SFZHxXylVPux6cbzJFNNxNG7Jkw3BebdRD49Ra7+TJpJ8x6mc+32OJhpXDvIM3FoGZ582fvJ/5xXuZ8McPnszcvrbe53gyc+a9yczRr/jF1We+9N1J3/vt6+I4822+1pI5etF4nn2MZjrkPfwcv/hwB9e/EJFlZJfVPKx6+cWJ4yvPZy6YeVx8PvMlGZevvk5eHT9wris5ug8zvjSH09bF5V2oz+SQlzis5174bovvdfter2ytw+qL3x7NjotwBOlTl58TZd3zfOayb3gy07dHlOeJURnKDruR93rTiv7ymr6SGRH10/He58o4M62HvOWU97Zk+iZlVFY461mZ0cx+Ief9Iyok442wb36u+71wfkb6yeczTdyOtizU85qe0wlkvE7vrbc3vACAJTrXqUk4M/aXDtIj0k0nZugPbREz/Eq655vGjP7xuIqkOD0YZyttjB7fJWaZwpJ84aFc7rFxenSbcqu53JSXL9Ib8iRFDxiut7m7VutY1E9t47CoV7/HqpAWUhvdx+evdNPXQ9blrdRRZX2JfO7TxhO7gR84pq451pfboi8Oy/3JFpyqY3F5F+ozNbTLqIfdb6w6X07R1/ePi/53UMvZByHbu2V/ca/DSqueOdZm96dyr9VWbN5H5zrjVMGB0ePUOhynI0lLoJVU/3CC6nqP+lpLFavXi7gz2lqbpLS4t7EhRS9q62xkKEWN6zivMerpIGp/WD+HWZGgIyLtIcOSdeD049R4v5PeKaewgA+nqK5lt+MelXkJy/CZXFazD7UJalyhz1esoUbxfqQv6XAkqqn9XktuNXRXA9Hg+UkdzoMo+7mhBK3UwYUAlOi8wXGFsVI8IAc8A167Y4UplYlyoUmXGw/uOdxlNTutwVIplpf3N/krSenOddJ4101nnxq67yGyJwNSqWUh5LInTjeKtHfqwf/lHwd46TW2a5vl+U3Ohxmjl/Sz7tthXSsV1vqiozzPvrSP7imlK9inz5jYdRYK9ilZZ9EHv9VNL/v1P4mhgKVy5gmav5KU7lw7zcxt+qrYvJ0apasy25U4fUEo9doqqtJhSeVS0iuz2ci4NL3OeYyeoZ4GoYyWVVP6Al8Yoxd743QXK6qpiyKVcn86bsyttKOXM/FBpq+m2BIddsHKmih2i1veVeK584IVW6i9NkU7tAxMd/BCAUp0XuBWoFlrSK7BUA+0wmL4Dg/w2ipQg6FSgrz78S0ZsvBRLDdZG1JEnvX8PCfNGxf9ZtOziKi/Pdib1lMBgq63udaGbQU6k3B7m2uOM7CO6tdnDFwK1FrXHDuu+qC2JK3JytO7hLL37qKtWaMsfqFM3tQWj71xyLJq7TRpSs+YNVpDzUN9wvo5KAZzS7H5rf0FgS2ucTpxdkoq4LplN0vrlE6+StOsCIVSdSwsYan183PdR9dmv8nHQkZY952q7keEtdqTZPkvrHVRKNE5D1skuRWo3BjjNxjeFKcDllVgKBZ2w2UrAseichSLpTTH6eQP1ExbpammjZ+bWwOB7Sa8o4p+Q/z3Dz9WEwY3uh7W5EIQaGOSpaB9LXpnYvH0rlJaU6bLlT0Alku9NK7PnH1Gwy7qLAXKuJYWLLe5tiqzJnZn9CSgmj5tWViW0nzlNA1xPaw0d6yndaWeJGRhDeZt1CjkyS7YiluEUh+eoAmdQiKtwtysXBenwfOv0uBJok2rRf9h61TkMXj2NMWkK1cgLdYQ7tK86W+mWK2YZkhr12HivF8fn9usTLL81WSGJyILBSjROY69DsdkrSWN0dNysGOctU155Ph9nYO11saHsnpYwZpuupqdjgvXSnPf4yV2KZaAG+Pb9eCsrG57py3L65Ba2V17R7Wqx7ZuepnDoq68tigVCstAXzfXgNltPfZ9VjYCe53PiWPYJa6UyUytHVsuUl4PV21cnDu9QJ8xJhmh6yTuVb9JFYevkhZ1sV24VhrLVTwzZO1cZTeseKZ0u1quRntH7hT1P9ZNgw3bc/88Y0kV1fV2U+twjG6TaVjJpai1I6bylNRQY0u1sLpMi9e9Y9aNTn/YLCfvxuX7hfK/XyjujgOO9SbidvQ6a5JqMnCaBnX89MBRUcc5gl0PzdSrdGK4Wk1AFgj4s39l4vylD6jyhqt1aPEx9fYHtGzJ38vt8tTVR832gOOw2GUEwiH71NRf0fIk0ZGcm1X4pylNQunpoFDs7f3mbxg98Q1tdM7eaOSHTh9z0rGi3nByPZ2yNixp+Ccr5jpoY45+b+FO7ymn9VMUibcO7nvrWtpo08k2St+vnpddPvWzFec9tH7Gkp2vhZV/XctB6lr9KiXrT9MmI62MJy0T/omLER9WDvMNKNEyASXKSjR//aFEQRisPjXS1U2UXFg7PsH8Ae5cAMD8RVg9h8jc0ANAeYESBQDMX/hPzOV1vwIws0CJlonF/Aez8/1heRP8UXEQlKB9CoCZBkq0TPBHhPkbiItNSXB9ud5c/0IsVhmBcITpUwDMNNhYVEb4o9P8DcTFpCTYWuDBLujHkxejjEA4wvYpAGYSKFEAAAAgInDnAgAAABGBEgUAAAAiAiUKAAAARARKFAAAAIgIlCgAAAAQEShRAAAAICJQogAAAEBEoEQBAACAiECJAgAAABGBEgUAAAAiAiUKAsJfv99KnaM6CAAAAEoUAAAAiAqUaNlgS66b+gf20nJh0S1vTtG0fV2EraNrTF6VTKUoKe4ZGe12x8vr1j0iXidXuPNLDkzp61PU32yGFSNdxjVXvnzspX53cgAAAAZQomUlRa3nt9O5oT461xmnCqnw2oi6RJivDR2k9nSbR9GlaMfQGhXfn6C63jZaXj9BO630tSn6/7d3vrFRXWf+f5L+ulJUqeo2jkExhGbywi/A5kVCsBbjhQikjJASyURisRFrpaMiz5uwixPVbGVZbhdXwbsilTIIZdp1UTFCiq0miplIIKDGqUwIUmzzYv0ikxJwi42TdittqzbbzO8858+959658+96ZvDg70e68j33nHv+POfc+5znOcdzTznpVX7p3pM6v36KDHbr/OqpbWcjTVy+oZU3M0sXRhpp15Z6pUDbkxSx69IyR32vG2UPAADAD5RolelqbdJnREvjZ2m4o596mvUFoejaX4sRDb5rWZeNNPCSvqf+adrVQtTW+wJtVheUYry1IEMyv5YYDewRSlHSRD2JKE3o/Oq2bKe2qas0YXTuzDWRXlzj5PVRSgjladeF8wYAAJAbKNH7yPytOSK2LG0XqrAGJ3R8LiLrjZL0IvOLrBMWrsXaBmrTp0oJz9HF60qLTk+mhKJ82pvecgfvGBT5AQAAyAmU6P1GWKLKfWofMW1plhvbpWu5ciVGebru4Cu9sEQBACAfUKL3kYYNQkml75RtzTEwv7vzHsvWcemOW65cRrp2Y3RFKM+E4w4GAACQDyjR+0jdnv3UNZWkPmsj0RLv3nV27pZGdn7CuoynrDVUgXbp9g2msl2/U/M0r09pJgl3LgAAFABK9L7SRD1jvJGo21kT3XF5O12RO3fDIPLTO3JVfso167Us3Q1D9iYnao7RmY4Udep6bDrdQFcSUaFYrY1IAAAAPDyUEehzAAAAAJQALFEAAAAgJFCiAAAAQEigRAEAAICQQIkCAAAAIYESBQAAAEICJQoAAACEBEoUAAAACAmUKAAAABASKFEAAAAgJFCiAAAAQEigRAEAAICQQIkCAAAAIYESBQAAAEKCr7gAAECJLP3hb/Tnv2boq69Kf30+/PBD9MjfPUR13/qavgJqGShRAAAoAVagrDu/8cjDUiGWCive//3zV8S3QpHWPnDnAgBACbAFGlaBMnwf38/5gNoHSrRKTCf20qbErA5pFlMUb91L8fFFfUEzk6RNrUma1kFQJVjuPSla0sGl8aOe8Gqi1LZ708/SkBjXQzMyUBDvs8H3HqUx3yNhI8sS+fNRbBnlhC3JsArUwPeHcQVnU0jWizTWU5qcAt9VOVjNz4gBSrRKbG6NEqXveAfb3XmaaGkkunzDc33pdpqopYEadBiA2qKJeiZHqadZBwuwOT5KN+NNOlSIRZq4PEddCXFPCWVUi89TR2nLc3tpy6nilNBKpJT+qNtzjG4ORalOh1cjUKLVYm0DtU1dpQlrhj09maKug4dpF9nX1UuibefTzsC0Z96bCszSGTmTdNJ7LVpvnDisGacsJ5GSM1cTn2UlW3D6+HhKzoQ5rZnt5qsvlx8fn7XKUPF2vfxlevOz2hNksUvr3p/GzTvnjJzTxVNEU0na4clznobzyaPY/CXKanDSZ832C8Rrz4WJ99ZFWRzB92rrbtyuq09unrKP0vAtfTkn+dKrOFcW3roNiTETt8aFa/nwff00THPU1x4kS47vpr4pouG4uEdaQHwtKdqmx4jPGjZlemRlxojdd1y+R75++dxP8vWtZtJqiyMDvs+VlysDX37isOXj9kfhd4KMN+VpuTp9wYffSrVlLuLGrLJqFt5YBIrji9//T+a/zr4jDz4vjYXM6JH2zPFpHczMZI5veyvzsTj7+M32TPd7C+qyvN6bGdXBe+/1ZjYeOZ+5p4KZzPRbmY36viD86e0wl5Odl1snmdYKq3i3Ln5Uem98ofrKOlj3qLDVfl96VUauMMvKlqmOf3NGBfyyWjif6c7THpneL7t88igpf9X/bj/7w/62FIq3wyqt0+6ssErrti043ilLtsNO76dQem9dveNOl+0fA5665Okjfb9fDu79jK9+uepr7jFhpy9VGe79Xn7zu79m/vSXjPe4cz7zPZlH9vG9Xy5kpxcH51MYf18F9509DoPk7R9XtrzUOA/uj0LPgIw3ZfnlmkPu3ry8dalFYIkWye//8EfaF3uN5n+7KA8+52vFUy+sy0YantSzrsU7lNYuW3b1ThiXLl+nCD1Vz4FZGh4kGnjNcpc0x+hMR4pOWbNBF04/J6xbN73tbpFuGtv10ryVuvSpQ0uMuoyLTMbPUfquDgfRsp3aZF2ZIuvbsZ/a9T3SzU1ROrRHX5BlpukTmVy3JxGjzTKS23OYBlpMfk20u0PMso1MxQxbuvpa2RUlZtunhaVv3Uv1URroJep7u4SZb055LDf/emofGqWEbvfS+Fka7ui33JMi/rUY0eC70iKS8XZdbJfpzLvC2ojSGccFp+5tGznr8QK440KNRWd5YeaasP6sPpDtEPG5KCn9LF0YabTGhKibqEe5UX2uMLIaMPVjWSXEM6ZlqRB1eknfU/807Wohaut9Qfelks/ErQUZKorHonTi0ii9/6qWw75+ui7CfJyImnqEoNi+tcbh5pdEvM/r5aLGne2urdsinmF9HkhJ7wRLrvr5NHJcui7qZI/x5hfEs6zPaxgo0SJ55/0r9I//8Az927/G5MHnfK0U6tZHnBcXDygyLlsemFPzNK+vT3RsVQ+EVKjKteW4QMTROcKRAcj0jRRZq8M5cN2j7DorI6XW15Br/TewPfX0lBCjQSrhkWvq5bh4gy6KF85u+ZAuUNq4/ay67BBKuTyUmr9SHhOD3Sqtz801f0vcN9LvyWtTe5Im7PjIOndyYhG4hl6/TkzFiiPofjlWc1BSes+kUMNLG/q0EgTKqogyI+uXoewqRHF963tGZHyBya/AWUKxxlkl4X5p27BGhxjvs1yrQIlWE0dZssVEtGuLO1PeLay1CzNBA03M7MbUJgr7MBZMKRjluWMwQmdkPv3ZluiyKV99i0LOjJXsPBMQjdmA4jmK3sRSmJLyF1a5jB9jS4HXXsULzF4PErP0rLwmLUsXgDJglGdnOkZXzHjUcaB0oESL5MXnd9Cvfv0R/ft/JuXB53ytNLSyHGeLyTs7b9jQSOnbIm6k0VWuRc4oHfKmt3c1VujFXGp9CxGY3yJ9IibnLsalm7JcucwairQIw/92oE+rDCwj//ooJfjllXCtaO7/rN3bFvnipRWoPRkO0gIsjqD7pQWUg5LSyz407nkN70rXp5UgUFYVLjOLT+/Q5/p0ORTXt75nJNCDY9DudZ7oVnlXLfeL10Xuf5ZrEyjRIvn7b32TziVfp4bH6+XB53ytVKSyvJxtMfG6BA0madizxthEXb2NNBy3dwr6dz7a6PSnLVeh3A3n3u++9HmHXpnduSXXtxDZ+S2Nn5BrRM56nEC5dJPiuv3iMO7TE9bakdqV6N3VGpZS88+O493ZpMdB3Z791CWs0z4r3t75aOKHHTla+cm1pRR1OlatiHs9KcaYu/acF32/s269mKK+fG7vktLzJGeO+l43Y1LUTYzPSpItSzEG4ylrzbNyPBrdTwf45MMkPc//6rLcf3cpsm/dZ76YvreVrpBNldy5cu11pN99F8j1Xn1ew0CJlgArza5/ekEeYRQoI5XllG0xafTmBv9aDm8M4o05nez6k0c/kbAmc/1/nEwf0a5CPuJpMetky1NtSCCzJtfaTemDJ+XCvrsxZ/mUWt9CcH5XetNOfsoV7bOkpUtX4JmACJpj4l6y1mi76eLOk7ldy9LdzrIr/G9EkpLy98tfu9Mc128T9Yh+suN3XN5OVxxrQcWnnTXYbuqL9OuyRN5Doi/TZk1VxRXvtub7+yliym6fp105NwoxpaXfHBd1IzMmxbjbye5D3zqpg1a6QqbhJzu86cqqnxiD6d48/V5WmugVvaHIOQ7l6wdrMhRIMX0rLMud8458+8geV3pDI48bqYjVJit3Lf8sRcZ4WWeOLl4PK+8iYQ+MXfbpBhroIN/yVe2B384FAFQX/n9CoXgP1eh67627X1L9t7+uQ+FZ/OJL2rBW5CPkMXT9aeqpipJfWfD67KkN1ZrgVAZYogCACpLtzp9+m92N3uWM1cz021cp4mwyfHDx/DADIyYPp+w9IDUKLFEAQGUxvwZl4F3IRbuaVx5lt0RXDey6Vr+gpOANTseKW7dfwUCJAgBACdxe/D/69je/tqwfoecfn//ij3+j9fX/T18BtQrcuQAAUAL8QW3+HmjYr7CY74lyPqD2gSUKAAAlwh/m5u+BhlGkbMGyAsUHuR8MoEQBAACAkMCdCwAAAIQEShQAAAAICZQoAAAAEBIoUQAAACAkUKIAAABASKBEAQAAgJBAiQIAAAAhwf+JVpHl/IN2rVLqP5avRhmB0sCPFYCVBJRolWDlwHrhG488vKzf3Kw1zE+ccZMLvfRWq4xAaZQypgCoNHDnVgm2rlajcuD2cru5/YVYrTICpVHKmKpZ+JurxX4cviD8OTo3L/lJMvmB7hUIf/HH/lxaDQAlWiV49pxLOcye2ktbnhPHqRS98311fjhV4a/ML5tZeoPrLI43Uik6LM+P0jv3dLQFt7sY92xlZGTqmRRn1aZ4GZWX+1Xu8vg8dVTWecv3RR87/R3ca8WOKQAqDZToCuDxJxrl321PPE2RJ+WpD/elmOulEgZHMVnHG77snRebcxhltIa+8yz/baTvPLOOAqtdRgrLaHm4svAp29mk1XZ1FD/Bqa6MXAqX6/ZrOZWrNU6dwz95WXQmQc6hx/Sj6yLyLz25jlp1f5eD6cRe2tRqjiRN6+sK/salFZ/TQlPp4uNu32d9ZFq0dMjKX8Y75Ra2Ku16xt+e11ddvPl528H3xsdT8gPoJo39IXQD57FjcI5opD+vxZdXZmwtOnHedgXLxK2LjE+kPDJ3ZGq+OzuVpB1Z/bRygRJdoTy5jr9Ua144/fTps+V7qXhppB+cG6Xrl9TxivWtZH7RPn9cPHD7+p3465dilPtzyhGKPKZPq4CS0fIwyuTlTxtpm75m8/mdNNGzMXqf234uJtN8cPzEMhRPdWXkosvVk4LnfyUmJCqi/Bh5ZY0XHs/d9KMPiQ68YeLFcSj3iNr2xBp9Fg5+aXemY3RlcpRuiuNKb5o6nZe8/kh0pF/G3Zw8SQNpoVwCFWk9te1spIlbCzq8SBOXxbMxNU+Oupu5RsMdW2mzOJXK6vJ2p9ybiQj1tedWDKy03HqepF3pFE3oOEYpvwid0fnJdvgUzcTgVYqMmfhGGo6b+DUUaYnQU+JxqdtzTMbJD6MPRalOxnvJKzOp6NI0oMtR7SrR7TySpPRBc39U1PuEur85JsPUwmXHpBxrAt5YBCrPb37318yf/pIJfdz+ZW9m47b2zMafzFjXFzJn/0Vc4+u+43u/XMj86aO3AuM2bnsrc03cf+0nfN6bOXvHW5Y6ZjKDVtrs+NIObn8hwsvI1NU+TLuC4sTxL+czt+087pzPfE/G5Wuvm9fgR+51JUfvYceXfpRX9sGHKcPf/znkJQ5ukzMO/YeUp77XL1tzmPHoGcPhj2LG1L33RH2PnM/c02EP01yftzIf66Bk4XymW8hkdEGHbWScST+TOS7Oj7/Znjk+LS9kPnbOOS47D47vfi8oY07v5iPx1CMgPrOQGT3i5sd5b3xzRp5L8rRDysRO6yGoLIO3TINddra8vfkVipd9kqu/ViiwRGuaenrxx9aM/g0xi5NE6btRMe1sirlxl07SD6SLT8zuX33Bsg7m6Ef7lFvN46a8d4c+lScpetm43fxpVhSuRf2zfRwW7RrzWRTSQuqnA3z+YZJ+WGJbPk+dpV/wicjngBYgu4FfPqeuudaX16IvnSZ6RdbTyL6a65lcttuO91/VHhDd5kejx5y460aWggOdUXpUn7Nsnw+ot7TqmXP9zniqdNvq9uynLukeDHA93hb1aWmgBh2W1K8TNnsOZFyaPuE8tNXZtaGR0rf5wixdGInS7mZxunhHpJoTFprrsuSjc4QzCUCmb6TIWh1m7HoExYtn/6mcFV0GgWUZFig9RRRZ7/UANQgZrGagRB8U2E33SkqcsDLxu1xdNxq7Zk+wghU0HfK+DD843h2sJKU7103jXze9/zTRgVfJmQxIpZaFkMsRftE30XNSyYq2fGZcc4VxXNusLH9sFMYsXdJleZRIWTDKjCc/ZqJT3c1BTpvFpOxnTpsNvP7ZLycV2149qScNlgKWEzqud3CdpTvXSVPJTV9N1CPdkidpoMUotrDrbU20u2OOLl5flAq4bcMaqtuynejyDVpi5aNduYpG1+VpHYk9y1+CACsLKNEHAY8CPUYvetbcvAo0eP0pQLE8ZjakiDzb+R43zad3SrPgKo5ov/OyFy9wx3oqQLHrbZ614SxlUk1yK6Vy41GgWevgXgVqJmUemrZqK3WOfnNXnrgbh4wl76RJU7ribaqn9iFWZP3UJSz8CzPCSl0v6mOvaTLSEsvN5tYoTdy6QROXiXZtEe1mi1HkMXH9KkVatZSkFTlHad3uggSlt+sRmN8ifZKvomHJW3deWxW9JS1vl/lbPE5WL1CiNY7cGJNTgfLLrpACZVyLylUsRmnO0eWPlLtKpWmknc+srNm04yZ8toEeF39++1nQQ63bcS9FP9VtLWpjklHQbIFmyc+dWPzilXJbU2anK/cf96228C75+7j8sIs6pwIV8jtcSIEys9eU61uMl+8Y16BRmh9epUlWmibNs9uptUJtkrtB7d2i7IYV7ZJu1+YXhHWaok5nI9Eijb2epImO/dSea2isbaC2kST1TamNOkqxpKhvMKLylDRRl2djD+PdpepFpz9tbXjieshzJju/pfETog5ROlR2y9ZfF4Hcjctli4nIQWsjkI7rHBFW90tqlKiJyVWa0PFL42eFvB9s8ItFVeLW3S+p/ttf16FisazILPgFt5Uu6RdaFkJpvv/EWf0y9MMv5cNE/+HNO/ul6FocBnbDhVnvW/ziS9qw9r/Fi6SfKDFKPc4LxyWcjBhfPZ9tpG0fztEHfL7vn+nAuZ/L3c0fiGsG01bX4sqG2/rcr4Pdw7YcnHVRi7wKpiCmPUFW4DJxvBbZyDo/c4MO70sq2fng+O9+1p3DXS7qeq6Bfuq5N2Bil1V++DbKMbX4c9oUJzqTczen3oE7pYOiTgNjxywl6YvnXavxfLWxdvTqdM5OXN9uV7nj1loH7cox7g12+q7eGKUHr9Iuq65qh64Zq1FPm+W9ZNWdf6yh3Xu/g4xjJe3Nw8Zbd5/MzL+iSPzy9N7b1ttPuy73y9243PZsWfHkwn4nqPBwQL4rFSjRKhFeQTwYKCWav/2rXUagNMyYmk4kieI19C8R4IEC7lwAQO0irKpTZG/oAaC6QIkCAGqX+igl8rpfAagsUKIAAABASKBEq8Rq/sHsfD8sb4MfFQfFUuyYAqDSQIlWCf6IMH8DcbUpCW4vt5vbX4jVKiNQGqWMKQAqDXbnVhH+6DR/A3E1KQm2FvhlV+zHk1ejjEBplDqmAKgkUKIAAABASODOBQAAAEICJQoAAACEBEoUAAAACAmUKAAAABASKFEAAAAgJFCiAAAAQEigRAEAAICQQIkCAAAAIYESBQAAAEICJVo1+Iv4e2loRgflF9ztsJ9C8Q8u/PX7TT0pWtJhAABYqUCJrliaqGdylHqadRAAAMCKA0q0KrAV2k19U0TD8b0UH1/U1wWTSdokLE51JGlaX862RFXYSZuY1dcDWExRXFhyYwlf2hm7LK+VK60/kW7a3KPj5XVzj79MT35Hacw0S1632yLgOlnX7HIC8wYAgFqAf4AeVIOFzOiR9szxaR3MzGSOb2vPbDxyPnNPhlX8xjdnZMjEq/Qqrvu9BRmTHfaxcD7TLe71xE+/ldm47a3Mxzqo0vRmRnWSe+/1ini3fibs1MeXXuWXK2zXXSHz03l9/KbdboG811e2HQ8AACsUWKL3ma6DUaqTZ/XUtrORKH2niLXAemofGqXEnnodDqKRdm0x8cISPp2irkSMNusrVB+lgV6ivrctC7AlRl3afVy3ZTu1iTwGXmpSF+qfpl0tc5S+ywGVX1vvYWo3RTTH6EzHnM6viXZ3CKt70uS9SBOX56irVeW1OT5KN4dMuwXNW6lLnwIAQC0BJVoTCKUplO3EYLdyfZa86WaB0tqVbLtQdwzO6fhcROipQD2t8ous90Y2bBCTAM3m1ijRyDXlvl28QRenorTbt77ruor7aVhfAwCAWgJKtFYQlt7NSWHBjcWobSpJO1j5lLiO2JUQ93Me9hHXlma5kdZlii7wuur1qzTRsdWxgo3y3DEYoTOyHv2wRAEANQmUaK1RH6UEK56EZekVZA1FWojSt60NTcsiOL/5W7Zla1y6KY8r13HtSoVuuZcBAKAGgRKtCdT/mNq7eqeFciLLusuPcQefcHfQBuRZPAH5zSSpc8RaQxUol26S+qYaKbJWX9S4CpjrAXcuAKA2gRKtGmrjkFyXLPnfOYTSei1GZNZExdGZjtGVUlyxzSI9byRqV/dvau2miztPFticlAd2Lycibn7xNA2MHXM3GjFmw1DLdmpzrvvb0k3pgydpQFi27kYkAACoDR7iLbr6HAAAAAAlAEsUAAAACAmUKAAAABASKFEAAAAgJFCiAAAAQEigRAEAAICQQIkCAAAAIYESBQAAAEICJQoAAACEBEoUAAAACAmUKAAAABASKFEAAAAgJFCiAAAAQEigRAEAAICQQIkCAAAAIcGn0AAAq4alP/yN/vzXDH31VemvvYcffoge+buHqO5bX9NXAIASBQCsEliBsu78xiMPS4VYKqx4//fPXxHfCkUKDHDnVonpxF7alJjVIc1iiuKteyk+vqgvaGaStKk1SdM6CKoEy70nRUs6uDR+1BNeNr78Vf8fpTFf9zsUig8gcJzlwdvGWRoS43FoRgYK4inL37YAZFkifz6KLaOcsAUaVoEyfB/fz/ksn0KyXqSxnlLktIy+A8sCSrRKbG6NEqXveF8yd+dpoqWR6PINz/Wl22milgZq0GGwSqmPUmLyGLXX63DFaaKeyVHqadbBAmyOj9LNeJMOFWKRJi7PUVdC3FNCGeWELcmwCtTA94dxBVeeSvYdyAeUaLVY20BtU1dpwrIqpidT1HXwMO0i+7p62bTtfJrq9BV7Br+pCMtEzjKd9F6L1hsnDms2KstJpOQM2MRnWckWnD4+npIzYE5rZsH56svlx8dnrTJUvF0vf5ne/Kz2BFns0nrzp3HzzjlT53TxFNFUknZ48pyn4XzyWHb+Ym71ttW+nJYqWxpJGjOyMOm0N0Pdn6QLfC0vymJR6Y/S8C19WeK3ZpQ1ZOo2JPratowdayZP2xScbzf1TRENx8U9XHeut/g7ZvrdGYd2/XzyNn1ry5zv88kgu/zCfJ46Slue20tbTpXTOvPKL9Dym7Ta4vQ93+fKy5GBp5182M+Wt+/Uc+Y+m3zYY9PpO0bL1RlbfNjjkLFlbvotqD2rEV4TBcXxxe//J/NfZ9+RB5+XxkJm9Eh75vi0DmZmMse3vZX5WJx9/GZ7pvu9BXVZXu/NjOrgvfd6MxuPnM/cU8FMZvqtzEZ9XxD+9HaYy8nOy62TTGuFVbxbFz8qvTe+UH1lHax7VNhqvy+9KiNXmGVly1THvzmjAn5ZLZzPdOdpj0zvl10+eSwzf5VetN/UV7fHkYUnPxXnphXo+73186XxEJS/SO/UyStP73hR4zer72xZ223Lwjf+ddnuuGd89ctVX1OmCTt9oMrw5unym9/9NfOnv2QCj9u/VH298SczgfH2wfkURsvL6Qt/WPenNX6C5O2XlxM2+eXrO6uv/M+Rp+/8cs0hd6fsguNsdQFLtEh+/4c/0r7YazT/20V58DlfK556YV020vCkmf3dobR22bKrd8K4dPk6Regp6cKbpeFBooHXoo5VSs0xOtORolNmduqB088J69ZNX7fnGN0cUmHpwtHnkuat1KVPHVpi1GVcQjJ+jtJ3dTiIlu3U5rgbi6xvx37HRSnd3BSlQ3v0BVlmmj6RyXV7EjHaLCO5PYdpoMXk10S7O8Rs3cjUuAxb2U0lZvOnhaVv3cvu0YFeor63S5hB55RHmfKnRhp4ybjVVHsmbi3ocDaqbYql61dpwlM/lrU+D2LmGg3bspb1bVTnWczShRFRN6cv66ldjKvy0ki7tjiDh5bGz9KwaM+AqR+7KBPi2Rh817IuLXnVP027Wojael/QfaCesXzyy+Jeig4LC/T543MqfK5fWaTiOJwKesaKZOZdYUlG6YzjMhXyey1GbSNnPZ4Ze/xsfknE+7xVDtK1b7trVVvzYj1ndVvEc+o8V0HkHodynHX0u2U3vyCeQX0O4M4tlnfev0L/+A/P0L/9a0wefM7XSqFufcRZF+WBScZlyy/nqXma19cnOraqB0sq1Dnqa9duFH10jnBkADJ9I0XW6nAOXPdov3iplpFS62vItf4b2J56ekqI0SCV8Mg19ZJdvEEXxYtrt3zYFyht3IdWXXYIpVweKp1/YeZvibIi69wJi6BhQ+4Xa9BauxyTQXgmcxpektCnlSCoPcWUGVlvV7JEHovSiUuj9P6rWm77+um6CPNxIho+38B9DfXrhERtfGNbxheYtIrJjXHRVmuscb+0bVijQ4z3GVztQIlWE0dZssVE1iycZ34pujATNGDFDHFMbcawj4QzWy8eozx3DEbojMynP9sSXTblq29RSOtQyc4zAdGYjSyeo4wbKiqdPwAKozz7Kd17Uo6zKzm9CKCaQIkWyYvP76Bf/foj+vf/TMqDz/laaWhlOc4Wk3eWzxZE+raIG7FcXEXNTC3yprd3R1ouyHJSan0LEZjfIn0iJvkuxqWbsly5zBqKtAjD//YyXHJ5qXT+hZFWp2/Ht7TmciCtTu3xMEiLKQgpe5/7j3eT69NKENSeSpdZKYJkrax7G9/YzudJYld8S4yuCOVZsQlpDrhfvC5y/zO4uoESLZK//9Y36VzydWp4vF4efM7XSkUqy8vZFhOvWdBgUjwo9hpjE3WJ2eZw3N5x6N2F50WnP23trJO76tz73Zc+7wAsszu35PoWIju/pfETcq3JWdcTKJduUly3X0BqDW9i8IS1BqV2S+bbcVw8lc6/MHV79lPXlBgzRrair/O6zuValrU+vZiivpwuQZ6czFHf69aOUTGuKolpT58jPzF24ilrzbMKfHqHPteny0LLutPZwSrk93pSPPfuOiXjPqvB8R5spSz6ulruXLmeOtLvPsNyvVefAyjRUmCl2fVPL8gjjAJlpLKcsi0mjd4k4V8T4o1BvDGnU7pylDuHhDWZ6//BZPoI/6uBTh9P08AYW55qYwMNdut8uil98KTcIOBuzFk+pda3EJzfld60k59yRfssaenSFXgmIIJmMXPnjT7OGm03Xdx5MvdMXrrbWXbef8vJSaXzL0gT9Yi+TZt12dMNNJBvYxGPgaF+ipgx0D5Pu/K4BDfHxfggM5bEeNkZozZhn3rWSQ1laRv/r6NVP+26rIbl9Wh0Px3gkw+T9LzeWJT/310KTQ5Z1kJ+6X7dlm7qi/T7XP2NNLBz3pFvH4nxZG1EkhsRuW9ZEesNes5zJfr6SkJMHnNtRConvKlJlOWs/+tx5l12Wr3gZ/8AAMXB/08oFO+hSi0HVJhbd7+k+m9/XYfCs/jFl7RhrchHWINDQvGFnSDWMvx/pqc2VGeCs9KBJQoACCDb0pp+m92N3mWI1Qu7t0nvBH+wkRsS7R9fEJOpU/bejVUOLFEAQDC8ns6/RGTo8Lsja4uyW6KrBl7rV7+gpOAd+NX8OcqVDZQoAGBVACUKKgHcuQCAVUE5fjy+HD9iDx4soEQBAKsC/qA2fw80rCLl+/h+zgcAA9y5AIBVA3+Ym78HGkaRsgXKChQf5AY2UKIAAABASODOBQAAAEICJQoAAACEBEoUAAAACAmUKAAAABASKFEAAAAgJFCiAAAAQEigRAEAAICQ4P9Eq8hy/tG7Vin1H9RXo4xAaeBHD8BKAkq0SrByYL3wjUceXlW/vWl+Ko2bXOilt1plBEqjlDEFQKWBO7dKsHW1GpUDt5fbze0vxGqVESiNUsZUzcIfQG89SmOLOrws+Nuwbl7y+6CJWRVYafDn9+xvl9YAUKJVgmfPuZTD7Km9tOU5cZxK0TvfV+eHU2V5eirILL3BdRbHG6kUHZbnR+mdezragttdjHu2MjIy9UyKs2pTvIzKy/0qd3l8njoq67zl+6KPnf4O7rVixxQAlQZKdAXw+BON8u+2J56myJPy1If7Usz1Ulke1kvXl73zYnMOo4zW0Hee5b+N9J1n1lFgtctIYRktD0dJ+5XtbNJquzqKn+BUV0Yuhct1+7VCytWRm3/ysuhMgpxDj+lH10XkX3pyHbXq/i4H04m9tKnVHEma1tcV/MFpKz6nhabSxcfdvpcWncdqYovPzV/GO+UWtirtesbfntdXXbz5edvB98bHU6J8N4+hGR1pwXnsGJwjGunPa/HllRlbi06ct13BMnHrIuMTKY/MHZmaj8BPJWlHVj+tXKBEVyhPruPPxpsXTj99+mz5Xip+Zk/10y/0uQ2/aJ8/Lh64ff10/dKoPmLUpOOziVDkMX1aBZSMlodRJi9/2kjb9DWbz++kiZ6N0fvc9nMxmeaD4yeWoXiqKyMXXa5Wbs//SkxIVEQFEJOyV8TLMAsez930ow+JDrxhxpM4DuUeUdueWKPPwsEv7c50jK5MjtJNcVzpTVOn85JnxdhNfZF+GXdz8iQNpIVyCVSk9dS2s5Embi3o8CJNXBbPxtQ8Oepu5hoNd2ylzeJUKqvL251ybyYi1NeeWzGw0nLreZJ2pVM0oeMYpfwidEbnJ9vhUzQTg1cpMmbiG2k4buLXUKQlQk+Jx6VuzzEZRx2izUNRqpPxXvLKTCq6NA3oclS7SnQ7jyQpfdDcHxX1PqHub47JMLVw2TEpx1oAG4uqxHK/qu9RaM5Lx30p+dn26kk6se5d2hL4MovSz7QydPLV8MvtFZk9W6esXN20y2Hxiy9pw9r87Q8vI1NXm0b6wblj9OJjQXECVow/jtKjOkj3UnR4X5I+yNteNy9XTuKqsGJfPqfODXZ86ZRX9sGYMoyc9OVAWSq4TQfueMeLgyNP/5i02sAKnMejZwyHp5gx5SizIIUhFQIJxWS9sHktsv0q7Ro7Ru3+OZqMm6dDMj1bWNeEMhLtaR2lnmalCC/Ic447KxSaNw+OP7XhJCX2+DPm9P1ECZWPxFOPgHg9Abi4U+UnlTAJxRjXcs3TDimTW/vdtB6CyjJ4yzTYZWfL25tfoXjZJ6cbgvtrhQJLtKappxd/bM3o3xCzOEmUvhsVg7wp5sZdOkk/kC4+VrAvqJeaUBw/FC9EVrg/2yejXO7doU/lSYpetlxvK3etlpWBaqtqyxz9aMxnUUiLsp8O8PmHSfphiW35PHVWKReRzwH9/nEUqLFW9RFegTJN9Iqsp5F9NdczuWy3He+/qj0gus2PRo85cdeNLAUHOtWE5PPUCaFAuS/cOIO06hkRZ8ZTpdtWt2c/dUn3YIDr8baoT0sDNeiwpH6dsNlzIOPS9Annoa3Org2NlL7NF2bpwkiUdrMiWLwjUs0JC811WfLROcKZBCDTN1JkrQ4zdj2C4sWz/1TOii6DwLIMC5SeIoqs92rlBiGD1QyU6IOCmeVLZeK3XizrQFgBJ1jB8rX/EJaXE86DdOeql+IHx7uz1k3vP0104FWiH+1TL2a/VagQcjnCL/omek5PGD74zLjmCuNY7I7FxczSJV2WUSLlwygznvyICYFsW3U3B7leCmFN2la7xLVYeRImJw16UnbgDduyDUa6c+Wkj9tWyU1fTdQj3ZInaaDFKLaw621NtLtjji5eX5QKuG3DGqrbsp3o8g1aYuWjXbmKRtflaR3ZViiodaBEHwQ8CtT/AvMqUMeNNvuuuqatAqN4fvGKeFnzRo/HzIYUkWc73+Mqn0/vrDBrVLTfednb1lMBil1v87jSs5RJNWGFUx1F6lGgWS5lrwI1k7DZMXaH6zHkuISVNc0TL2fjkLHkm7ZqazVN6Yq3qZ7ah1iR9VOXqNOFGWGlrhf1sdc0GWmJ5WZza5Qmbt2gictEu7aIdrPFKPKYuH6VIq1aStKKnKP0XRUsSFB6ux6B+S3SJ/kqGpa8dee1VdFb0vJ2mb/F42T1AiVa4/DLLrcC5ZddgAJlPK5e4wLVFoJMZ5TmHF3+SLmrlNXVSDufWVmzacdN+GwDPS7+/PazoIdat0NYSz/VE4aiNiYZBc0WaNY6njux+MUr5bamuO9YGXH/cd+avips5S0XdlHnVKC8dhygQJmmQ+54cl29amIjLVWjND+8SpOsNGevaff4dmqtUJt4Dc6zW5TdsKJO0u3a/IKwTlPU6WwkWqSx15M00bE/ez3UsLaB2kaS1DelNuooxZKivsGIylPSRF2ejT0Mr/0F75h10p+2NjxxPeQ5k53f0vgJUYcoHSq7Zeuvi0DuxuWyxUTkoLURSMd1jgir+yU1StTE5CpN6Pil8bNC3g822FhUJcJtmsm9cUi9nLbSpRybQFhpvv/EWf0y9JOtcM3anndDTPYmk7AbZtQmkP/Os2mhjBuLnm2kbR/OSauI9v0zHTj3c7m7+QNxzWAUgGtxZcNtfe7Xwe5hWw5BG4v8CqY0THuCrMBl4ngtspF1fuaG3mCVDcd/97PuHO5yf11ztCGr/PBtlGNq8efZm4M86B24Uzooxv6AZ7ONL553rQZuuDHo9LyjV6fLtXlJbrix1kG7cox7g52+qzdG6UHvxiBZDv97iiTqaXMpG4tUHCtpbx423rr7ZCY3ZJk+9MvTe29bbz/tutwvd+MWtbFIh4cD8l2pQIlWieXuzq11Krs7F6xGzJiaTiSJ4rmUKACVBe5cAEDtIqyqU2Rv6AGgukCJAgBql/ooJfK6XwGoLFCiVWI1/9Znvt/EtcHvoYJiKXZMAVBpoESrBH//kD/ftNqUBLeX283tL8RqlREojVLGFACVBhuLqgg+yl0YfJQbFKLUMQVAJYESBQAAAEICdy4AAAAQEihRAAAAICRQogAAAEBIoEQBAACAkECJAgAAACGBEgUAAABCAiUKAAAAhARKFAAAAAgJlCgAAAAQEihRAAAAICRQolWDv4i/l4ZmdFB+wd0O+ykU/+DCX7/f1JOiJR0GAICVCpToiqWJeiZHqadZBwEAAKw4oESrAluh3dQ3RTQc30vx8UV9XTCZpE3C4lRHkqb15WxLVIWdtIlZfT2AxRTFhSU3lvClnbHL8lq50voT6abNPTpeXjf3+Mv05HeUxkyz5HW7LQKuk3XNLicwbwAAqAX4Ky6gGixkRo+0Z45P62BmJnN8W3tm45HzmXsyrOI3vjkjQyZepVdx3e8tyJjssI+F85luca8nfvqtzMZtb2U+1kGVpjczqpPce69XxLv1M2GnPr70Kr9cYbvuCpmfzuvjN+12C+S9vrLteAAAWKHAEr3PdB2MUp08q6e2nY1E6TtFrAXWU/vQKCX21OtwEI20a4uJF5bw6RR1JWK0WV+h+igN9BL1vW1ZgC0x6tLu47ot26lN5DHwUpO6UP807WqZo/RdDqj82noPU7spojlGZzrmdH5NtLtDWN2TJu9Fmrg8R12tKq/N8VG6OWTaLWjeSl36FAAAagko0ZpAKE2hbCcGu5Xrs+RNNwuU1q5k24W6Y3BOx+ciQk8F6mmVX2S9N7Jhg5gEaDa3RolGrin37eINujgVpd2+9V3XVdxPw/oaAADUElCitYKw9G5OCgtuLEZtU0nawcqnxHXEroS4n/Owj7i2NMuNtC5TdIHXVa9fpYmOrY4VbJTnjsEInZH16IclCgCoSaBEa436KCVY8SQsS68gayjSQpS+bW1oWhbB+c3fsi1b49JNeVy5jmtXKnTLvQwAADUIlGhNoP7H1N7VOy2UE1nWXX6MO/iEu4M2IM/iCchvJkmdI9YaqkC5dJPUN9VIkbX6osZVwFwPuHMBALUJlGjVUBuH5Lpkyf/OIZTWazEisyYqjs50jK6U4optFul5I1G7un9Tazdd3HmywOakPLB7ORFx84unaWDsmLvRiDEbhlq2U5tz3d+WbkofPEkDwrJ1NyIBAEBt8BBv0dXnAAAAACgBWKIAAABAKIj+P2/dXcAhXz1WAAAAAElFTkSuQmCC)"
      ],
      "metadata": {
        "id": "y_R3uIpslBAx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def solution(s, t):\n",
        "    res = 0\n",
        "    \n",
        "    for i in range(len(s)):\n",
        "        if s[i].isdigit():\n",
        "            temp = s[0:i] + s[i + 1:]\n",
        "            \n",
        "            if temp < t:\n",
        "                res += 1\n",
        "                \n",
        "    for i in range(len(t)):\n",
        "        if t[i].isdigit():\n",
        "            temp = t[0:i] + t[i + 1:]\n",
        "            \n",
        "            if s < temp:\n",
        "                res += 1\n",
        "    \n",
        "    return res"
      ],
      "metadata": {
        "id": "vS0JrHv9lBGh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**From Codesignal**\n",
        "1. Use log10(n), not log(n,10)\n",
        "2. Math formula is faster than iteration"
      ],
      "metadata": {
        "id": "El-jsShRCivR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "Ds_7iYZfCixs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def solution(a):\n",
        "    multiplier = 0\n",
        "    length = 0\n",
        "    total = 0\n",
        "    \n",
        "    for n in a:\n",
        "        length += 1\n",
        "        # check number of digits in a\n",
        "        digit = math.floor(math.log10(n))\n",
        "\n",
        "        multiplier += 10 ** (digit + 1)\n",
        "        total += n\n",
        "    \n",
        "    return (total) * (length + multiplier)\n"
      ],
      "metadata": {
        "id": "uQK2orrZlq-X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-29**\n",
        "**26. Remove Duplicates from Sorted Array**\n",
        "1. This is so fucking weird, but might be useful\n",
        "2. uses two pointers, don't delete anything, simply adding new element behind"
      ],
      "metadata": {
        "id": "3BcPksUCC4W_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def removeDuplicates(self, nums: List[int]) -> int:\n",
        "        k = 0\n",
        "        prev = nums[0]\n",
        "        i = 1\n",
        "        j = 1\n",
        "        while i < len(nums):\n",
        "            print(nums[i])\n",
        "            if nums[i] == prev:\n",
        "                k += 1\n",
        "            else:\n",
        "                prev = nums[i]\n",
        "                nums[j] = nums[i]\n",
        "                j += 1\n",
        "            i += 1\n",
        "\n",
        "        return (len(nums) - k)"
      ],
      "metadata": {
        "id": "EQfqyHA6C4ca"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**415. Add Strings**\n",
        "1. 两个技巧：从头插入列表用insert(0,c)；反转列表或者字符串都用[::-1]\n",
        "2. 使用ord()-ord('0')来获得当前字符串的值\n",
        "3. ''.join()可以用来串接所有列表中字符串"
      ],
      "metadata": {
        "id": "hrLxVkeotOGR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def addStrings(self, num1: str, num2: str) -> str:\n",
        "        res = []\n",
        "\n",
        "        i,j = len(num1) - 1, len(num2) - 1\n",
        "        carry = 0\n",
        "\n",
        "        while i >= 0 or j >= 0:\n",
        "            print(i,j)\n",
        "            curr = 0\n",
        "            if i >= 0:\n",
        "                curr += (ord(num1[i]) - ord('0'))\n",
        "            if j >= 0:\n",
        "                curr += (ord(num2[j]) - ord('0'))\n",
        "\n",
        "            curr += carry\n",
        "            carry = curr // 10\n",
        "            curr = curr % 10\n",
        "\n",
        "            res.insert(0, str(curr))\n",
        "            i -= 1\n",
        "            j -= 1\n",
        "\n",
        "        if carry == 1:\n",
        "            res.insert(0, str(carry))\n",
        "\n",
        "        return ''.join(res)\n"
      ],
      "metadata": {
        "id": "nXFmOCI4uGyf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-01-30**\n",
        "**17. Letter Combinations of a Phone Number**\n",
        "1. Exactly the same as subsets, using backtracking"
      ],
      "metadata": {
        "id": "_GjoAM4E-rkC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def letterCombinations(self, digits: str) -> List[str]:\n",
        "        num_to_letter = {'2':'abc','3':'def','4':'ghi','5':'jkl','6':'mno','7':'pqrs','8':'tuv','9':'wxyz'}\n",
        "        self.res = []\n",
        "        self.curr = ''\n",
        "\n",
        "        # backtracking\n",
        "        def dfs(s):\n",
        "\n",
        "            if len(s) == 0:\n",
        "                self.res.append(self.curr)\n",
        "                return\n",
        "            \n",
        "            n = s[0]\n",
        "\n",
        "            if n in num_to_letter:\n",
        "                for c in num_to_letter[n]:\n",
        "                    self.curr += c\n",
        "                    dfs(s[1:])\n",
        "                    self.curr = self.curr[0:len(self.curr) - 1]\n",
        "        \n",
        "        if not digits:\n",
        "            return []\n",
        "\n",
        "        dfs(digits)\n",
        "\n",
        "        return self.res"
      ],
      "metadata": {
        "id": "E9nDeG8X-rph"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-02-05**\n",
        "**73. Set Matrix Zeroes**\n",
        "1. This is so fucking miserable, bitch"
      ],
      "metadata": {
        "id": "GyZA-qDMCWjA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def setZeroes(self, matrix: List[List[int]]) -> None:\n",
        "        \"\"\"\n",
        "        Do not return anything, modify matrix in-place instead.\n",
        "        \"\"\"\n",
        "        # You can use O(mn) by copying the matrix, O(m+n) by using 2 lists, O(1) by \n",
        "        \n",
        "        # first loop through the matrix to get locations of 0s\n",
        "        # get first row and check if there's 0\n",
        "        first_row = False\n",
        "\n",
        "        for i in range(0, len(matrix)):\n",
        "            for j in range(0, len(matrix[0])):\n",
        "                if matrix[i][j] == 0:\n",
        "                    if i == 0:\n",
        "                        first_row = True\n",
        "                        matrix[0][j] = 0\n",
        "                    else:\n",
        "                        matrix[0][j] = 0\n",
        "                        matrix[i][0] = 0\n",
        "\n",
        "        # print(matrix, first_row)\n",
        "\n",
        "        # then loop though it again to modify the rows\n",
        "        for i in range(1, len(matrix)):\n",
        "            if matrix[i][0] == 0:   \n",
        "                for j in range(len(matrix[0])):\n",
        "                    matrix[i][j] = 0\n",
        "\n",
        "        # print(matrix)\n",
        "\n",
        "        # then loop through it again to modify the columns\n",
        "        for j in range(len(matrix[0])):\n",
        "            if matrix[0][j] == 0:        \n",
        "                for i in range(len(matrix)):\n",
        "                    matrix[i][j] = 0\n",
        "        \n",
        "        # print(matrix)\n",
        "        \n",
        "        # check first row\n",
        "        if first_row:\n",
        "            for j in range(len(matrix[0])):\n",
        "                matrix[0][j] = 0\n"
      ],
      "metadata": {
        "id": "EF6aFZIeCWpd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2023-02-07**\n",
        "**27. Remove Element**\n",
        "1. I don't know what trick this is, but it looks legit."
      ],
      "metadata": {
        "id": "q77wqhDNaJ4E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def removeElement(self, nums: List[int], val: int) -> int:\n",
        "        i = 0\n",
        "        for n in nums:\n",
        "            if n != val:\n",
        "                nums[i] = n\n",
        "                i += 1\n",
        "        \n",
        "        return i"
      ],
      "metadata": {
        "id": "dowGpB6QaJ_L"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}