"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Assignment 1: Uninformed Search\n",
"\n",
"* *A1.1: First paragraph is changed. It no longer mentions a requirement of applying your search functions to a puzzle of your choice.*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Type your name here*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Breadth-first and depth-first are two algorithms for performing\n",
"uninformed search---a search that does not use\n",
"knowledge about the goal of the search. You will implement both\n",
"search algorithms in python and test them on a simple graph. Then you\n",
"will apply your search algorithms to the grid navigation problem that you modify\n",
"as explained below."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Required Code"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this jupyter notebook, you must implement at least the following functions. The first function, `search`, implements the algorithm shown at the end of Lecture Notes `03 Problem-Solving Agents`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`solution_path = search(start_state, goal_state, successors_f, breadth_first)`\n",
"* `start_state`: single state where search starts\n",
"* `goal_state`: signle state that represents the goal\n",
"* `successors_f`: function that accepts a single argument that is a state and returns a list of states that can be reached in one step from the argument state\n",
"* `breadth_first`: `True` or `False`. If `True`, `search` performs a breadth-first search. Otherwise it performs a depth-first search.\n",
"* `solution_path`: returned value that is either \n",
" * a list of states that shows the path found from the start state to the goal state, or \n",
" * the string `'Goal not found'` if the search has searched everywhere without finding the goal state."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The next two functions are very short, and just call `search`. These are really just convenience functions so the user of your search algorithm does not need to know what the boolean-valued argument `breadth_first` means."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`solution_path = breadth_first_search(start_state, goal_state, successors_f)`\n",
"* `start_state`: single state where search starts\n",
"* `goal_state`: signle state that represents the goal\n",
"* `successors_f`: function that accepts a single argument that is a state and returns a list of states that can be reached in one step from the argument state\n",
"* `solution_path`: returned value that is either \n",
" * a list of states that shows the path found from the start state to the goal state, or \n",
" * the string `'Goal not found'` if the search has searched everywhere without finding the goal state."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"`solution_path = depth_first_search(start_state, goal_state, successors_f)`\n",
"* `start_state`: single state where search starts\n",
"* `goal_state`: signle state that represents the goal\n",
"* `successors_f`: function that accepts a single argument that is a state and returns a list of states that can be reached in one step from the argument state\n",
"* `solution_path`: returned value that is either \n",
" * a list of states that shows the path found from the start state to the goal state, or \n",
" * the string `'Goal not found'` if the search has searched everywhere without finding the goal state."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"Each receives as arguments the starting state, the goal state, and a successors function. If they succeed in finding the goal state, `breadth_first_search` returns the breadth-first solution path as a list of states starting with the `start_state` and ending with the `goal_state`. `depth_first_search` returns the depth-first solution path. If they do not success, they return the string `'Goal not found'`.\n",
"\n",
"Test your code by running them with a simple graph as shown in the following example, and with the grid example. \n",
"\n",
"Test your code on other graphs, too. The final grading script will include graphs not shown here."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def search(start_state, goal_state, successors_f, breadth_first):\n",
" .\n",
" .\n",
" ."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def breadth_first_search(start_state, goal_state, successors_f):\n",
" .\n",
" .\n",
" ."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def depth_first_search(start_state, goal_state, successors_f):\n",
" .\n",
" .\n",
" ."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Example 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here is a simple example. States are defined by lower case letters. A dictionary stores a list of successor states for each state in the graph that has successors."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"lines_to_next_cell": 1
},
"outputs": [
{
"data": {
"text/plain": [
"{'a': ['b', 'c', 'd'],\n",
" 'b': ['e', 'f', 'g'],\n",
" 'c': ['a', 'h', 'i'],\n",
" 'd': ['j', 'z'],\n",
" 'e': ['a', 'k', 'l'],\n",
" 'g': ['m'],\n",
" 'k': ['z']}"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"successors = {'a': ['b', 'c', 'd'],\n",
" 'b': ['e', 'f', 'g'],\n",
" 'c': ['a', 'h', 'i'],\n",
" 'd': ['j', 'z'],\n",
" 'e': ['a', 'k', 'l'], # Watch out. This creates the cycle a -> b -> e-> a\n",
" 'g': ['m'],\n",
" 'k': ['z']}\n",
"successors"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here is an example of a successors function that works for any search problem whose graph is explicitly represented with a successors dictionary as used in this example."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def successors_f(state): \n",
" successors = {'a': ['b', 'c', 'd'],\n",
" 'b': ['e', 'f', 'g'],\n",
" 'c': ['a', 'h', 'i'],\n",
" 'd': ['j', 'z'],\n",
" 'e': ['a', 'k', 'l'], # Watch out. This creates the cycle a -> b -> e-> a\n",
" 'g': ['m'],\n",
" 'k': ['z']}\n",
" return successors.get(state, [])"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['b', 'c', 'd']"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"successors_f('a')"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['a', 'k', 'l']"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"successors_f('e')"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"successors_f('q')"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['a']"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"breadth_first_search('a', 'a', successors_f)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['a', 'b']"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"breadth_first_search('a', 'b', successors_f)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['a', 'c']"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"breadth_first_search('a', 'c', successors_f)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['a', 'd']"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"breadth_first_search('a', 'd', successors_f)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['a', 'b', 'e']"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"breadth_first_search('a', 'e', successors_f)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['a', 'b', 'g', 'm']"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"breadth_first_search('a', 'm', successors_f)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Path from a to a: ['a']\n",
"Path from a to b: ['a', 'b']\n",
"Path from a to c: ['a', 'c']\n",
"Path from a to d: ['a', 'd']\n",
"Path from a to e: ['a', 'b', 'e']\n",
"Path from a to f: ['a', 'b', 'f']\n",
"Path from a to g: ['a', 'b', 'g']\n",
"Path from a to h: ['a', 'c', 'h']\n",
"Path from a to i: ['a', 'c', 'i']\n",
"Path from a to j: ['a', 'd', 'j']\n",
"Path from a to k: ['a', 'b', 'e', 'k']\n",
"Path from a to l: ['a', 'b', 'e', 'l']\n",
"Path from a to m: ['a', 'b', 'g', 'm']\n",
"Path from a to z: ['a', 'd', 'z']\n"
]
}
],
"source": [
"for goal in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'z']:\n",
" path = breadth_first_search('a', goal, successors_f)\n",
" print(f'Path from a to {goal}: {path}')"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Path from a to a: ['a']\n",
"Path from a to b: ['a', 'b']\n",
"Path from a to c: ['a', 'c']\n",
"Path from a to d: ['a', 'd']\n",
"Path from a to e: ['a', 'b', 'e']\n",
"Path from a to f: ['a', 'b', 'f']\n",
"Path from a to g: ['a', 'b', 'g']\n",
"Path from a to h: ['a', 'c', 'h']\n",
"Path from a to i: ['a', 'c', 'i']\n",
"Path from a to j: ['a', 'd', 'j']\n",
"Path from a to k: ['a', 'b', 'e', 'k']\n",
"Path from a to l: ['a', 'b', 'e', 'l']\n",
"Path from a to m: ['a', 'b', 'g', 'm']\n",
"Path from a to z: ['a', 'b', 'e', 'k', 'z']\n"
]
}
],
"source": [
"for goal in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'z']:\n",
" path = depth_first_search('a', goal, successors_f)\n",
" print(f'Path from a to {goal}: {path}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Example 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's try a navigation problem around a grid of size 10 x 10. Rows and columns will be indexed from 0 to 9.\n",
"\n",
"The following function takes the input state and returns all possible states."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"def grid_successors(state):\n",
" row, col = state\n",
" # succs will be list of tuples () rather than list of lists [] because state must\n",
" # be an immutable type to serve as a key in dictionary of expanded nodes\n",
" succs = []\n",
" for r in [-1, 0, 1]: #check each row\n",
" for c in [-1, 0, 1]: # check in each col\n",
" newr = row + r\n",
" newc = col + c\n",
" if 0 <= newr <= 9 and 0 <= newc <= 9: \n",
" succs.append( (newr, newc) )\n",
" return succs"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5)]"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"grid_successors([3,4])"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(2, 8), (2, 9), (3, 8), (3, 9), (4, 8), (4, 9)]"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"grid_successors([3,9])"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(0, 0), (0, 1), (1, 0), (1, 1)]"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"grid_successors([0,0])"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Breadth first\n",
"path from (0, 0) to (9, 9) is [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]\n"
]
}
],
"source": [
"print('Breadth first')\n",
"print('path from (0, 0) to (9, 9) is', breadth_first_search((0, 0), (9, 9), grid_successors))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Depth-first\n",
"path from (0, 0) to (9, 9) is [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (1, 9), (2, 8), (2, 7), (2, 6), (2, 5), (2, 4), (2, 3), (2, 2), (2, 1), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0), (8, 0), (9, 1), (8, 2), (7, 2), (6, 2), (5, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 9), (6, 8), (6, 7), (6, 6), (6, 5), (7, 4), (8, 4), (9, 5), (8, 6), (8, 7), (8, 8), (9, 9)]\n"
]
}
],
"source": [
"print('Depth-first')\n",
"print('path from (0, 0) to (9, 9) is', depth_first_search((0, 0), (9, 9), grid_successors))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's plot the paths."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(0, 0),\n",
" (0, 1),\n",
" (0, 2),\n",
" (0, 3),\n",
" (0, 4),\n",
" (0, 5),\n",
" (0, 6),\n",
" (0, 7),\n",
" (0, 8),\n",
" (1, 9),\n",
" (2, 8),\n",
" (2, 7),\n",
" (2, 6),\n",
" (2, 5),\n",
" (2, 4),\n",
" (2, 3),\n",
" (2, 2),\n",
" (2, 1),\n",
" (3, 0),\n",
" (4, 0),\n",
" (5, 0),\n",
" (6, 0),\n",
" (7, 0),\n",
" (8, 0),\n",
" (9, 1),\n",
" (8, 2),\n",
" (7, 2),\n",
" (6, 2),\n",
" (5, 2),\n",
" (4, 3),\n",
" (4, 4),\n",
" (4, 5),\n",
" (4, 6),\n",
" (4, 7),\n",
" (4, 8),\n",
" (5, 9),\n",
" (6, 8),\n",
" (6, 7),\n",
" (6, 6),\n",
" (6, 5),\n",
" (7, 4),\n",
" (8, 4),\n",
" (9, 5),\n",
" (8, 6),\n",
" (8, 7),\n",
" (8, 8),\n",
" (9, 9)]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"path_dfs = depth_first_search((0, 0), (9, 9), grid_successors)\n",
"path_dfs"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, we have the path to goal state. To plot this path we must extract the first value in each tuple and put them in a list called `rows` to use as the $y$ coordinate of each point, and build a second list called `cols` of second values."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAApOUlEQVR4nO3deUBU9frH8feXHXFBRVxwzxUFs9BU1MpScynX223f83bLFr03t/KXlaVl17Q92/dbKeIuapZrWSoKiLjhiigoisq+fH9/oBfHGIEc5pyZ87z+itgenjnz8TvnnPk+SmuNEEII8/IwugAhhBCXJ0EthBAmJ0EthBAmJ0EthBAmJ0EthBAm51UVPzQoKEg3b968Kn60EEK4pS1btpzQWtcr63NVEtTNmzdn8+bNVfGjhRDCLSmlDtr7nJz6EEIIk5OgFkIIk5OgFkIIk5OgFkIIk5OgFkIIk6uSuz5cWXRsCjNidnH0dA6NAv15tn9bhnYOMbosYQJybAh7qvrYkKC+SHRsChOj4skpKAIg5XQOE6PiAeQJaXFybAh7nHFsyKmPi8yI2fW/Zl+QU1DEjJhdBlUkzEKODWGPM44NCeqLpJzOKfP/H7Xz/4V12DsG5NgQzjg25NQHcCorn5cXJ9r9fL0avk6sRphJYVExn6zfj73xGrUDfJxajzCXX3al4aEURWUMYGkU6O+w32PpFbXWmsVxR7l55hoWbj9K/9Bg/Lz/3JKT5/J49+e9FBQVG1ClMMrO1DMMf38j05Yl0bFRTfy8bI8NBWRk5TP6262cOJdnTJHCEKey8hn7wzYe+OwP6lb3wfeSY8Pf25Nn+7d12O+z7Ir6+Jlcno9OYGXiccJCavH1I9fRvmHNP129/cf1Ldm0P4MZMbtYHJfKjJHhdAypZXT5ogrlFRbx7uq9vPfLPgKrefPuXdcwMKwBC7YdtTk2xtzcmtTMXN5evZcNe0/wwq0dGHJ1I5RSRv8JooporVmWcIz/W5DA6ewCnuzTitF9WrEs/liV3vWhqmJmYkREhDbrpkxaa37YfJipS3aSX1jM2L5teLhnC7w8L//iImbHMZ6PTiAjK59He7XkmZtb4+ft6aSqhbNsOXiK8fPi2Jt2juHXhDB5UGi5pzf2HD/LuHlxxB46zY1t6/HKsDCHvuwV5pB2JpfJCxKI2VGyuHttRDihjWo67OcrpbZorSPK/JyVgvrQyWwmRMWxcd9JrmtRh+kjwmkRFFDh78/MLuDVpTv5fvNhWgYFMH1EOF1b1KnCioWzZOcXMiNmF59vPEDDmn68MjyMG9sGV/j7i4o1X2w8wIyYXXh6KMYPaMfdXZvi4SGra1entebHLUeYujiRvMJixvRtwyMVWNxVluWDuqhY8/nGA7xx/kk0cWA77uzy159E6/ecYOL8OA5n5HBvt2aMH9CO6r6WPYvk8tbvOcGEqDiOnMrhvu7NGHfLX388D2dkMzEqnvV7T9C1RR1eq+RiQJjLpY/n9OFhtKxXvUp+l6WDevfxs4ybG8e2w6fp0y6YV4Z1pGGtK39Zmp1fyBsxu/ls4/6/tAITxsvMKeCVJYn8sPmIQ18haa35cfMRXl6SSH4VrsBE1bn0FdKEAe24q4pfIVkyqPMLi3n/l3288/Meqvt6MeW2DtzWyfEXerYeOsX4uXHsSTvH8M4hTB5c/jlNYbyYHceYHJ3Ayax8RvVuydM3Of6aw/EzuUyOTmBFYtWc0xRVY8/xs4yfF8fWQ6e5oW09XnXSNQfLBfX2w6cZPy+OpGNnubVTI6bcGkrd6lV3L/TFdwnU8vfmxSEdGBTWUK7+m1D62TymLNzBkvhUQhvW5PUqvotHa83S+GO8sLDkLoF/3nAVo/u0wtdLLkSbTUFRMR/8so+3V+8lwNfT6XfxWCaoc/KLeHPVbj5el0y9Gr5MHRpG39D6Tvv9O1PPMG5uHPEpmfQLrc/LQztSv6af036/sE9rTdTWFF5anEhOfhFP39yaUb1b4u2k0xGnsvJ5eUkiUVtTaBVcnddGhHNts9pO+d2ifPFHMnl27naSjp1lcHhDptzWgaAqXNyVxRJB/eu+k0yMiuPAyWzu7NqUiQPbUdPP26k1QOk72Wau3I2PlwfPD2rP7RFNZHVtoJTTOUyKimfN7nSubVab10aE0yq4ai4IleeXXWk8Nz+Bo5k5PNCjOc/2b0s1H7kQbZTcgpLF3UdrSxZ3Lw/pSL8ODQypxa2D+kxuAdOXJfHtpkM0q1uNacPD6HFVkFN+9+XsP5HF+Hlx/L4/g8hWdZk2LJymdasZXZalFBdrvt50kNeWJaGBcf3bcl/35obfMncur5DXlyfx5a8HaVzbn+nDw+nZ2vhj1mp+Sz7JhHkXFndNmDCgPbX8nb+4u8Btg3p10nEmRSWQdjaXh3u2YGzftvj7mOfcX3Gx5rs/DjFtaRJFxZp/92/LAz2a4yn31la5fennmDAvjj8OnKJX6yBeHRZGkzrm+ofy9/0ZTJgXR/KJLG6PaMxzA0OpVc24oLCKs+cXd99sOkTTOtWYPjyMHq2M/4fS7YL65Lk8XlqcyIJtR2lbvwavjQzn6iaBVfb7rlRqZg7PzU9gdVIanZsG8vqIcFrXr2F0WW6poKiYj9YlM2vVHvy9PZk8OJQR14SY9tRTbkERs3/aw5y1ydQJ8OHlIR25paMxL72t4OekNCbNj+f4mVweimzB2H5tTHPqyW2CWmvNwu1HeXFRImdzC3jixlY8fkMrfLzMf3/qhdqnLNzBubxCnuzTmseuv8olancVCSmZjJ8Xx46jZxjQsQEvDulAcA3XuJibkJLJuLlxJKaeYVBYycUs2bXRcTKy8nlp0Q6itx2lTf2Si7mdm5rrYq5bBHVqZg7Pz0/gp6Q0OjUpWZW2beB6q9KT5/KYsiiRRduP0q5BDV4bEU4nE78acAW5BUW8vXoPH6xJpnY1H14e0oEBYQ2NLqvSCoqKmbM2mdk/lbwa+L/BoQw38asBV6C1ZlFcKlMW7uBsbgGP39CKJ2405+LOpYO6uFjz3z8OM23pTgqKi/l3v7Y8GNnC5c/zrkw8zvPR8aSfzTu/yVMbU51fdxWbD2Qwbl4cyelZjLy2Mc8Pak9gNdd+w9HetHOMnxfHloOnuL5NPV4dHkaIbPJUaccyS3bIXLXzOJ0a1+K1keG0a2DeNxy5bFAfOJHFhKg4fkvOoHvLukwfEUazuu6zb8KZ3AKmLd3Jd78fpnndakwfEU63lnWNLsslZOWVbKL0xa8HaFTLn2nDw+jdpp7RZTlMcbHmq98O8tryJBQwfkA77rmumeF3rLgCrUsWd68uKVnc/atvWx7qaf7F3RUHtVJqDPAIoIF44EGtda69r/8rQX3xPtANA/3o0qwOMYnH8Pbw4LlB7fl7F/e9F3nj3hNMiIrnUEY2d1/XlLCQmry9ep9Muz7v0j3Cb+3UkEXbUzmamcP93UvuRQ5w002xDmdkM2l+POv2nKBL89pMHxFO/JFMmYZ+3qXHxoORzflpZxq/Jp+kW8s6TB8eTnMX2RTrioJaKRUCrAdCtdY5SqkfgKVa68/tfU9lg/rSKb4XdGhUk0/u70KDWq5xQehK5OQXMXPlLj5at/9Pn/P39mTa8DBLPhntHRvBNXx47+5riWju/tvMaq2ZtzWFlxcnci63AKUUhcWlz1urHh/2jg1fT8WUIR35e0QTl3oFcrmgrugZdS/AXynlBVQDjjqqOCh7ii/A6ex8S4Q0gL+PJ88NCqVeGW9btfK0a3vHhpeHhyVCGkApxchrG7NybG+8vTxsQhqse3zYOzZqB/hyp5vtBV5uUGutU4A3gENAKpCptV5x6dcppUYppTYrpTanp6dXqgj7U3ztnl1xW/Zm71l12rW9vzs103rHRnANP/IKyp7bacXjw97ffPyM+x0b5Qa1Uqo2MARoATQCApRS91z6dVrrOVrrCK11RL16lbuoY28LQSuOM5Je2JJ+2JJ+lLJSLypy6uNmYL/WOl1rXQBEAT0cWcSz/dvif8lewI6e4usqpBe2pB+2nu3fFj/vqp147SqsdGxU5FL5IaCbUqoakAPcBDj03SwXLoKM+X4bGgix8JXsC3/zS4t3kJFVQHANXyYNbG/JXkBpPybMiyO3sNjSxwaU9COvoIjxUfGAPFcAXli4g8ycAhrU9GPCgHZu2Ytyg1prvUkpNRfYChQCscAcRxcytHMIE6Piubd7MyYNbO/oH+9ShnYOwc/bg8e+3soXD3WlfUPz3qTvDEM7h7A0PpVDGdksf6a30eUYbnCnRoyPimfSwHaM6n2V0eUYamjnEM7mFTI5OoFFT/Z027fdV+jmU631C8ALVVyLEEKIMpjvDe9CCCFsSFALIYTJSVALIYTJSVALIYTJSVALIYTJSVALIYTJSVALIYTJSVALIYTJSVALIYTJSVALIYTJSVALIYTJSVALIYTJSVALIYTJmSaoo2NTyC0oYs7aZCKnryY6NsXokgwTHZvCpPkl+w3f/+nvlu4FlPRj7e50ko6dtfyxAbB4e8nI0leXJlm+H9GxKbxxfl7krW+vd9teVGib06p2YZrwhZGdKadzmHh+Y3R33AT8ci6drJx2Ns+yvYDSfuQWlswKtPKxASX9eGHRjv99bOV+XPpcOXYm1217YYoVdVnThGWycimr9gKkH5eaEbOL3EsG3Fq1H1Y6NkwR1PankMtk5fL+v7uTftiSfpSyUi9MEdRWmiZcHumFLemHLelHKSv1whRBbaVpwuWRXtiSftiSKeSlrHRsmOJiokwhLyVTyG3JFHJbMoW8lEwhN4BMIS8lU8htyRRyWzKFvJRVppCb4tSHEEII+ySohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CSohRDC5CoU1EqpQKXUXKVUklJqp1Kqu6MLkSnkpWQKuS2ZQm5LppCXkinktmYDy7XWI5VSPkA1RxYhU8hLyRRyWzKF3JZMIS8lU8gvopSqCfQGPgHQWudrrU87sggrTRMuj/TClvTDlkwhL2WlY6Mipz5aAunAZ0qpWKXUx0qpgEu/SCk1Sim1WSm1OT09vVJFWGmacHmkF7akH7akH6Ws1IuKBLUXcA3wvta6M5AFTLj0i7TWc7TWEVrriHr16lWqCCtNEy6P9MKW9MOW9KOUvb/Zx8vD7cK6IkF9BDiitd50/uO5lAS3w1hpmnB5pBe2pB+2ZAp5qbKODW9PRXGxpu/MNXz120GKi7Wd73Yt5Qa11voYcFgpdeFIuAlIdGQRQzuHMG14GOr8xyGB/kwbHuZ2FwQq4kIv6gR4AxBcw9eyvYDSfvh5lRyqVj42oKQfL97a4X8fW7kfF46NkEB/FCW9mDGyE6v/fQOdm9ZmcnQCd8z5jeT0c0aXesWU1uX/i6OUuhr4GPABkoEHtdan7H19RESE3rx5c6WLaT95uUwhP295QiqPfb2VZU/3svwUcoBRX26WKeTnZeUV0uGFGJlCfhlaa37ccoSpixPJKyxmTN82PNKzBV6e5n3riFJqi9Y6oqzPVej2PK31NqDMHyCEEGajlOL2iCbc0KYekxckMH1ZEovjjvL6iE6ENnK9hY95/3kRQogrFFzTjw/uuZb37r6GY5m53PbOev6zYhd5hUXlf7OJSFALIdyaUoqBYQ1ZOeZ6hlwdwtur9zLorfVsOZhhdGkVJkEthLCE2gE+/Of2TnzxUFdy8osY+cGvTFm4g6y8QqNLK5cEtRDCUq5vU4+YMb25r1szPt94gP6z1rJuT+XepOdsEtRCCMup7uvFi0M68uNj3fHx8uDeT37n2R+3k5ldYHRpZZKgFkJYVpfmdVj6VC8ev+EqomJTuPnNNSxPOGZ0WX8iQS2EsDQ/b0/G3dKOBU9EUq+6L499vYXHv9lC2tlco0v7HwlqIYQAOobUYsHoSJ7t35ZVO9PoO3Mtc7ccoSJvCqxqEtRCCHGet6cHT9zYiqVP9aJ1cHX+/eN27v/sD46cyja0LglqIYS4RKvg6vzwj+68eFsHNh/IoN+ba/li4wHDNnmSoBZCiDJ4eCju79GcFWN6E9G8Di8s3MHtH/7KPgM2eZKgFkKIy2hcuxpfPNiFN/7WiT1p5xgwex3v/ryXgqLi8r/ZQSSohRCiHEopRl7bmJVje3Nz+2BmxOxi6LsbSEjJdMrvN01QyxTyUjKF3JZMIbclU8iNE1zDj/fuvpYP7rmGtLN5DHl3A68vT+LHzYeJnL6aFhOWVMljUtEp5FVKppCXkinktmQKuS2ZQm4Ot3RsSPeWQUxdksh7v+xDQZXmlylW1FaaJlwe6YUt6YctmUJuHrWqeTPjb52oG+DDpfeCOPoxMUVQW2macHmkF7akH7akH+aTkZVf5v935GNiiqCWycqlpBe2pB+27P3dtat5m+IddFZSXKz5fMN+u5935DFqiqCWSdOlpBe2pB+2yuqHUpCRXcBjX28h7Yx59qdwZ3vTznH7h78yZVEibRvUwNeraifDm+Ji4oUT7mO+34amZJrws/3bWvLiyIW/+aXFO8jIKiC4hi+TBra3ZC+gtB8T5sWRW1hs6WMDSvsxI2YXR0/n0CjQn3/1bU36uXxmrtzNTTPXMHlQKH+LaIxSyuBq3U9BUTFz1iYze9Ueqvl6MvP2TgzrHMKCbUdtHhNHH6MVmkJeWTKF/MrJFHJbMoW8fMnp55gQFc/v+zPo2SqIacPDaFKnmtFluY2ElEzGzY0jMfUMg8IaMuW2DtSr4euwn3+5KeSmOPUhhLhyLetV57+PdmPq0I5sO3yafm+u5dP1+ykyaH8Kd5FbUMRry5MY8u4G0s/l8cE91/Lu3dc4NKTLY4pTH0IIx/DwUNzTrRl92gUzaX48Ly1OZHHcUV4bEU7r+jWMLs/l/HEgg/Fz40g+kcXtEY15bmAotap5O70OWVEL4YYaBfrz2QNdmPX3q9l/IotBb63n7Z/2OHV/Cld2Lq+Q/1uQwN8++JX8omK+fvg6Xh/ZyZCQBllRC+G2lFIM7RxCz9ZBvLgokf+s3M2S+FReHxlOeONAo8szrV92pfHc/ASOZubwUGQL/t2/DdV8jI1KWVEL4eaCqvvy9p2d+ei+CE5l5zP03Q1MW7qT3Eve8Wl1p7LyGfvDNh747A/8fTyZ+1gP/u/WUMNDGmRFLYRl9A2tT9cWdZi+bCcfrk0mZscxpo8Ip1vLukaXZiitNUvjj/HCwgROZxfwVJ9WPNGnFb5enuV/s5PIiloIC6nl78204eF8+8h1FGu4Y85vPDc/nrO5BUaXZoi0M7n846stPPHtVhrW8mfh6J6M7dfWVCENsqIWwpJ6tApi+TO9mLliN59u2M/qpDReHRbGje2CjS7NKbTW/Lj5CC8vSSS/sJiJA9rxcM8WeHmac+1qzqqEEFWumo8Xzw8OZd4/e1DDz4sHP/+DZ/4ba3eTIXdxOCObez/5nXHz4mjfsCbLn+nNP66/yrQhDbKiFsLyOjetzeIne/Huz3t575e9rNtzgim3dWBweEO3eht6UbHmi40HmBGzC08PxdShHbmra1M8PMz/N0pQCyHw8fJgTN82DAhrwPi5cTz5XSwLth1l6tCONKjlZ3R5V2zP8bOMmxdH7KHT3Ni2Hq8MC3OpHRjNu9YXQjhduwY1iXo8kucGtmf93nT6zlzDd78fctktVPMLi3nrpz0Mems9B05kMevvV/PpA11cKqRBVtRCiEt4eige7d2SvqH1mRAVx8SoeBZuO8r0EWE0qxtgdHkVFnfkNOPmxpF07Cy3dmrEC7eGElTdeftzOJKsqIUQZWoeFMC3j3Tj1WFhJKRk0n/WWj5el2z6TZ5yC4qYtnQnQ9/dwKnsfD66L4K37+zssiENldjmVCnlCWwGUrTWgy/3tX9lm9Po2BTZj/q86NgU2Y/6ItGxKbIftcFSM3N4fn4CPyWl0alJIK+PCGdn6pkq3YO5IqJjU2xqGNa5EYvjUjlwMps7uzZhwoD21PI3Zn+OyrrcNqeVCeqxQARQ09FBfenkbSiZkDBteJjlnpDSC1vSD/PQWrMoLpUpC3dwOjsfD6UovGh17ezHpaxjA6BOgDfv3HkNPVoFOaUOR7lcUFfoHLVSqjEwCHgFGOvA2oDLT5q22pNRemFL+mEeSilu69SInq2CiJy+uszHZcK8OJbEpzqlnnW708kt/PNugH5eni4X0uWp6MXEWcA4wO6GtkqpUcAogKZNm1aqCJmsXEp6YUv6YT51AnzsbuiUW1jMkVPOeWzKCmmA1Ez3mxtZblArpQYDaVrrLUqpG+x9ndZ6DjAHSk59VKaIRoH+pJTxxHO1W2gcQXphS/phTvYel5BAf5Y93cspNUROX22ZY6Mid31EArcppQ4A/wX6KKW+dmQRMmm6lPTClvTDnMzwuJihBmcpd0WttZ4ITAQ4v6L+t9b6HkcWIVPIS8kUclsyhdycypqG7uzHxQw1OEulppBfFNQOvz0PZAr5xWQKuS2ZQi7c3RXf9XGB1voX4BcH1CSEEKKC5J2JQghhchLUQghhchLUQghhchLUQghhchLUQghhchLUQghhchLUQghhchLUQghhchLUQghhchLUQghhchLUQghhchLUQghhchLUQghhcqYJ6ujYFHILipizNpnI6auJjk0xuiTDRMemMGl+PAD3f/q7pXsBJf1YuzudpGNnLX9sCGuq1DanVeXCNOELO2OnnM5hYlRJULnjJuCXc+lk5bSzeZbtBZT248J8PCsfG8K6TLGivtykaauRXtiSfghhkqCWSdOlpBe2pB9CmCSo7U0NdsdpwuWRXtiy93f7eXuSkZXv5GqEMIYpgtpK04TLI72wVVY/vDwUuQVF3DxzDQu3H6Uycz+FcEWmCOqhnUOYNjwMdf7jkEB/pg0Ps+TFogu9qBPgDUBwDV/L9gJK+xES6I+i5Nh442+dWPZMLxrX9uep72J59MstHMvMNbpUIapMpaaQV5RMIb9yMoW8fIVFxXy24QBvrNiFj6cHkwa1544uTVBKlf/NQpjM5aaQm2JFLcRf4eXpwaO9WxLzTG9CG9VkYlQ8d320iYMns4wuTQiHkqAWLq95UADfPdqNV4eFEZ+SSf9Za/l4XTJFxXLuWrgHCWrhFjw8FHdd15SVY3sTeVUQU5fsZPj7G9l17KzRpQlxxSSohVtpWMufj++PYPYdV3M4I5vBb69j1qrd5J9/Z6MQrkiCWrgdpRRDrg5h5ZjeDAxryKxVe7j17fVsO3za6NKE+EskqIXbqlvdl9l3dObj+yLIzClg+HsbeGVJIjn5ReV/sxAmIkEt3N7NofVZMbY3d3Rtykfr9tN/1lo27jthdFlCVJgEtbCEmn7evDosjO8e7YZScNdHm5gYFc+Z3AKjSxOiXBLUwlK6X1WX5U/3ZlTvlnz/xyH6zlzDqsTjRpclxGVJUAvL8ffxZNLA9sx/PJLa1Xx45MvNPPldLCfP5RldmhBlkqAWltWpSSALR/dkbN82LE9I5eaZa1iwLUU2eRKmI0EtLM3Hy4OnbmrNkqd60axuAE//dxsPf7FZ9rsWpiJBLQTQpn4N5v2zB5MHh/LrvpP0e3Mt32w6SLG8DV2YgAS1EOd5eige7tmCmGd606lJLZ6bn8CdH/3G/hOyyZMwVrnbnCqlmgBfAg2AYmCO1nr25b7nr2xzGh2bwpjvt6Ep2XP42f5tLbsHc3RsCi8t3kFGVgHBNXyZNLC9ZXthFK01P2w+zNQlO8kvLOZf/doQFODDf1bu4ejpHBoZeIxGx6YwI2aX1GGSGhzlctucViSoGwINtdZblVI1gC3AUK11or3vqWxQXzp5G0qmmlhxw3zphbkcP5PL89EJrEw8jlJw8dPFiMfFLMeHGeowQw2OdEVBXcYPWwC8o7Veae9rKhvUkdNXk1LGxZuQQH82TOhTqfpcnfTCfLTWXPPySk5l//nNMT6eHnRqUstptWw/nEl+0Z83mLJiHfZqcNXnyuWC2quSP6g50BnYVMbnRgGjAJo2bVqpAmXSdCnphfkopThdRkgD5BcV4+3pvEs9ZQWTVeuwV4M7PlcqHNRKqerAPOAZrfWZSz+vtZ4DzIGSFXVlimgU6F/mKtKKk7elF+Zk73EJCfTn20e7Oa2Oy73islod9mrw9FDEHjpF56a1nVKHM1Tonz6llDclIf2N1jrK0UXI5O1S0gtzMsvjInVcvgYfTw8CfD0Z/v5GXl6cSHZ+odPqqUrlrqhVyaTQT4CdWuuZVVHEhRP/ctdHaS/krg9zudB/o+8wkDrKr+Gm9sG8tjyJT9bvZ0XiMaYPDyeyVZDT6qoKFbnroyewDoin5PY8gEla66X2vkemkF85mUIuxJXZlHySCVHx7D+RxR1dmjBxYHtq+XsbXZZdV3QxUWu9HlAOr0oIIarQdS3rsuzpXry5ajcfrU1mdVIaU4d2pF+HBkaXVmnyzkQhhNvy8/Zk4oD2RD8RSZ0AH0Z9tYXR327lhIvtlChBLYRwe+GNA1n0ZE/+3a8NK3Yc5+aZa5gfe8RldkqUoBZCWIK3pwej+7Rm6dM9aRkUwJjvt/PQ53+4xH3XEtRCCEtpFVyDHx/rwQu3hvJbcgZ9Z67hq9/MvVOiBLUQwnI8PRQPRrZgxZjedG5am8nRCdwx5zeS088ZXVqZJKiFEJbVpE41vnq4K6+PDCfp2BkGzF7HB2v2UWjn7elGkaAWQliaUorbI5qwauz13NC2HtOXJTH0vQ0kHv3TThmGkaAWQggguKYfH94bwft3X8OxzDxue2c9/1mxi7zCovK/uYpJUAshxEUGhDVk1djeDLk6hLdX72XQW+vZcjDD0JokqIUQ4hKB1Xz4z+2d+OKhruTkFzHyg1+ZsnAHWXnGbPIkQS2EEHZc36YeMWN6c1+3Zny+8QD9Z61l3Z50p9chQS2EEJdR3deLF4d05MfHuuPj5cG9n/zOsz9uJ9POMImqIEEthBAV0KV5HZY+1YvHb7iKqNgUbn5zDcsTjjnld1d6ZmJFyBTyKyNTyIUwt4SUTMbNjSMx9QwDwxrQrWUdPlyz/4r25nbocNuKkCnkf530QgjXUFBUzJy1ycxcsYuiS2L0rzxnLxfUpjj1MSNml00wAeQUFDEjZpdBFRlHeiGEa/D29OCJG1tRt7rvnz7n6OesKYJaJm+Xkl4I4VrSz5a9t7Ujn7OmCGp7E7atOHnb3t+sFPy087iTqxFC2JOVV8iUhTuwd/LYkflliqA2w0RjsyirF75eHtSv4cvDX2zmqe9iOeli0ymEcDdrd6fT7821fPHrAXq1DsLP2zZKHZ1f5c5MdAaZQl7K3mTlgWENef+Xfbzz8x7W7Ulnym0duK1TI0qGxAshnOF0dj5Tl+xk7pYjtKwXwI//6E5E8zpEx6ZU6UR2U9z1cYFMIS/f7uNnGTc3jm2HT3NTu2CmDutIw1rWO0UkhLMti09l8oIdnMrO57HrW/Jkn9b4XfLq90qY/q4PUXFt6tdg3j978Pyg9mzYd4K+M9fyzSZzT6cQwpWlnc3ln19v4Z/fbKV+TV8Wjo7k2f7tHBrS5THFqQ9ROZ4eikd6taRfaAMmRMXx3PwEFm0/yvTh4TQPCjC6PCHcgtaauVuOMHXJTnIKihh3S1se7dUSb0/nr29lRe3CmtatxjePXMf04WHsSDlD/1lrmbPWfNMphHA1hzOyue/T33l2bhxt6ldn2dO9ePyGVoaENMiK2uUppbija1NuaBvM89EJvLo0iSVxqbw2Mpx2DWoaXZ4QLqW4WPPlrwd4PWYXCnh5SAfuvq4ZHh7GXrSXFbWbaFDLj4/uu5Z37urMkVM5DH5rPTNX7jbFdAohXMHetHPc/uGvTFmUSJfmdYgZ05t7uzc3PKRBVtRuRSnF4PBGRF4VxEuLE3nrpz0siy9ZXV/TtLbR5QlhShf27Ji9ag/VfD2ZeXsnhnUOMdWtr7KidkO1A3x48+9X89kDXTiXV8iI9zfy8uJEsvONmU4hhFklpGQy5J0NzIjZRd/Q+qwccz3Dr2lsqpAGWVG7tRvbBbNiTG9eW57EJ+v3syLxGNOHhxPZKsjo0oQwVG5BEbN/2sOctcnUCfDhg3uu5ZaODYwuyy5ZUbu5Gn7eTB0axvejuuHl4cHdH29iwrw4MnOcN51CCDP540AGA2ev4/1f9jHymsasGnO9qUMaZEVtGde1rMuyp3sxa9UePlqXzOqkNKYO7Ui/DuY+QIVwlHN5hby+PIkvfz1I49r+fP3wdfRs7RqvLmVFbSF+3p5MGNCO6McjqVvdl1FfbWH0t1s5IZs8CTf38640+s1cw1e/HeShyBasGNPbZUIaZEVtSWGNa7FwdCQfrtnHWz/tZf3eE7xwayhDrzbXlW4hrtSprHxeXpxIVGwKrYKrM/exHlzbzPXugJKgtihvTw9G92nNLR0bMG5uHGO+386CbUd5ZVgYIRbcB1y4F601S+OP8cLCBE5nF/BUn1Y80acVvl7O25/DkeTUh8W1Cq7Bj4/14IVbQ9mUnPG/l4eyyZNwVWlncvnHV1t44tutNKzlz8LRPRnbr63LhjRUcJtTpdQtwGzAE/hYaz39cl8vU8hd0+GMbCbNj2fdnhN0bV6Hm0OD+WLjwSrbY7eiqnqvX6nDdeuwrcGPXq3rsSQ+lfzCYsb2bcPDPVvgZdD+HJV1RVPIlVKewG6gL3AE+AO4U2udaO97ZAq567qwY9jk6HhyC22PDSMeE7McG1KH+eooqwaAlkEBfPJAF1q42E6SVxrU3YEpWuv+5z+eCKC1nmbveyob1JHTV5NSxiDIkEB/NkzoU+GfIxyn26s/cexM7p/+v5eHcuoTYP+JLArLOA0jdUgd9mpoFOjHxgk3OaUGR7pcUFfkYmIIcPiij48A15XxS0YBowCaNm1aqQJl8rb5HC8jpAEKizWt61d3Wh170s5JHVJHpWpIPV32sevKKhLUZd2v9ad/xrTWc4A5ULKirkwRjQL9y1xRW3EKuVnYe0xCAv157+5rnVbH5V5tSR3WrsNeDe6YGxU5y34EaHLRx42Bo44sQqaQm49ZHhOpQ+owcw3OUpEV9R9Aa6VUCyAFuAO4y5FF2Ju8LRcSjWOWx0TqkDrMXIOzVPT2vIHALEpuz/tUa/3K5b7+r04hF0IIq7rSi4lorZcCSx1alRBCiApxjTvBhRDCwiSohRDC5CSohRDC5CSohRDC5Cp010elf6hS6cDBv/jtQcAJB5bjyqQXtqQftqQfpdyhF8201vXK+kSVBPWVUEpttneLitVIL2xJP2xJP0q5ey/k1IcQQpicBLUQQpicGYN6jtEFmIj0wpb0w5b0o5Rb98J056iFEELYMuOKWgghxEUkqIUQwuRME9RKqVuUUruUUnuVUhOMrsdISqkmSqmflVI7lVI7lFJPG12T0ZRSnkqpWKXUYqNrMZpSKlApNVcplXT+GOludE1GUkqNOf88SVBKfaeU8jO6JkczRVCfH6D7LjAACAXuVEqFGluVoQqBf2mt2wPdgCcs3g+Ap4GdRhdhErOB5VrrdkAnLNwXpVQI8BQQobXuSMlWzHcYW5XjmSKoga7AXq11stY6H/gvMMTgmgyjtU7VWm89/99nKXkiut9u6BWklGoMDAI+NroWoymlagK9gU8AtNb5WuvThhZlPC/AXynlBVTDwROozMAsQV3WAF3LBtPFlFLNgc7AJoNLMdIsYBxQbHAdZtASSAc+O38q6GOllPPGj5uM1joFeAM4BKQCmVrrFcZW5XhmCeoKDdC1GqVUdWAe8IzW+ozR9RhBKTUYSNNabzG6FpPwAq4B3tdadwayAMte01FK1abk1XcLoBEQoJS6x9iqHM8sQV3lA3RdjVLKm5KQ/kZrHWV0PQaKBG5TSh2g5JRYH6XU18aWZKgjwBGt9YVXWHMpCW6ruhnYr7VO11oXAFFAD4NrcjizBPX/BugqpXwouRiw0OCaDKOUUpScg9yptZ5pdD1G0lpP1Fo31lo3p+S4WK21drsVU0VprY8Bh5VSF0Zt3wQkGliS0Q4B3ZRS1c4/b27CDS+uVmhmYlXTWhcqpUYDMZQO0N1hcFlGigTuBeKVUtvO/79J52dXCvEk8M35RU0y8KDB9RhGa71JKTUX2ErJ3VKxuOHbyeUt5EIIYXJmOfUhhBDCDglqIYQwOQlqIYQwOQlqIYQwOQlqIYQwOQlqIYQwOQlqIYQwuf8HrK9CPYwBWMIAAAAASUVORK5CYII=\n",
"text/plain": [
"