diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..f24d933 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,3 @@ +*.ipynb filter=nbstripout +*.zpln filter=nbstripout +*.ipynb diff=ipynb diff --git a/.gitignore b/.gitignore index 176af7e..57555f7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ .ipynb_checkpoints/ +.commit diff --git a/README.md b/README.md index 492e99f..6b7ace4 100644 --- a/README.md +++ b/README.md @@ -3,3 +3,10 @@ This directory contains an ipython notebook contianing Python code for the Spider Algorithm. Information on how it works and references are contained inside notebook. This project was done by Jeffrey Lantz and Riley Guyett as part of their senior theses with Professor Hubbard in Spring 2023. + +## Developer Notes +The python environment is managed via (mini)conda, which can be installed [here](https://docs.conda.io/projects/conda/en/stable/user-guide/install/index.html). The environment is managed in env.yaml, and should be automatically managed via git hooks. However, on initial install, one may need to run `conda env create -f env.yml` + +Additionally, as working with Jupyter notebooks in version control can be difficult, we have included `nbstripout` in the conda environment. This may need to be manually initialized with `nbstripout --install --attributes .gitattributes`. This makes `git diff` show fewer non-code related changes, at the expense of not showing output data. I tried to include automatically generated outputs, but it wasn't working; for now, if we choose to include sample outputs in the repo, they will be added manually. + +In order to run the Jupyter Notebook, simply call `jupyter lab` from the root directory of the repository, then select `spider-algorithm.ipynb` from the file explorer on the left. Jupyterlab supports a few nice features over jupyter notebook, accessible under `Settings > Advanced Settings Editor`. Here you can change the theme to dark under `Theme > Selected Theme`, and enable automatically formatting the code on saving the notebook under `Jupyterlab Code Formatter > Auto format config`. diff --git a/env.yml b/env.yml new file mode 100644 index 0000000..d7c73ab --- /dev/null +++ b/env.yml @@ -0,0 +1,192 @@ +name: spideralgorithm +channels: + - conda-forge + - defaults +dependencies: + - _libgcc_mutex=0.1=main + - _openmp_mutex=5.1=1_gnu + - anyio=3.5.0=py38h06a4308_0 + - argon2-cffi=21.3.0=pyhd3eb1b0_0 + - argon2-cffi-bindings=21.2.0=py38h7f8727e_0 + - astroid=2.14.2=py38h06a4308_0 + - asttokens=2.0.5=pyhd3eb1b0_0 + - attrs=22.1.0=py38h06a4308_0 + - babel=2.11.0=py38h06a4308_0 + - backcall=0.2.0=pyhd3eb1b0_0 + - beautifulsoup4=4.11.1=py38h06a4308_0 + - black=22.6.0=py38h06a4308_0 + - blas=1.0=mkl + - bleach=4.1.0=pyhd3eb1b0_0 + - brotli=1.0.9=h5eee18b_7 + - brotli-bin=1.0.9=h5eee18b_7 + - brotlipy=0.7.0=py38h27cfd23_1003 + - ca-certificates=2023.01.10=h06a4308_0 + - certifi=2022.12.7=py38h06a4308_0 + - cffi=1.15.1=py38h5eee18b_3 + - charset-normalizer=2.0.4=pyhd3eb1b0_0 + - click=8.0.4=py38h06a4308_0 + - colorama=0.4.6=py38h06a4308_0 + - comm=0.1.2=py38h06a4308_0 + - contourpy=1.0.5=py38hdb19cb5_0 + - cryptography=39.0.1=py38h9ce1e76_0 + - cycler=0.11.0=pyhd3eb1b0_0 + - dbus=1.13.18=hb2f20db_0 + - debugpy=1.5.1=py38h295c915_0 + - decorator=5.1.1=pyhd3eb1b0_0 + - defusedxml=0.7.1=pyhd3eb1b0_0 + - dill=0.3.6=py38h06a4308_0 + - entrypoints=0.4=py38h06a4308_0 + - executing=0.8.3=pyhd3eb1b0_0 + - expat=2.4.9=h6a678d5_0 + - flit-core=3.6.0=pyhd3eb1b0_0 + - fontconfig=2.14.1=h52c9d5c_1 + - fonttools=4.25.0=pyhd3eb1b0_0 + - freetype=2.12.1=h4a9f257_0 + - giflib=5.2.1=h5eee18b_3 + - glib=2.69.1=he621ea3_2 + - gst-plugins-base=1.14.1=h6a678d5_1 + - gstreamer=1.14.1=h5eee18b_1 + - icu=58.2=he6710b0_3 + - idna=3.4=py38h06a4308_0 + - importlib-metadata=4.11.3=py38h06a4308_0 + - importlib_resources=5.2.0=pyhd3eb1b0_1 + - intel-openmp=2021.4.0=h06a4308_3561 + - ipykernel=6.19.2=py38hb070fc8_0 + - ipython=8.10.0=py38h06a4308_0 + - ipython_genutils=0.2.0=pyhd3eb1b0_1 + - isort=5.9.3=pyhd3eb1b0_0 + - jedi=0.18.1=py38h06a4308_1 + - jinja2=3.1.2=py38h06a4308_0 + - jpeg=9e=h7f8727e_0 + - json5=0.9.6=pyhd3eb1b0_0 + - jsonschema=4.17.3=py38h06a4308_0 + - jupyter_client=7.4.9=py38h06a4308_0 + - jupyter_core=5.2.0=py38h06a4308_0 + - jupyter_server=1.23.4=py38h06a4308_0 + - jupyterlab=3.5.3=py38h06a4308_0 + - jupyterlab_code_formatter=1.5.3=pyhd8ed1ab_0 + - jupyterlab_pygments=0.1.2=py_0 + - jupyterlab_server=2.19.0=py38h06a4308_0 + - kiwisolver=1.4.4=py38h6a678d5_0 + - krb5=1.19.4=h568e23c_0 + - lazy-object-proxy=1.6.0=py38h27cfd23_0 + - lcms2=2.12=h3be6417_0 + - ld_impl_linux-64=2.38=h1181459_1 + - lerc=3.0=h295c915_0 + - libbrotlicommon=1.0.9=h5eee18b_7 + - libbrotlidec=1.0.9=h5eee18b_7 + - libbrotlienc=1.0.9=h5eee18b_7 + - libclang=10.0.1=default_hb85057a_2 + - libdeflate=1.17=h5eee18b_0 + - libedit=3.1.20221030=h5eee18b_0 + - libevent=2.1.12=h8f2d780_0 + - libffi=3.4.2=h6a678d5_6 + - libgcc-ng=11.2.0=h1234567_1 + - libgomp=11.2.0=h1234567_1 + - libllvm10=10.0.1=hbcb73fb_5 + - libpng=1.6.37=hbc83047_0 + - libpq=12.9=h16c4e8d_3 + - libsodium=1.0.18=h7b6447c_0 + - libstdcxx-ng=11.2.0=h1234567_1 + - libtiff=4.5.0=h6a678d5_2 + - libuuid=1.41.5=h5eee18b_0 + - libwebp=1.2.4=h11a3e52_1 + - libwebp-base=1.2.4=h5eee18b_1 + - libxcb=1.15=h7f8727e_0 + - libxkbcommon=1.0.1=hfa300c1_0 + - libxml2=2.9.14=h74e7548_0 + - libxslt=1.1.35=h4e12654_0 + - lxml=4.9.1=py38h1edc446_0 + - lz4-c=1.9.4=h6a678d5_0 + - markupsafe=2.1.1=py38h7f8727e_0 + - matplotlib=3.7.0=py38h06a4308_0 + - matplotlib-base=3.7.0=py38h417a72b_0 + - matplotlib-inline=0.1.6=py38h06a4308_0 + - mccabe=0.7.0=pyhd3eb1b0_0 + - mistune=0.8.4=py38h7b6447c_1000 + - mkl=2021.4.0=h06a4308_640 + - mkl-service=2.4.0=py38h7f8727e_0 + - mkl_fft=1.3.1=py38hd3c417c_0 + - mkl_random=1.2.2=py38h51133e4_0 + - munkres=1.1.4=py_0 + - mypy_extensions=0.4.3=py38h06a4308_1 + - nbclassic=0.5.2=py38h06a4308_0 + - nbclient=0.5.13=py38h06a4308_0 + - nbconvert=6.5.4=py38h06a4308_0 + - nbformat=5.7.0=py38h06a4308_0 + - nbstripout=0.6.1=pyhd8ed1ab_0 + - ncurses=6.4=h6a678d5_0 + - nest-asyncio=1.5.6=py38h06a4308_0 + - notebook=6.5.2=py38h06a4308_0 + - notebook-shim=0.2.2=py38h06a4308_0 + - nspr=4.33=h295c915_0 + - nss=3.74=h0370c37_0 + - numpy=1.23.5=py38h14f4228_0 + - numpy-base=1.23.5=py38h31eccc5_0 + - openssl=1.1.1t=h7f8727e_0 + - packaging=22.0=py38h06a4308_0 + - pandocfilters=1.5.0=pyhd3eb1b0_0 + - parso=0.8.3=pyhd3eb1b0_0 + - pathspec=0.10.3=py38h06a4308_0 + - pcre=8.45=h295c915_0 + - pexpect=4.8.0=pyhd3eb1b0_3 + - pickleshare=0.7.5=pyhd3eb1b0_1003 + - pillow=9.4.0=py38h6a678d5_0 + - pip=22.3.1=py38h06a4308_0 + - pkgutil-resolve-name=1.3.10=py38h06a4308_0 + - platformdirs=2.5.2=py38h06a4308_0 + - ply=3.11=py38_0 + - prometheus_client=0.14.1=py38h06a4308_0 + - prompt-toolkit=3.0.36=py38h06a4308_0 + - psutil=5.9.0=py38h5eee18b_0 + - ptyprocess=0.7.0=pyhd3eb1b0_2 + - pure_eval=0.2.2=pyhd3eb1b0_0 + - pycparser=2.21=pyhd3eb1b0_0 + - pygments=2.11.2=pyhd3eb1b0_0 + - pylint=2.16.2=py38h06a4308_0 + - pyopenssl=23.0.0=py38h06a4308_0 + - pyparsing=3.0.9=py38h06a4308_0 + - pyqt=5.15.7=py38h6a678d5_1 + - pyqt5-sip=12.11.0=py38h6a678d5_1 + - pyrsistent=0.18.0=py38heee7806_0 + - pysocks=1.7.1=py38h06a4308_0 + - python=3.8.16=h7a1cb2a_2 + - python-dateutil=2.8.2=pyhd3eb1b0_0 + - python-fastjsonschema=2.16.2=py38h06a4308_0 + - pytz=2022.7=py38h06a4308_0 + - pyzmq=23.2.0=py38h6a678d5_0 + - qt-main=5.15.2=h327a75a_7 + - qt-webengine=5.15.9=hd2b0992_4 + - qtwebkit=5.212=h4eab89a_4 + - readline=8.2=h5eee18b_0 + - requests=2.28.1=py38h06a4308_0 + - send2trash=1.8.0=pyhd3eb1b0_1 + - setuptools=65.6.3=py38h06a4308_0 + - sip=6.6.2=py38h6a678d5_0 + - six=1.16.0=pyhd3eb1b0_1 + - sniffio=1.2.0=py38h06a4308_1 + - soupsieve=2.3.2.post1=py38h06a4308_0 + - sqlite=3.40.1=h5082296_0 + - stack_data=0.2.0=pyhd3eb1b0_0 + - terminado=0.17.1=py38h06a4308_0 + - tinycss2=1.2.1=py38h06a4308_0 + - tk=8.6.12=h1ccaba5_0 + - toml=0.10.2=pyhd3eb1b0_0 + - tomli=2.0.1=py38h06a4308_0 + - tomlkit=0.11.1=py38h06a4308_0 + - tornado=6.2=py38h5eee18b_0 + - traitlets=5.7.1=py38h06a4308_0 + - typing-extensions=4.4.0=py38h06a4308_0 + - typing_extensions=4.4.0=py38h06a4308_0 + - urllib3=1.26.14=py38h06a4308_0 + - wcwidth=0.2.5=pyhd3eb1b0_0 + - webencodings=0.5.1=py38_1 + - websocket-client=0.58.0=py38h06a4308_4 + - wheel=0.38.4=py38h06a4308_0 + - wrapt=1.14.1=py38h5eee18b_0 + - xz=5.2.10=h5eee18b_1 + - zeromq=4.3.4=h2531618_0 + - zipp=3.11.0=py38h06a4308_0 + - zlib=1.2.13=h5eee18b_0 + - zstd=1.5.2=ha4553b6_0 +prefix: /home/jeff/anaconda3/envs/spideralgorithm diff --git a/spider-algorithm.ipynb b/spider-algorithm.ipynb index be0217a..4e5c2da 100644 --- a/spider-algorithm.ipynb +++ b/spider-algorithm.ipynb @@ -2,13 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "import numpy as np\n", "import math\n", + "\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "from matplotlib.lines import Line2D" ] }, @@ -27,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -36,122 +37,156 @@ " ## It has legs that go off to infinity (or |z| = exp(2). Close enough)\n", " ## The legs land at points in C and do not cross.\n", " ## Spiders may be equivalent under a certain homotopy condition, which we currently ignore\n", - " \n", - " \n", + "\n", " ## A spider may be is defined by a rational angle\n", " ## In this case, it has legs going radially with endpoints at exp(2^j 2pi i theta)\n", - " def __init__(self, theta=0, endpoints=np.empty(0), legs=np.empty((0,0))):\n", - " if theta == 0: # If we are given the endpoints & legs\n", - " self.endpoints = endpoints # Give the endpoints\n", - " self.legs = legs # Give the legs\n", - " else: # If we are given the starting angle\n", - " angles = np.array([theta, theta*2 % 1]) # Initialize an array of angles\n", - " while not any(np.abs(angles[-1]*2 % 1 - angles[:-1]) < math.pow(10,-6)): # While the angles in the array differ by at least 10^-6\n", - " angles = np.append(angles, angles[-1]*2 % 1) # Add double the last angle to the array\n", - " self.endpoints = np.exp(2 * np.pi * 1j * angles) # The endpoints are points on the unit circle of those angles\n", - " self.legs = np.kron(np.linspace(1, 3, 100), self.endpoints[:, np.newaxis]) # Legs are straight lines perpindicular to the circle\n", - " self.divline = np.linspace(-1,1,100)*np.sqrt(self.endpoints[0]) # Constructs the appropriate line dividing the space in two halves\n", - " self.knead = [] # Initialize the kneading sequence\n", - " for point in self.endpoints: # For each endpoint\n", - " if round((point / np.sqrt(self.endpoints[0])).imag,7) > 0: # If the endpoint is in region A\n", - " self.knead.append('A') # Give it a kneading value of 'A'\n", - " elif round((point / np.sqrt(self.endpoints[0])).imag,7) < 0: # If the endpoint is in region B\n", - " self.knead.append('B') # Give it a kneading value of 'B'\n", - " elif round((point / np.sqrt(self.endpoints[0])).real,7) == -1: # If the endpoint hits the cc boundary of A\n", - " self.knead.append('*1') # Give it a kneading value of '*1'\n", - " elif round((point / np.sqrt(self.endpoints[0])).real,7) == 1: # If the endpoint hits the C boundary of A\n", - " self.knead.append('*2') # Give it a kneading value of '*2'\n", - " \n", - " def graph(self,draw_circ=False): # To graph the spider\n", - " plt.figure(figsize=(10,10)) # Makes a 10x10 grid\n", - " for leg in self.legs: # For each leg\n", - " plt.plot(leg.real, leg.imag, 'black') # Plot the leg in black\n", + " def __init__(self, theta=0, endpoints=np.empty(0), legs=np.empty((0, 0))):\n", + " if theta == 0: # If we are given the endpoints & legs\n", + " self.endpoints = endpoints # Give the endpoints\n", + " self.legs = legs # Give the legs\n", + " else: # If we are given the starting angle\n", + " angles = np.array([theta, theta * 2 % 1]) # Initialize an array of angles\n", + " while not any(\n", + " np.abs(angles[-1] * 2 % 1 - angles[:-1]) < math.pow(10, -6)\n", + " ): # While the angles in the array differ by at least 10^-6\n", + " angles = np.append(\n", + " angles, angles[-1] * 2 % 1\n", + " ) # Add double the last angle to the array\n", + " self.endpoints = np.exp(\n", + " 2 * np.pi * 1j * angles\n", + " ) # The endpoints are points on the unit circle of those angles\n", + " self.legs = np.kron(\n", + " np.linspace(1, 3, 100), self.endpoints[:, np.newaxis]\n", + " ) # Legs are straight lines perpindicular to the circle\n", + " self.divline = np.linspace(-1, 1, 100) * np.sqrt(\n", + " self.endpoints[0]\n", + " ) # Constructs the appropriate line dividing the space in two halves\n", + " self.knead = [] # Initialize the kneading sequence\n", + " for point in self.endpoints: # For each endpoint\n", + " if (\n", + " round((point / np.sqrt(self.endpoints[0])).imag, 7) > 0\n", + " ): # If the endpoint is in region A\n", + " self.knead.append(\"A\") # Give it a kneading value of 'A'\n", + " elif (\n", + " round((point / np.sqrt(self.endpoints[0])).imag, 7) < 0\n", + " ): # If the endpoint is in region B\n", + " self.knead.append(\"B\") # Give it a kneading value of 'B'\n", + " elif (\n", + " round((point / np.sqrt(self.endpoints[0])).real, 7) == -1\n", + " ): # If the endpoint hits the cc boundary of A\n", + " self.knead.append(\"*1\") # Give it a kneading value of '*1'\n", + " elif (\n", + " round((point / np.sqrt(self.endpoints[0])).real, 7) == 1\n", + " ): # If the endpoint hits the C boundary of A\n", + " self.knead.append(\"*2\") # Give it a kneading value of '*2'\n", + "\n", + " def graph(self, draw_circ=False): # To graph the spider\n", + " plt.figure(figsize=(10, 10)) # Makes a 10x10 grid\n", + " for leg in self.legs: # For each leg\n", + " plt.plot(leg.real, leg.imag, \"black\") # Plot the leg in black\n", " if draw_circ == True:\n", - " plt.plot(np.exp(np.linspace(0, 2*np.pi, 100) * 1j).real, np.exp(np.linspace(0, 2*np.pi, 100) * 1j).imag, 'black') # Plot the unit circle in black\n", - " limit=5 # Set limits for axis\n", - " plt.plot(self.divline.real,self.divline.imag,'red') # Plots the dividing line in red\n", - " plt.scatter(self.endpoints.real,self.endpoints.imag, s=20, marker='o') # Plots the endpoints of the spider in blue\n", - " i = 0 # Intializing an index\n", - " while i < len(self.endpoints): # While this is a valid index for an endpoint\n", - " plt.text(1.1*self.legs[i][99].real, 1.1*self.legs[i][99].imag,'z_'+str(i+1)) # Label the endpoints\n", - " i += 1 # Increase the index\n", - " plt.xlim((-limit,limit)) # Plot real axis\n", - " plt.ylim((-limit,limit)) # Plot imaginary axis\n", - " plt.ylabel('Imaginary') # Label the imaginary axis\n", - " plt.show() # Show the plot\n", - " \n", + " plt.plot(\n", + " np.exp(np.linspace(0, 2 * np.pi, 100) * 1j).real,\n", + " np.exp(np.linspace(0, 2 * np.pi, 100) * 1j).imag,\n", + " \"black\",\n", + " ) # Plot the unit circle in black\n", + " limit = 5 # Set limits for axis\n", + " plt.plot(\n", + " self.divline.real, self.divline.imag, \"red\"\n", + " ) # Plots the dividing line in red\n", + " plt.scatter(\n", + " self.endpoints.real, self.endpoints.imag, s=20, marker=\"o\"\n", + " ) # Plots the endpoints of the spider in blue\n", + " i = 0 # Intializing an index\n", + " while i < len(self.endpoints): # While this is a valid index for an endpoint\n", + " plt.text(\n", + " 1.1 * self.legs[i][99].real,\n", + " 1.1 * self.legs[i][99].imag,\n", + " \"z_\" + str(i + 1),\n", + " ) # Label the endpoints\n", + " i += 1 # Increase the index\n", + " plt.xlim((-limit, limit)) # Plot real axis\n", + " plt.ylim((-limit, limit)) # Plot imaginary axis\n", + " plt.ylabel(\"Imaginary\") # Label the imaginary axis\n", + " plt.show() # Show the plot\n", + "\n", " def update(self):\n", - " z_2 = self.endpoints[1] # Select z_2 so we don't have to keep calling it\n", - " i = 0 # Initialize an index\n", - " new_endpoints= np.empty(0) # Initialize an array for future endpoints\n", - " while i " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "favorite.graph(True)" ] }, { "cell_type": "code", - "execution_count": 44, - "metadata": { - "scrolled": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "favorite.update()" @@ -159,20 +194,9 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAMtCAYAAACsNfFIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmNElEQVR4nO3deZxN9ePH8fed3TIztrEPWVMiypKvbBGhRUqS7AbZU/adCaHIkDVbkbVIJSbZi5IlsmTsWQeZYZjF3Pv7437NL18Os9yZc++d1/PxuA/3nHvPOe+bacx7Pud8jsVms9kEAAAAALiHh9kBAAAAAMBZUZgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMeJkdICNZrVadO3dO/v7+slgsZscBAAAAYBKbzabr16+rYMGC8vAwHkfKVIXp3LlzCg4ONjsGAAAAACdx5swZFS5c2PD1TFWY/P39Jdn/owQEBJicBgAAAIBZoqOjFRwcnNQRjGSqwnTnNLyAgAAKEwAAAICHXqrDpA8AAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYIDCBAAAAAAGKEwAAAAAYMBlC9O4ceNksVjUu3dvs6MAAAAAcFMuWZh+++03zZw5U+XLlzc7CgAAAAA35nKF6caNG2rZsqVmz56tnDlzPvC9cXFxio6OvusBAAAAAMnlcoWpW7duaty4serVq/fQ944dO1aBgYFJj+Dg4AxICAAAAMBduFRhWrJkiXbv3q2xY8cm6/0DBw5UVFRU0uPMmTPpnBAAAACAO/EyO0BynTlzRr169VJ4eLj8/PyStY2vr698fX3TORkAAAAAd2Wx2Ww2s0Mkx6pVq/Tqq6/K09MzaV1iYqIsFos8PDwUFxd312v3Ex0drcDAQEVFRSkgICC9IwMAAABwUsntBi4zwlS3bl3t37//rnXt2rVTmTJl1L9//4eWJQAAAABIKZcpTP7+/nriiSfuWpctWzblzp37nvUAAAAA4AguNekDAAAAAGQklxlhup9NmzaZHQEAAACAG2OECQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAAAAMUJgAAAAAwACFCQAAN2Gz2TRx4kSVLl1avr6+KlSokD744AOzYwGAS/MyOwAAAHCMXr16af369Zo4caLKlSunq1ev6urVq2bHAgCXRmECAMCJnDx5UsWKFbtnfa1atbRp0ybD7Q4dOqTp06frwIEDevTRRyXpvvsBAKQMp+QBAOBEgoODdf78+aTHnj17lDt3btWsWfOB261Zs0bFixfXt99+q2LFiumRRx5Rx44dGWECgDRihAkAACfi6emp/PnzS5JiY2PVpEkTVatWTSNGjHjgdsePH9epU6e0fPlyLVy4UImJiXr33Xf1+uuv66effsqA5ADgnihMAAA4qfbt2+v69esKDw+Xh8eDTwqxWq2Ki4vTwoULVbp0aUnSZ599pqefflpHjhxJOk0PAJAynJIHAIATCg0N1bp16/TNN9/I39//oe8vUKCAvLy8ksqSJD322GOSpNOnT6dbTgBwdxQmAACczMqVKzVq1CgtW7ZMJUqUSNY21atX1+3bt3Xs2LGkdX/99ZckqWjRoumSEwAyA4vNZrOZHSKjREdHKzAwUFFRUQoICDA7DgAA9zhw4ICqVq2qPn36qFu3bknrfXx8lCtXLsPtrFarKleurOzZs2vy5MmyWq3q1q2bAgICtH79+oyIDgAuJbndgBEmAACcyK5du3Tz5k2FhoaqQIECSY+mTZs+cDsPDw+tWbNGefLkUc2aNdW4cWM99thjWrJkSQYlBwD3xAgTAAAAgEyHESYAAAAASCMKEwAALqBhw4bKnj37fR9jxowxOx4AuC3uwwQAgAuYM2eObt26dd/XHjQZBAAgbShMAAC4gEKFCpkdAQAyJU7JAwAAAAADFCYAAAAAMEBhAgAAAAADFCYAAAAAMEBhAgAAAAADFCYAAAAAMEBhAgAAAAADFCYAAAAAMEBhAgAAAAADFCYAAAAAMEBhAgAAAAADFCYAAEyybNkyff3112bHAAA8gJfZAQAAyIyWLFmit99+WxaLRb/88osqVapkdiQAwH0wwgQAQAb78ssv1bJlSyUmJqpVq1aqWLGi2ZEAAAYoTAAAZKDFixfr7bffltVqVfv27TVnzhx5enqaHQsAYIDCBABABlm0aJFatWolq9WqDh06aPbs2fLw4J9iAHBmfJcGACADfPHFF2rdurWsVqtCQkI0a9YsyhIAuAC+UwMAkM4WLlyYVJY6deqkGTNmUJYAwEXw3RoAgHQ0f/58tW3bVjabTZ07d9b06dMpSwDgQviODQBAOpk3b57at28vm82md955R59++illCQBcDN+1AQBIB3PnzlWHDh1ks9nUrVs3TZs2jbIEAC6I79wAADjYnDlzkspS9+7dFRYWJovFYnYsAEAqUJgAAHCg2bNnKyQkRJLUs2dPTZkyhbIEAC6MwgQAgIPMnDlTnTp1kiT16tVLkydPpiwBgIujMAEA4AAzZsxQly5dJEm9e/fWpEmTKEsA4AYoTAAApNGnn36qd955R5LUp08fffzxx5QlAHATFCYAANJg2rRp6tatmyTp/fff18SJEylLAOBGKEwAAKRSWFiYunfvLknq16+fxo8fT1kCADdDYQIAIBWmTJminj17SpIGDBigcePGUZYAwA1RmAAASKFJkyapV69ekqSBAwdqzJgxlCUAcFMUJgAAUuDjjz9Wnz59JEmDBw/WBx98QFkCADdGYQIAIJk++ugjvffee5KkoUOHavTo0ZQlAHBzFCYAAJJh4sSJev/99yVJw4YN08iRIylLAJAJUJgAAHiI8ePHq2/fvpKkESNGUJYAIBOhMAEA8ADjxo1T//79JUkjR47U8OHDTU4EAMhIFCYAAAx88MEHGjhwoCRp9OjRGjZsmMmJAAAZzcvsAAAAOKMPPvhAQ4YMSXo+aNAgkxMBAMzACBMAAP8jNDQ0qSyNGTOGsgQAmRiFCQCAfxk5cqSGDh0qyX790p1T8gAAmROn5AEA8F93ZsCT7p4ZDwCQeVGYAACZns1m04gRIzRq1ChJ0oQJE5LuuQQAyNwoTACATM1ms2nYsGEKDQ2VJH300Ufq06ePyakAAM6CwgQAyLRsNpuGDBmiMWPGSKIsAQDuRWECAGRKNptNgwYN0rhx4yRJkyZNUu/evc0NBQBwOi4zS97YsWNVuXJl+fv7K2/evGrSpImOHDlidiwAgAuy2WwaMGBAUln65JNPKEsAgPtymcK0efNmdevWTTt27FB4eLgSEhJUv359xcTEmB0NAOBCbDab+vfvr/Hjx0uSwsLC1LNnT5NTAQCclcVms9nMDpEakZGRyps3rzZv3qyaNWve9z1xcXGKi4tLWo6OjlZwcLCioqIUEBCQUVEBAE7CZrOpX79+mjhxoiRp6tSp6tatm8mpAABmiI6OVmBg4EO7gcuMMP2vqKgoSVKuXLkM3zN27FgFBgYmPYKDgzMqHgDAydhsNr3//vtJZenTTz+lLAEAHsolR5isVqtefvllXbt2Tdu2bTN8HyNMAADJXpb69OmjyZMnS5KmT5+uLl26mBsKAGCq5I4wueQsed26ddOBAwceWJYkydfXV76+vhmUCgDgjGw2m3r37q0pU6ZIkmbMmKHOnTubnAoA4CpcrjB1795d3377rbZs2aLChQubHQcA4MRsNpt69eqlsLAwSdLMmTPVqVMnk1MBAFyJyxQmm82mHj166Ouvv9amTZtUrFgxsyMBAJyYzWZTz549NXXqVFksFs2aNUsdO3Y0OxYAwMW4TGHq1q2bFi9erNWrV8vf318XLlyQJAUGBipLliwmpwMAOJM7v2SbNm2aLBaL5syZo/bt25sdCwDgglxm0geLxXLf9fPmzVPbtm2TtY/kXtgFAHBdVqtV3bt31/Tp02WxWPTZZ5+pXbt2ZscCADgZt5v0wUV6HQDARFarVV27dtXMmTNlsVg0d+7cZP9SDQCA+3GZwgQAwINYrVZ16dJFs2fPlsVi0fz589W6dWuzYwEAXByFCQDg8qxWqzp37qw5c+bIw8NDCxYs0Ntvv212LACAG6AwAQBcmtVqVUhIiObOnSsPDw99/vnneuutt8yOBQBwExQmAIDLslqt6tixo+bNm0dZAgCkCwoTAMAlJSYmqmPHjpo/f748PDy0aNEivfnmm2bHAgC4GQoTAMDlJCYmqkOHDlqwYIE8PT21aNEiNW/e3OxYAAA3RGECALiUxMREtWvXTp9//rk8PT21ePFivfHGG2bHAgC4KQoTAMBlJCYmqm3btvriiy/k6empJUuW6PXXXzc7FgDAjVGYAAAu4fbt22rTpo0WL14sLy8vLVmyRK+99prZsQAAbo7CBABwerdv31arVq20ZMkSeXl5aenSpWratKnZsQAAmQCFCQDg1G7fvq23335bS5culZeXl5YtW6ZXX33V7FgAgEyCwgQAcFq3b99Wy5YttWzZMnl7e2v58uV65ZVXzI4FAMhEKEwA4GaOR97Qqas39UjubCqWJ5vZcVItISFBLVu21PLly+Xt7a2VK1fqpZdeMjsWACCToTABgJu4djNePb/cqy1HI5PW1SwVpLAWFRWY1dvEZCmXkJCgFi1aaOXKlfLx8dGKFSsoSwAAU3iYHQAA4Bg9v9yr7RGX71q3PeKyeny5x6REqZOQkKA333wzqSx99dVXlCUAgGkoTADgBo5H3tCWo5FKtNnuWp9os2nL0UiduBxjUrKUiY+PV/PmzfXVV1/Jx8dHX3/9tRo3bmx2LABAJkZhAgA3cOrqzQe+fvKK8xem+Ph4vfHGG/r666/l6+ur1atXq1GjRmbHAgBkclzDBABuoGiurA98/ZHczj35Q3x8vJo1a6ZvvvkmqSw1aNDA7FgAADDCBADuoHhQdtUsFSRPi+Wu9Z4Wi2qWCnLq2fLi4uL0+uuvJ5Wlb775hrIEAHAaFCYAcBNhLSqqesk8d62rXjKPwlpUNCnRw8XFxem1117TmjVr5OfnpzVr1qh+/fpmxwIAIAmn5AGAmwjM6q2FHaroxOUYnbwS4/T3YYqNjdVrr72m77//XlmyZNE333yjevXqmR0LAIC7UJgAwM0Uy+PcRUmyl6WmTZtq7dq1ypIli9asWaO6deuaHQsAgHtQmAAAGSo2NlavvvqqfvjhB2XJkkXfffed6tSpY3YsAADui2uYAAAZ5tatW2rSpIl++OEHZc2aVd9//z1lCQDg1BhhAgBkiFu3bumVV15ReHh4UlmqVauW2bEAAHggRpgAAOnu5s2bevnllxUeHq5s2bJp7dq1lCUAgEtghAkAkK7ulKUNGzYklaUaNWqYHQsAgGShMAEA0k1MTIxeeuklbdy4UdmzZ9fatWv17LPPmh0LAIBkozABANJFTEyMXnzxRW3atEn+/v5au3atqlevbnYsAABShMIEAHC4mJgYNW7cWJs3b5a/v7/WrVunatWqmR0LAIAUozABABzqxo0baty4sbZs2SJ/f3+tX79ezzzzjNmxAABIFWbJAwA4zPXr19WoUSNt2bJFAQEBCg8PpywBAFwahQkAkDKJifddff36dTVs2FBbt25VYGCgwsPDVbVq1QwOBwCAY1GYAADJ9/ff0pNPSuvXS5KOR97QxiOX9MeJ83rhhRe0ffv2pLJUpUoVk8MCAJB2XMMEAEieS5ekevWkI0eU2Ptddeg9W5uO/yNr3E1dWjZMcecOKzBHDv0YHq5KlSqZnRYAAIegMAEAHu6ff6T69aUjR6TgYL3fdoy2nrgma1yMLi4bpvhzR+Thl13Vu0+mLAEA3Aqn5AEAHuz6dalhQ2nfPilfPp1e/o2+vuqlhNgburj0/8tS3uah+jMhj05cjjE7MQAADkNhAgAYu3VLevllaedOKVcu6ccfdSxHQUnS9b0/KP78EXn4+Svfmx/IN39JSdLJKxQmAID74JQ8AMD9xcdLr70mbdok+ftL69ZJTzyhopE3JEkBVV6V9WaUsj1eWz75iidt9kjubCYFBgDA8RhhAgDc6/ZtqWVLae1aKUsW6bvvpP9em1Q8KLtqlgqSl4enctZpn1SWPC0W1SwVpGJ5KEwAAPdBYQIA3M1qlTp0kFaskHx8pFWrpBo17npLWIuKql4yz13rqpfMo7AWFTMwKAAA6Y9T8gAA/89mk3r0kBYulDw9pWXL7LPj/Y/ArN5a2KGKTlyO0ckrMXokdzZGlgAAbonCBACws9mk/v2lTz+VLBbp88+lV1554CbF8lCUAADujVPyAAB2o0dLEybYn8+aJbVoYW4eAACcAIUJACBNmiQNH/7/zzt2NDcPAABOgsIEAJndrFlSnz7256NHS717mxoHAABnQmECgMxs0SKpSxf78379pMGDzc0DAICToTABQGa1apXUpo19soeuXaVx4+yTPQAAgCQUJgDIjNavl5o3lxIT7aUpLIyyBADAfVCYACCz2bpVatJEio+XXn9dmjNH8uCfAwAA7od/IQEgM/ntN6lxY+nWLalRI/s1TF7ckg8AACMUJgDILPbvlxo0kK5fl2rXllaskHx8zE4FAIBTozABQGbw11/S889L//wjPfOM9M03UpYsZqcCAMDpUZgAwN2dOiXVqyddvChVqCB9/73k7292KgAAXAKFCQDc2fnzUt260pkzUpky9tnxcuY0OxUAAC6DwgQA7uryZfvI0rFjUrFi0o8/SkFBZqcCAMClUJgAwB1du2af4OHgQalQIWnDBvufAAAgRShMAOBuYmLsU4fv3m0fUfrxR/sIEwAASDEKEwC4k9hY6ZVXpJ9/lnLkkMLD7dcuAQCAVKEwAYC7SEiQ3njDfvpd9uzS2rXSk0+anQoAAJdGYQIAd5CYKLVqJa1ZI/n52f985hmzUwEA4PIoTADg6qxWqVMnaelSydtbWrlSql3b7FQAALgFChMAuDKbTerdW5o7V/LwkL78UmrUyOxUAAC4DQoTALiyIUOksDD78/nzpddeMzUOAADuhsIEAK5q7FhpzBj7808/tV/DBAAAHIrCBACuaOpUadAg+/MJE6R33jE3DwAAborCBACuZt48qUcP+/Nhw6T33zc3DwAAbozCBACuZOlSqWNH+/P33pNGjDA1DgAA7o7CBACuYs0a6e23/38a8QkTJIvF7FQAALg1ChMAuIING6RmzaTbt6WWLe2TPFCWAABIdxQmAHB2P/8svfyyFBcnNWlinz7c09PsVAAAZAoUJgBwZrt3Sw0bSjdvSg0aSEuWSF5eZqcCACDToDABgLP680+pfn0pOlqqUUP66ivJ19fsVAAAZCoUJgBwRhER0vPPS1euSJUrS99+K2XNanYqAAAyHQoTADibM2ekunWl8+elcuWkH36QAgLMTgUAQKZEYQIAZ3LxolSvnnT6tFS6tLR+vZQrl9mpAADItChMAOAsrl61n4b3119S0aLSjz9K+fObnQoAgEyNwgQAziA6WnrhBWn/fqlAAft9l4KDzU4FAECmR2ECALPdvCm9+KL0229S7tz2kaUSJcxOBQAARGECAHPFxUlNm0pbt9ondli/Xnr8cbNTAQCA/6IwAYBZEhKkN9+U1q2zTxm+dq301FNmpwIAAP9CYQIAM1itUrt20qpV9pvRfvON9J//mJ0KAAD8DwoTAGQ0m0165x1p0SLJy0tavtx+3yUAAOB0KEwAkJFsNum996RZsyQPD+mLL6SXXjI7FQAAMEBhAoCMNGKENGmS/fns2VLz5qbGAQAAD0ZhAoCMMmGCNGqU/fmUKVL79ubmAQAAD0VhAoCM8OmnUr9+9udjxkg9epibBwAAJAuFCQDS28KFUrdu9ueDBkkDB5qbBwAAJBuFCQDS08qV9unDJalnTyk01Nw8AAAgRShMAJBe1q6VWrSw33OpfXv7ZA8Wi9mpAABAClCYACA9bNokNW0qJSTYZ8K7M404AABwKfzrDQCOtnOn/d5KsbH2Pz//XPL0NDsVAABIBQoTADjS3r3SCy9IN25IdetKy5ZJ3t5mpwIAAKlEYQIARzl8WKpfX7p2TapeXVq9WvLzMzsVAABIAwoTADjCiRNSvXpSZKT01FPSd99J2bKZnQoAAKQRhQkA0ursWfvpd2fPSo8/Lq1bJwUGmp0KAAA4AIUJANLi0iX7yNKJE1KJEtKPP0p58pidCgAAOAiFCQBS659/7NcsHT4sFS4sbdggFShgdioAAOBAFCYASI3r16VGjaR9+6R8+exlqWhRs1MBAAAHozABQErduiW98oq0Y4eUM6cUHi6VLm12KgAAkA4oTACQEvHx0uuvSxs3Sv7+9gkeypUzOxUAAEgnFCYASK7bt6WWLaXvv5eyZJG+/VaqXNnsVAAAIB1RmAAgOaxWqUMHacUKycdH+vprqWZNs1MBAIB0RmECgIex2aQePaSFCyVPT2nJEqlBA7NTAQCADEBhAoAHsdmkAQOkTz+VLBZ7aXr1VbNTAQCADEJhAoAHCQ2Vxo+3P585U3rrLXPzAACADEVhAgAjkydLw4bZn0+aJIWEmBoHAABkPAoTANzP7NnSu+/an48aJfXubWocAABgDgoTAPyvL7+UOne2P+/XTxoyxNw8AADANBQmAPi31aulVq3skz107SqNG2ef7AEAAGRKFCYAuGP9eumNN6TERKl1ayksjLIEAEAmR2ECAEnaulVq0kSKj5dee0367DPJg2+RAABkdvw0AAC7dkmNG0u3bkkNG0qLF0teXmanAgAAToDCBCBz279fatBAun5dql1bWrlS8vExOxUAAHASFCYAmddff0nPPy9dvSpVrSp9842UJYvZqQAAgBNJVWFq06aNtmzZ4ugsAJBxTp2S6tWTLl6UnnxSWrtW8vc3OxUAAHAyqSpMUVFRqlevnkqVKqUxY8bo7Nmzjs4FAOnn/Hmpbl3pzBmpTBn77Hg5c5qdCgAAOKFUFaZVq1bp7Nmzeuedd7R06VI98sgjatiwoVasWKGEhARHZwQAx7l82X4a3rFjUrFi0o8/Snnzmp0KAAA4qVRfwxQUFKQ+ffpo37592rlzp0qWLKlWrVqpYMGCevfdd3X06FFH5gSAtIuKsk/w8OefUsGC0oYNUqFCZqcCAABOLM2TPpw/f17h4eEKDw+Xp6enGjVqpP379+vxxx/XpEmTHJERANIuJsY+dfju3VJQkL0sFStmdioAAODkUlWYEhIStHLlSr344osqWrSoli9frt69e+vcuXNasGCBfvzxRy1btkyjRo1ydF4ASLnYWPtNabdvl3LksF+zVKaM2akAAIALSNWdGQsUKCCr1aoWLVro119/VYUKFe55T506dZQjR440xgOANEpIkN54w36tUrZs9tnw7vM9CwAA4H5SVZgmTZqkZs2ayc/Pz/A9OXLk0IkTJ1IdDADSLDFRatVKWrNG8vOz//nMM2anAgAALiTFp+QlJCSoXbt2ioiISI88AOAYVqvUqZO0dKnk5SWtXCnVqWN2KgAA4GJSXJi8vb1VpEgRJSYmpkceAEg7m016911p7lzJw0P68kupUSOzUwEAABeUqkkfBg8erEGDBunq1auOzgMndDzyhjYeuaQTl2PMjgIkz9Ch0pQp9udz50qvv25uHgAA4LJSdQ3T1KlTFRERoYIFC6po0aLKli3bXa/v3r3bIeFgrms349Xzy73acjQyaV3NUkEKa1FRgVm9TUwGPMC4cdIHH9ifT5smtWljbh4AAODSUlWYmjRp4uAYcEY9v9yr7RGX71q3PeKyeny5Rws7VDEpFfAAU6dKAwfan3/4odS1q7l5AACAy0tVYRo+fLijc8DJHI+8cdfI0h2JNpu2HI3UicsxKpYn2322BEwyb57Uo4f9+dChUr9+5uYBAABuIVXXMMH9nbp684Gvn7zC9UxwIsuXSx072p+/+640cqS5eQAAgNtI1QhTYmKiJk2apGXLlun06dOKj4+/63Umg3B9RXNlfeDrj+RmdAlO4ttvpbfesk8jHhIiffSRZLGYnQoAALiJVI0wjRw5Uh9//LGaN2+uqKgo9enTR02bNpWHh4dGjBjh4IgwQ/Gg7KpZKkie//ODp6fFopqlgjgdD87hp5/sM+Ddvm0vTdOnU5YAAIBDpaowLVq0SLNnz9Z7770nLy8vtWjRQnPmzNGwYcO0Y8cOR2eEScJaVFT1knnuWle9ZB6FtahoUiLgX37+WXr5ZSkuTmrSRJo/X/L0NDsVAABwM6k6Je/ChQsqV66cJCl79uyKioqSJL344osaOnSo49LBVIFZvbWwQxWduByjk1di9EjubIwswTns3m2/EW1MjFS/vrRkieTNVPcAAMDxUjXCVLhwYZ0/f16SVKJECa1fv16S9Ntvv8nX19dx6eAUiuXJpjqP5qUswTncvCk1bChFRUk1akhffy3xfQcAAKSTVBWmV199VRs2bJAk9ejRQ0OHDlWpUqXUunVrtW/f3qEBAeAuERHSpUtS9uz2CR+yPniCEgAAgLSw2Gw2W1p38ssvv+iXX35RqVKl9NJLLzkiV7qIjo5WYGCgoqKiFBAQYHYcAKnx11/So49KAQH2USYAAIBUSG43cMh9mKpVq6Y+ffo4dVkC4CbunH4XF2duDiCZYmNj1bZtW5UrV05eXl5q0qSJ2ZGQQkeOHFGdOnWUL18++fn5qXjx4hoyZIgSEhLMjgYgA6Rq0gdJOnr0qDZu3KhLly7JarXe9dqwYcPSHAwA7uvfhclmYxpxOL3ExERlyZJFPXv21MqVK82Og1Tw9vZW69at9dRTTylHjhzat2+fQkJCZLVaNWbMGLPjAUhnqSpMs2fP1jvvvKM8efIof/78svzrBxaLxUJhApB+/j3BQ0KC5ONjXhZkKidPnlSxYsXuWV+rVi1t2rTJcLts2bJp+vTpkqTt27fr2rVr6ZQQD5Pav8PixYurePHiSctFixbVpk2btHXr1vSICcDJpKowhYaG6oMPPlD//v0dnQcAHuzfhSkujsKEDBMcHJw0Q6xkv8VGvXr1VLNmTRNTISUc9XcYERGhH374QU2bNnV0RABOKFWF6Z9//lGzZs0cnQUAHu5/C5O/v3lZkKl4enoqf/78kuzXJTVp0kTVqlXTiBEjzA2GZEvr3+F//vMf7d69W3FxcerUqZNGjRqVjmkBOItUTfrQrFmzpHsvAUCG8vSUvP77u57YWHOzwCUdj7yhjUcu6cTlmFTvo3379rp+/boWL14sDw+HzJ+EDJaav8OlS5dq9+7dWrx4sb777jtNnDgxnVMCcAapGmEqWbKkhg4dqh07dqhcuXLy9va+6/WePXs6JNz9TJs2TRMmTNCFCxf05JNPKiwsTFWqVEm34wFwQr6+0u3bzJSHFLl2M149v9yrLUcjk9bVLBWksBYVFZjV+wFb3i00NFTr1q3Tr7/+Kn9GOF1Sav8Og4ODJUmPP/64EhMT1alTJ7333nvy9PRMr6gAnECq7sN0vwsmk3Zosej48eNpCmVk6dKlat26tWbMmKGqVatq8uTJWr58uY4cOaK8efM+dHvuwwS4B1vu3LJcvaorW7Yo8dFH73ndarXq8uXLD1yXkuX7PX/QOqvVqpiY1I9eAJlJ1qxZ5eHhody5cysoKEhBQUH3LP/74eHhoTx58iQ9z5o1612TTz3MypUr1aJFC61du1Z169ZNde6FCxeqQ4cOunnz5j2/OAbgGpLbDRxy49qMUrVqVVWuXFlTp06VZP8hJTg4WD169NCAAQPueX9cXJzi/vUb6OjoaAUHB1OYABdmtVp13tNThSRVlLTX5DwAzHXjxg1ly5YtWe89cOCAqlatqj59+qhbt25J6318fJQrVy7D7RYtWiRvb2+VK1dOvr6+2rVrl959913VqVNHX3zxRZo/AwBzZOiNazNCfHy8fv/9d9WrVy9pnYeHh+rVq6dffvnlvtuMHTtWgYGBSY87Q+kAXNudX4P4PvBdAHC3Xbt26ebNmwoNDVWBAgWSHg+b7c7Ly0sffvihqlSpovLly2vkyJHq3r275syZk0HJAZgp2SNMffr00ejRo5UtWzb16dPnge/9+OOPHRLu386dO6dChQrp559/VrVq1ZLW9+vXT5s3b9bOnTvv2YYRJsA92R57TJbDh/XPV18poXr1e17nlDzAdWT0KXkAcEdyR5iSPenDnj17lJCQkPTciDN90/L19ZWvL7+DBtyN5b//X+fMmlUyuH7xztTBwB2tP/tV2yMuK/Ffvyf0tFhUvWQeLezA5EEAgPtLdmHauHHjfZ9nlDx58sjT01MXL168a/3Fixf5wQjIbO78IoRZ8pACYS0qqseXe+6aJa96yTwKa1ExTftt2LChtm7det/XBg0apEGDBqVp/0h//B0CeJBUTStuBh8fHz399NPasGGDmjRpIsl+GsyGDRvUvXt3c8MByFh+fvY/KUxIgcCs3lrYoYpOXI7RySsxeiR3NhXLk7zJAh5kzpw5unXr1n1fe9BEAnAe/B0CeJBUFaZXX331vqfeWSwW+fn5qWTJknrrrbf06H2m+02LPn36qE2bNqpUqZKqVKmiyZMnKyYmRu3atXPocQA4OUaYkAbF8jimKN1RqFAhh+0L5uDvEMCDpGqWvMDAQP3000/avXu3LBaLLBaL9uzZo59++km3b9/W0qVL9eSTT2r79u0ODdu8eXNNnDhRw4YNU4UKFbR371798MMPypcvn0OPA8DJ3SlMsbHm5gAAAG4vVSNM+fPn11tvvaWpU6fKw8PeuaxWq3r16iV/f38tWbJEXbp0Uf/+/bVt2zaHBu7evTun4AGZHSNMAAAgg6RqhOmzzz5T7969k8qSZL8nUo8ePTRr1ixZLBZ1795dBw4ccFhQAEhCYQIAABkkVYXp9u3bOnz48D3rDx8+rMTEREmSn5+fU00xDsCNMOkDAADIIKk6Ja9Vq1bq0KGDBg0apMqVK0uSfvvtN40ZM0atW7eWJG3evFlly5Z1XFIAuOPOCNO+fZLNJvHLGQAAkE4sNtu/7uCXTImJiRo3bpymTp2adF+kfPnyqUePHurfv788PT11+vRpeXh4qHDhwg4PnVrJvZsvACf33XfSiy/an3foIM2cKXl6mpsJAAC4lOR2g1QVpv89kCSXKCAUJsCNzJ9vL0tWq9SsmfTFF5KPj9mpAACAi0huN0jVNUz/FhAQQPkAkPHatpWWLZO8vaXly6VXXpFu3jQ7FQAAcDOpuoZJklasWKFly5bp9OnTio+Pv+u13bt3pzkYADzUa69Ja9ZIr74q/fCD1KCB9O23UmCg2ckAAICbSNUI05QpU9SuXTvly5dPe/bsUZUqVZQ7d24dP35cDRs2dHRGADDWoIEUHm4vSdu2Sc89J0VGmp0KAAC4iVRdw1SmTBkNHz5cLVq0kL+/v/bt26fixYtr2LBhunr1qqZOnZoeWdOMa5gAN7Z3r1S/vr0slSljL1FONOkMnMP48eMVGxurwoULq3DhwgoODlZwcLCyZ89udjQAQAZL10kfsmbNqkOHDqlo0aLKmzevwsPD9eSTT+ro0aN65plndOXKlTSFTy8UJsDNHTki1asn/f23VLSo9OOPUsmSZqeCEylWrJhOnjx5z/ocOXLcVaD+/fzOctasWTM+MAAg3SS3G6TqGqb8+fPr6tWrKlq0qIoUKaIdO3boySef1IkTJ5TGSfcAIPUefdR+Wt7zz0tHj0o1akjr10vlypmdDE6iU6dOOn78uM6cOaMzZ87o77//VnR0tK5du6Zr167pwIEDhtvmypUrqUjdr1AVLlxYWbJkycBPAwDICKkaYerYsaOCg4M1fPhwTZs2TX379lX16tW1a9cuNW3aVJ999ll6ZE0zRpiATOLiRfvpeX/8IeXMKa1dK1WtanYqOKno6Gj9/fffd5Wofy+fOXNGN27cSNa+8uTJc89I1b+XCxUqJD8/v3T+RACA5EjXU/KsVqusVqu8vOwDVEuWLNHPP/+sUqVKqXPnzvJx0nuhUJiATOSff6RGjaQdO6Rs2eyz6dWpY3YquKioqKikMvXvYvXvUnUzmdPaBwUF3XeU6s66QoUKOe2/owDgTjLsxrWuhMIEZDI3bkhNmkgbNki+vvb7Nr38stmp4IZsNpuuXbtmWKbuLMfGxiZrf/ny5Xvg9VQFCxaUt7d3On8qAHBv6V6YYmNj9ccff+jSpUuyWq13vfayk/5AQmECMqHYWOnNN6XVqyVPT2nBAqllS7NTIROy2Wy6evXqA0vV33//rbi4uIfuy2KxKH/+/IaFKjg4WAUKFEg6EwQAcK90LUw//PCDWrdurcuXL9+7Q4tFiYmJKd1lhqAwAZnU7dtS+/bS559LFos0bZr0zjtmpwLuYbPZdPny5QeOUv39999KSEh46L48PDxUoECBe0rVv5/nz59fnp6eGfDJAMD5pGthKlWqlOrXr69hw4YpX758aQqakShMQCZmtUo9e9rLkiSNHSsNGGBuJiAVrFarIiMj7ztSdef52bNndfv27Yfuy9PTUwULFryrSBUuXFhFihRJmrAif/788vBI1X3uXd7JkydVrFixe9b/8ssveuaZZ0xIBMCR0rUwBQQEaM+ePSpRokSaQmY0ChOQydls0pAh0pgx9uUBA+zPLRZzcwEOZrVadfHixQeOVJ07dy5ZZ4R4eXmpUKFCDzz9LygoyC1L1Z3C9OOPP6ps2bJJ63Pnzs01ZIAbSNf7ML3++uvatGmTyxUmAJmcxSJ98IEUGCj17y+NGydFRUlTp0pu+MMeMq87p+MVKFBAVapUue97EhMTdeHCBcNRqr///lvnzp3T7du3derUKZ06dcrweN7e3neNUN2vWAUFBcli0i8njEaKatWqpU2bNj10+9y5cyt//vzpkAyAK0jVCNPNmzfVrFkzBQUFqVy5cvf8lqVnz54OC+hIjDABSDJrltSli33UqWVLad48id8YA3e5ffu2zp8/f98ydefP8+fPJ+um9b6+voZl6s663Llzp0upSkxMVGRkZNLyhQsXVK9ePXXt2lWjRo0y3O5O0QoODlZsbKxKly6tfv36Oe3kVgBSJl1Pyfvss8/UpUsX+fn53fPNzWKx6Pjx46lLnc4oTADusmSJ1KqVfVKIl1+Wli6VuKkokCIJCQk6d+7cPUXq9OnTScuXLl1KVqnKkiXLQ0eqcubMmaZSFRsbq9q1aysoKEirV69+4KmEly9f1sKFC1W9enV5eHho5cqVGj9+vFatWkVpAtxAuham/Pnzq2fPnhowYIBLnbNMYQJwj+++k15/3T79+HPP2acfz57d7FSAW4mPj9fZs2cfOPPfpUuXkrWvrFmzKjg4WHv37pVfKn7B8dZbb2nfvn3asWOH/P39U7x969atdeLECW3dujXF2wJwLul6DVN8fLyaN2/uUmUJAO6rcWNp7VrppZekn36S6tWTvv9eypXL7GSA2/Dx8VGxYsXuex3RHbGxsTp79uwDr6m6fPmybt68qQsXLqSqLIWGhmrdunX69ddfU1WWJKlq1aoKDw9P1bYAXFOqClObNm20dOlSDRo0yNF5ACDj1a4tbdggNWwo7dxpX16/XuIibyDD+Pn5qUSJEg+cUOrWrVs6e/asrly5kuL9r1y5UqNGjdLatWvTNGnV3r17VaBAgVRvD8D1pKowJSYmavz48Vq3bp3Kly9/z6QPH3/8sUPCAUCGqVJF2rxZql9f2r9fqlFD+vFHqWhRs5MB+K8sWbKoZMmSKlmyZIq2O3DggFq3bq3+/furbNmyunDhgiT7yFeuB4wmL1iwQD4+PqpYsaIk6auvvtLcuXM1Z86c1H8IAC4nVYVp//79Sd88Dhw44NBAAGCaJ56Qtm61n5YXESE9+6wUHi6VKWN2MgBpsGvXLt28eVOhoaEKDQ1NWp+cacVHjx6tU6dOycvLS2XKlNHSpUv1+uuvp3NiAM4kVZM+uComfQCQLGfPSs8/Lx06JOXJI61bJz31lNmpAACAA6XLpA9NmzZ96HssFotWrlyZkt0CgHMpVEjaskV64QXp99+lOnXss+k9+6zZyQAAQAZL0TR3gYGBD30wcgPALeTJY58IomZNKTrafm3TunVmpwLgQA0bNlT27Nnv+xgzZozZ8QA4CU7JA4AHuXnTfp+mtWslb29p8WL7MgCXd/bsWd26deu+r+XKleuBE0IAcH3peuNaV0VhApAq8fFSq1bSsmWSh4c0Z47Urp3ZqQAAQBoktxtw51kAeBgfH/vIUseOktUqtW8vffKJ2akAAEAGoDABQHJ4ekqzZknvvWdf7t1bGjlSyjyD9AAAZEoUJgBILotFmjBBGj3avjxihL1AUZoAAHBbFCYASAmLRRoyRJoyxb48aZL9VL3ERHNzAQCAdEFhAoDU6NFDmj/fPgnE3LnSm2/aJ4cAAABuhcIEAKnVpo20fLl9UogVK6RXXrFPQw4AANwGhQkA0qJpU2nNGilrVumHH6QGDaSoKLNTAQAAB6EwAUBa1a8vrV8vBQZK27ZJdepIkZFmpwIAAA5AYQIAR6heXdq0SQoKkvbskWrWlP7+2+xUAAAgjShMAOAoFSpIW7dKhQtLhw9Lzz4rRUSYnQoAAKQBhQkAHOnRR+2n5ZUqJZ06ZS9N+/ebnQoAAKQShQkAHK1oUWnLFql8eeniRalWLWnnTrNTAQCAVKAwAUB6yJ/ffk3TM89I//wj1a0rbdxodioAAJBCFCYASC85c0rh4VK9elJMjNSwofTNN2anAgAAKUBhAoD0lD27/T5NTZpIcXH2+zYtWmR2KgAAkEwUJgBIb35+0vLlUqtWUmKi/c/p081OBQAAkoHCBAAZwctLmj9f6t5dstmkrl2lcePMTgUAAB6CwgQAGcXDQ5oyRRo82L48cKA0YIC9QAEAAKdEYQKAjGSxSKGh0vjx9uUPP7SPNlmt5uYCAAD3RWECADP07SvNnGkvUDNmSK1bSwkJZqcCAAD/g8IEAGbp1ElavNh+fdOiRdLrr0uxsWanAgAA/0JhAgAzvfmmtGqVfSa9b76RGjWSrl83OxUAAPgvChMAmK1xY2ntWvs9mzZulJ5/Xrp61exUAABAFCYAcA61a0s//STlyiXt3CnVqiWdP292KgAAMj0KEwA4i8qVpS1bpAIFpAMHpBo1pJMnzU4FAECmRmECAGdStqy0bZtUrJh07Jj07LPSoUNmpwIAINOiMAGAsyleXNq6VXr8censWalmTWn3brNTAQCQKVGYAMAZFSokbd4sPf20dPmyVKeOvUQBAIAMRWECAGeVJ499IoiaNaXoaKlBA+mHH8xOBQBApkJhAgBnFhBgn3K8YUPp1i3p5Zel5cvNTgUAQKZBYQIAZ5c1q/3mts2bSwkJ9pvdzp1rdioAADIFChMAuAIfH2nRIikkRLJapQ4dpMmTzU4FAIDbozABgKvw9JRmzpTee8++/O670ogRks1maiwAANwZhQkAXInFIk2YII0ebV8eOVLq08c+6gQAAByOwgQArsZikYYMkaZMsS9Pnix17Cjdvm1qrPQ0c+ZMXbhwwewYAIBMiMIEAK6qRw9pwQLJw0OaN09q0UKKizM7lcNt27ZNXbp0UcmSJTVy5EjFxMSYHQkAkIlQmADAlbVuLa1YYZ8UYsUK6ZVXpJs3zU7lUH5+fqpSpYpiYmI0YsQIlSxZUrNnz9ZtNx5RAwA4DwoTALi6V1+Vvv3WPv34unX2G9xGRZmdymEqVaqkHTt2aMmSJSpevLguXLigTp066cknn9S3334rG5NeAADSEYUJANzB889L4eFSjhzStm1SnTpSZKTZqRzGYrGoefPmOnTokCZPnqxcuXLp4MGDeumll/Tcc89p165dZkcEALgpChMAuIv//EfatEnKm1fas0eqUUP6+2+zU6XY8cgb2njkkk5cvvdaJR8fH/Xq1UvHjh1Tv3795Ovrq02bNqly5cpq0aKFTpw4YUJiAIA7s9gy0bkM0dHRCgwMVFRUlAICAsyOAwDp46+/pHr1pDNnpKJFpR9/lEqWNDvVQ127Ga+eX+7VlqP/PzJWs1SQwlpUVGBW7/tuc/r0aQ0ZMkRffPGFbDabfHx81L17dw0ePFi5cuXKqOgAABeU3G7ACBMAuJvSpe2n5ZUqJZ06JT37rLR/v9mpHqrnl3u1PeKybDarrHH2iSu2R1xWjy/3GG5TpEgRLVy4UL///rvq1aun+Ph4ffzxxypRooQmTpyo2NjYjIoPAHBTFCYAcEdFikhbt0rly0sXL0q1akk7d5qdytDxyBvacjRSiTabbvwRrnNzuijm8Dbdtlq15WjkfU/P+7eKFStq/fr1Wrt2rcqVK6dr166pb9++KlOmjBYtWiQrN/YFAKQShQkA3FW+fPZrmqpVk/75R6pbV/rpJ7NT3depq/YRJZvNphv71ivxxlVdXj1OkStH6XbURZ288vB7L1ksFr3wwgvas2eP5s2bp0KFCunUqVN6++23VblyZf3kpJ8dAODcKEwA4M5y5pTWr7df0xQTIzVqJK1ebXaqexTNlVWSvfTkf2usAv/zpuThpVvHftO5z7pq/ZezlZCQkKx9eXp6qm3btvrrr7/0wQcfyN/fX7t371bdunXVuHFj/fnnn+n5UQAAbobCBADuLnt2+32aXn1ViouTXntNWrTI7FR3KR6UXTVLBcnTYpHFy0c5arytgu3C5Bf8hGwJcRo3cogqVaqknSk4rTBr1qwaNGiQjh07ph49esjLy0vff/+9ypcvr44dO+rcuXPp+IkAAO6CwgQAmYGvr7RsmdS6tZSYKLVqJU2fbnaqu4S1qKjqJfMkLXvnCdbrw+Zo6vTZypUrl/744w9Vq1ZN3bp1U1QKbswbFBSkKVOm6ODBg3rttddktVr12WefqWTJkho6dKiuX7+eHh8HAOAmmFYcADITq1Xq1UuaOtW+PHasNGCAuZn+x4nLMTp5JUaP5M6mYnmySZIiIyP1/vvva+HChZKkAgUK6JNPPtHrr78ui8WSov3/8ssvev/99/Xzzz9LsheqESNGKCQkRN7e95++HADgfphWHABwLw8PacoUafBg+/LAgfbC5ES/OyuWJ5vqPJo3qSxJ9lKzYMECbdiwQaVLl9b58+f1xhtvqHHjxim+WW21atW0bds2rVy5UqVKlVJkZKS6deumJ554Ql9//bUy0e8RAQDJQGECgMzGYpFCQ6UJE+zLH34ode1qH31ycs8995z27dun4cOHy8fHR2vXrlXZsmU1fvz4ZE8KIdknl2jatKn+/PNPTZ06VUFBQfrrr7/UtGlT1axZUzt27EjHTwEAcCUUJgDIrN5/X5o5016gZsywX9eUgtJhFj8/P40YMUJ//PGHateurVu3bql///56+umn9csvv6RoX97e3urWrZsiIiI0ePBgZcmSRdu2bVO1atXUrFkzRUREpNOnAAC4CgoTAGRmnTpJX34peXlJixfbZ9CLjTU7VbI8+uij+umnn7RgwQLlzp1b+/fvV/Xq1fXOO+/o2rVrKdpXQECAQkNDdfToUbVv314Wi0UrVqzQ448/rl69euny5cvp8yEAAE6PwgQAmV3z5tKqVZKfn7Rmjf1eTS4yc5zFYlHr1q11+PBhtW3bVjabTTNmzFCZMmW0dOnSFF+PVKhQIX322Wfat2+fGjZsqISEBE2ZMkUlSpTQ2LFjdevWrXT6JAAAZ0VhAgBIjRtLa9fa79m0caP9RrdXr5qdKtny5MmjefPmaePGjXr00Ud18eJFvfnmm2rUqJGOHz+e4v2VK1dO33//vcLDw1WhQgVFR0dr0KBBKl26tObPn6/ExMR0+BQAAGdEYQIA2NWubS9LuXNLv/4q1aolnT9vdqoUqV27tvbt26cRI0bIx8dHP/zwg5544gmNGzcuRZNC3FGvXj39/vvvWrhwoYoUKaK///5b7dq101NPPaV169alwycAADgbChMA4P9VqiRt2SIVLCgdOCA9+6yUwmm7zebr66vhw4dr//79eu6553Tr1i0NHDhQTz31VNK9l1LCw8NDrVq10pEjRzR+/HgFBgbqjz/+0AsvvKD69etr7969jv8QAACnQWECANzt8celrVulYsWk48elGjWkQ4fMTpVipUuX1o8//qgFCxYoT548OnDggKpXr64uXbron3/+SfH+/Pz81LdvXx07dky9e/eWt7e3wsPD9dRTT6lNmzY6c+ZMOnwKAIDZKEwAgHsVLy5t22YvT2fPSjVrSrt3m50qxf49KUS7du0kSTNnzlSZMmX05Zdfpuomtblz59akSZN0+PBhNW/eXDabTQsXLlTp0qU1cOBARUVFOfpjAABMRGECANxfwYLS5s320/QuX5bq1LGPPLmg3Llza+7cudq0aZPKlCmjS5cu6a233tILL7yQqkkhJKl48eJasmSJfv31V9WqVUuxsbEaN26cSpQooSlTpig+Pt7BnwIAYAYKEwDAWJ480oYN9gkgoqOlBg3ss+m5qFq1amnv3r0aNWqUfH19tX79epUtW1ZjxoxJdcGpXLmyNm7cqNWrV6tMmTK6cuWKevXqpccff1zLly9P1SgWAMB5UJgAAA8WEGAvSY0aSbduSa+8Ii1fbnaqVPP19dXQoUO1f/9+1a1bV7GxsRo8eLAqVqyobdu2pWqfFotFL7/8svbv368ZM2YoX758OnbsmN544w1Vq1Yt1fsFAJiPwgQAeLgsWaSvv7bf5DYhQXrzTWnuXLNTpUmpUqUUHh6uzz//XEFBQTp48KBq1KihTp06pWpSCEny8vJS586dFRERoREjRihbtmzauXOnatSooSZNmujIkSMO/hQAgPRGYQIAJI+Pj7RokdSpk2S1Sh06SJMnm50qTSwWi95++20dOnRIHTp0kCTNnj1bZcqU0eLFi1N9Ol327Nk1fPhwRUREqHPnzvL09NTq1atVtmxZde3aVRcvXnTkxwAApCMKEwAg+Tw9pRkzpL597cvvviuNGCG5+HU6uXPn1pw5c7RlyxY99thjunTpklq2bKkGDRro2LFjqd5v/vz5NWPGDO3fv18vvfSSEhMTNX36dJUsWVKjRo1STEyMAz8FACA9UJgAACljsUgffiiFhtqXR460Fyer1dxcDlCjRg3t3btXo0ePlq+vr8LDw/XEE0/ogw8+SNOsd4899pi++eYbbdq0SZUrV9aNGzc0fPhwlSpVSnPmzFFiYqIDPwUAwJEoTACAlLNYpMGDpbAw+/Inn9hP0bt929xcDuDj46MhQ4bowIEDqlevnmJjYzVkyBBVrFhRW9M4rXqtWrW0c+dOLVmyRMWKFdP58+cVEhKiJ598Ut999x0z6gGAE6IwAQBSr3t3acEC+6l68+fbJ4OIizM7lUOULFlS69ev1xdffKG8efPq4MGDqlmzpkJCQnT16tVU79disah58+Y6dOiQJk2apJw5c+rPP//Uiy++qLp16+r333934KcAAKQVhQkAkDatW0srVtgnhTh3zi1Gme6wWCxq2bKlDh06pI4dO0qS5syZozJlyuiLL75I04iQr6+vevfurWPHjqlv377y9fXVxo0bValSJbVs2VInT5500KcAAKSFxZaJxv+jo6MVGBioqKgoBQQEmB0HANzL1q3SE09IOXOanSTdbNu2TZ07d9bBgwclSXXr1tWMGTNUsmTJNO/71KlTGjJkiL744gtJ9lMDe/ToocGDByunG/83BQCzJLcbMMIEAHCMGjXcuixJ0rPPPqs9e/YoNDRUfn5+2rBhg5544gmFhoamaVIISSpatKg+//xz/f7776pbt67i4+P10UcfqUSJEvroo48U5yanOgKAq6EwAQCQAj4+Pho8eLAOHDig559/XnFxcRo6dKgqVKigLVu2pHn/Tz31lMLDw/X999/riSee0D///KP3338/6d5QVjeYjRAAXAmFCQCAVChRooTWrVunxYsXK2/evDp06JBq1aqlDh066MqVK2nat8ViUcOGDbV371599tlnKliwoE6ePKmWLVuqSpUq2rhxo4M+BQDgYShMAACkksViUYsWLXT48GF16tRJkjR37lyVKVNGCxcuTPM04Z6enmrfvr2OHj2q0NBQ+fv76/fff9dzzz2nF198UX/++acjPgYA4AEoTAAApFHOnDk1c+ZMbdu2TWXLltXly5fVpk0b1atXT3/99VfS+45H3tDGI5d04nJMivafNWtWDR48WBEREerWrZu8vLz03XffqXz58goJCdG5c+cc/ZEAAP/FLHkAADjQnckaRo0apdjYWPn6+uq9fgN0smA9bT8ZlfS+mqWCFNaiogKzeqf4GH/99ZcGDhyor776SpK9UL333nvq27ev/P39HfZZAMCdJbcbUJgAAEgHx48fV9euXbVu3TpJkneuwsrVoJv8ipSTJHlaLKpeMo8WdqiS6mNs375dffv21S+//CJJyps3r0aMGKGOHTvK2zvlRQwAMhOmFQcAwETFixfX2rVrNXnmPHlky6GEq3/r4pcDdfn7yUq8Fa1Em01bjkam+PS8f6tevbq2b9+uFStWqGTJkrp06ZK6du2qcuXKafXq1Wm+hgoAQGECACDdWCwWla/VSAU7zlD2Cg0lSTH7f9S52V1048AG2Ww2nbyS+sJ05xivvfaaDh48qLCwMOXJk0dHjhxRkyZNVLNmTe3cudMRHwUAMi0KEwAA6ahorqzy9Muu3A26KV/LCfLOU1TWW9G68t0kXVwyWNZ/zjrkON7e3urevbsiIiI0cOBA+fn5adu2bXrmmWfUvHlzRUREOOQ4AJDZUJgAAEhHxYOyq2apIHlaLPIr/JgKtP1EOWq1lcXLV3Gn/1CjWs9o5MiRiouLc8jxAgMDNWbMGB09elRt27aVxWLRsmXL9Pjjj6tXr166fPmyQ44DAJkFkz4AAJDOom4mqMeXe7TlaGTSuoo5EnTjpxn6Mdw+KcSjjz6qGTNmqHbt2g499h9//KF+/folTT4REBCggQMHqlevXsqSJYtDjwUAroRZ8u6DwgQAMNOJyzE6eSVGj+TOpmJ5sslms2nZsmXq3bu3Lly4IElq06aNJk6cqDx58jj02OHh4erbt6/27dsnSQoODlZoaKjefvtteXhwwgmAzIdZ8gAAcDLF8mRTnUfzqliebJLsEzY0b95chw4d0jvvvCOLxaIFCxaoTJkymj9/vkNnuXv++ee1e/duLViwQMHBwTpz5ozatGmjp556SuHh4Q47DgC4GwoTAAAmy5Ejhz799FNt375d5cqV05UrV9SuXTs999xzOnLkiMOO4+HhodatW+vIkSMaN26cAgMDtW/fPtWvX18NGjTQH3/84bBjAYC7oDABAOAkqlWrpt9//10ffvihsmTJok2bNql8+fIaPny4YmNjHXacLFmyqH///jp27Jh69eolb29vrV+/XhUqVFDbtm31999/O+xYAODqKEwAADgRb29v9evXTwcPHlSjRo0UHx+vUaNGqXz58vrpp58ceqzcuXNr8uTJOnTokJo3by6bzaYFCxaoVKlSGjRokKKiohx6PABwRRQmAACc0COPPKJvv/1Wy5YtU4ECBXT06FHVrVtXbdq0UWRk5MN3kAIlSpTQkiVLtHPnTtWoUUOxsbEaO3asSpYsqbCwMMXHxzv0eADgSihMAAA4KYvFombNmunQoUPq2rWrLBaLFi5cqDJlymjevHkOnRRCkqpUqaLNmzdr1apVKlOmjC5fvqyePXuqbNmyWrFihcOPBwCugMIEAICTCwwM1LRp0/TLL7+ofPnyunr1qtq3b686dero0KFDDj2WxWLRK6+8ov3792vGjBnKly+fIiIi1KxZM/3nP//R9u3bHXo8AHB2FCYAAFxE1apVtWvXLk2YMEFZs2bV5s2b9eSTT2rYsGEOnRRCkry8vNS5c2cdPXpUw4YNU9asWbVjxw49++yzatq0qY4dO+bQ4wGAs6IwAWmQmJio/v376+zZs2ZHAZBJeHt76/3339eff/6pRo0aKSEhQaNHj1b58uW1YcMGhx/P399fI0eOVEREhEJCQuTh4aGvv/5aV69edfixAMAZUZiANAgLC9P48eP1n//8RwkJCWbHAZCJ3JkUYvny5UmTQtSrV0+tWrXSpUuXHH68AgUKaNasWdq/f78mTpyoypUrO/wYAOCMLLZMdAVndHS0AgMDFRUVpYCAALPjwMWdPn1ajz/+uGJiYjRr1iyFhISYHQlAJhUVFaXBgwfr008/lc1mU86cOTVhwgS1a9dOHh78bhQA7ie53YDvokAq2Gw2de3aVTExMapRo4Y6dOhgdiQAmVhgYKCmTp2qHTt2qEKFCvrnn3/UsWNH1a5dWwcPHjQ7HgC4NAoTkArLly/Xd999J29vb82cOZPf4AJwClWqVNFvv/2miRMnKmvWrNq6dasqVKigIUOG6NatW2bHS5ZNmzbplVdeUYECBZQtWzZVqFBBixYtMjsWgEyMn/KAFLp27Zp69eolSRo4cKAee+wxkxMBwP/z8vLSe++9p4MHD+qll15SQkKCPvjgA5UrV04//vij2fEe6ueff1b58uW1cuVK/fHHH2rXrp1at26tb7/91uxoADIprmECUqhTp06aPXu2Hn30Ue3bt0++vr5mRwKA+7LZbFq1apW6d++uc+fOSZJatmypjz/+WHnz5k3XY588eVLFihW7Z32tWrW0adOmFO2rcePGypcvn+bOneugdADANUxAutiyZYtmz54tSZo1axZlCYBTs1gsevXVV3Xo0CH16NFDFotFixYtUpkyZTR79mxZrdZ0O3ZwcLDOnz+f9NizZ49y586tmjVrpnhfUVFRypUrVzqkBICHY4QJSKa4uDg9+eSTOnLkiDp27JhUnADAVezatUudOnXSnj17JEnVq1fXzJkzVbZs2XQ9bmxsrGrXrq2goCCtXr06Rdd9Llu2TK1atdLu3bvTPSeAzIURJsDBxo0bpyNHjihfvnwaP3682XEAIMUqVaqkX3/9VR999JGyZcum7du3q0KFCho8eHC6TgrRvn17Xb9+XYsXL05RWdq4caPatWun2bNnU5YAmIbCBCTDoUOHNGbMGEnSlClTlDNnTpMTAUDqeHl5qU+fPjp48KBefvll3b59W2PGjFG5cuUUHh7u8OOFhoZq3bp1+uabb+Tv75/s7TZv3qyXXnpJkyZNUuvWrR2eCwCSi8IEPITValXnzp0VHx+vxo0bq1mzZmZHAoA0K1KkiFavXq2vvvpKhQoV0rFjx1S/fn299dZbunjxokOOsXLlSo0aNUrLli1TiRIlkr3dpk2b1LhxY3344Yfq1KmTQ7IAQGpRmICHmDt3rrZu3aps2bJp2rRpslgsZkcCAIe5MylEr1695OHhoS+//FJlypTRvHnz0rTfAwcOqHXr1urfv7/Kli2rCxcu6MKFC7p69eoDt9u4caMaN26snj176rXXXkv2dgCQXihMwANcuHBBffv2lSSNHj1aRYsWNTkRADiev7+/Jk+erF9//VVPPfWUrl27ppMnT6Zpn7t27dLNmzcVGhqqAgUKJD2aNm36wO0WLFigmzdvauzYsSnaDgDSC7PkAQ/QvHlzLVu2TE8//bR27twpT09PsyMBQLq6ffu25s2bp1atWsnPz8/sOACQbpLbDbwyMBPgUr777jstW7ZMnp6emj17NmUJQKbg5eWlkJAQs2MAgNPglDzgPm7cuKGuXbtKkt59911VrFjR5EQA4B4aNmyo7Nmz3/dxZzZSAHAmjDAB9zFs2DCdPn1ajzzyiEaMGGF2HABwG3PmzDG851OuXLkyOA0APByFCfgfu3bt0ieffCJJmj59urJly2ZyIgBwH4UKFTI7AgCkCKfkAf9y+/ZthYSEyGq16q233tILL7xgdiQAAACYiMIE/MvkyZO1d+9e5cyZU5MmTTI7DgAAAEzmEoXp5MmT6tChg4oVK6YsWbKoRIkSGj58uOLj482OBjdy4sQJDRs2TJI0ceJE5c2b1+REAAAAMJtLXMN0+PBhWa1WzZw5UyVLltSBAwcUEhKimJgYTZw40ex4cAM2m03vvPOObt26pdq1a6tdu3ZmRwIAAIATcNkb106YMEHTp0/X8ePHk70NN66FkcWLF6tly5by9fXVH3/8odKlS5sdCQAAAOnI7W9cGxUV9dDpR+Pi4hQXF5e0HB0dnd6x4IKuXr2q3r17S5KGDBlCWQIAAEASl7iG6X9FREQoLCxMnTt3fuD7xo4dq8DAwKRHcHBwBiWEK+nbt68iIyP1+OOPq1+/fmbHAQAAgBMxtTANGDBAFovlgY/Dhw/ftc3Zs2f1wgsvqFmzZgoJCXng/gcOHKioqKikx5kzZ9Lz48AFbdy4UXPnzpUkzZo1Sz4+PiYnAgAAgDMx9RqmyMhIXbly5YHvKV68eNIPsefOnVPt2rX1zDPPaP78+fLwSFnf4xom/FtsbKzKly+vo0ePqkuXLpo+fbrZkQAAAJBBXOIapqCgIAUFBSXrvWfPnlWdOnX09NNPa968eSkuS8D/+uCDD3T06FEVKFBA48aNMzsOAAAAnJBLTPpw9uxZ1a5dW0WLFtXEiRMVGRmZ9Fr+/PlNTAZX9eeffyaVpLCwMAUGBpqcCAAAAM7IJQpTeHi4IiIiFBERocKFC9/1movOig4TWa1WderUSbdv39Yrr7yipk2bmh0JAAAATsolzmtr27atbDbbfR9ASs2cOVM///yzsmfPrqlTp8pisZgdCQAAAE7KJQoT4Cjnzp3TgAEDJEljxoy5Z8QSAAAA+DcKEzKVHj16KDo6WlWrVlXXrl3NjgMAAAAnR2FCprF69Wp99dVX8vLy0qxZs+Tp6Wl2JAAAADg5ChMyhevXr6tbt26SpL59+6p8+fImJwIAAIAroDAhUxg0aJDOnj2rEiVKaOjQoWbHAQAAgIugMMHt7dy5U9OmTZMkzZgxQ1myZDE5EQAAAFwFhQluLSEhQSEhIbLZbGrdurXq1atndiQAAAC4EAoT3NrHH3+s/fv3K3fu3Proo4/MjgMAAAAXQ2GC2zp27JhGjBghyV6c8uTJY24gAAAAuBwKE9ySzWZT586dFRsbq7p166pVq1ZmRwIAAIALojDBLX3++efasGGD/Pz8NGPGDFksFrMjAQAAwAVRmOB2IiMj1adPH0nS8OHDVbJkSZMTAQAAwFVRmOB23nvvPV25ckXly5fXe++9Z3YcAAAAuDAKE9xKeHi4Pv/8c1ksFs2aNUve3t5mRwIAAIALozDBbdy8eVNdunSRJHXv3l1Vq1Y1OREAAABcHYUJbmP06NE6fvy4ChcurNDQULPjAAAAwA1QmOAW/vjjD02YMEGSNG3aNAUEBJicCAAAAO6AwgSXl5iYqJCQECUmJqpp06Z6+eWXzY4EAAAAN0Fhgsv79NNP9euvvyogIEBhYWFmxwEAAIAboTDBpZ05c0aDBg2SJI0bN04FCxY0OREAAADcCYUJLstms6lbt266ceOGqlWrps6dO5sdCQAAAG6GwgSX9dVXX2nNmjXy9vbW7Nmz5eHBlzMAAAAci58w4ZKioqLUo0cPSVL//v1VtmxZkxMBAADAHVGY4JIGDhyo8+fPq1SpUho8eLDZcQAAAOCmKExwOdu3b9f06dMlSTNnzpSfn5/JiQAAAOCuKExwKfHx8erUqZMkqV27dqpTp47JiQAAAODOKExwKePHj9fBgwcVFBSkiRMnmh0HAAAAbo7CBJfx119/KTQ0VJI0efJk5cqVy+REAAAAcHcUJrgEm82mzp07Ky4uTg0aNFCLFi3MjgQAAIBMgMIElzBv3jxt2rRJWbNm1fTp02WxWMyOBAAAgEyAwgSnd+nSJb3//vuSpJEjR6pYsWImJwIAAEBmQWGC03v33Xf1zz//qGLFiurdu7fZcQAAAJCJUJjg1H744QctXrxYHh4emjVrlry8vMyOBAAAgEyEwgSnFRMTo3feeUeS1LNnT1WqVMnkRAAAAMhsKExwWsOHD9fJkydVpEgRjR492uw4AAAAyIQoTHBKe/bs0eTJkyVJ06dPV/bs2c0NBAAAgEyJwgSnc/v2bYWEhCgxMVFvvPGGGjVqZHYkAAAAZFIUJjidsLAw/f7778qRI4c++eQTs+MAAAAgE6MwwamcOnVKQ4YMkSSNHz9e+fPnNzkRAAAAMjMKE5yGzWZTt27ddPPmTdWoUUMdOnQwOxIAAAAyOQoTnMayZcv03XffycfHRzNnzpSHB1+eAAAAMBc/kcIp/PPPP+rVq5ckadCgQXrsscdMTgQAAABQmOAk+vXrp4sXL+qxxx7TgAEDzI4DAAAASKIwwQls2bJFc+bMkSTNnDlTvr6+JicCAAAA7ChMMFVcXJw6deokSQoJCVGNGjVMTgQAAAD8PwoTTDV27FgdOXJE+fPn1/jx482OAwAAANyFwgTTHDp0SGPGjJEkffLJJ8qRI4e5gQAAAID/QWGCKaxWqzp16qSEhAQ1btxYzZo1MzsSAAAAcA8KE0wxZ84cbdu2TdmyZdOnn34qi8VidiQAAADgHhQmZLjz58+rX79+kqTQ0FAVKVLE5EQAAADA/VGYkOF69eqlqKgoPf300+rRo4fZcQAAAABDFCZkqG+//VbLly+Xp6enZs+eLU9PT7MjAQAAAIYoTMgwN27cUNeuXSVJffr0UcWKFU1OBAAAADwYhQkZZsiQITpz5oyKFSum4cOHmx0HAAAAeCgKEzLEb7/9prCwMEnS9OnTlS1bNpMTAQAAAA9HYUK6S0hIUEhIiKxWq1q2bKkGDRqYHQkAAABIFgoT0t3kyZO1b98+5cqVSx9//LHZcQAAAIBkozAhXR0/fjzpeqWPPvpIefPmNTkRAAAAkHwUJqQbm82md955R7du3VKdOnXUpk0bsyMBAAAAKUJhQrpZvHix1q9fL19fX82YMUMWi8XsSAAAAECKUJiQLq5cuaJ3331XkjR06FCVLl3a5EQAAABAylGYkC7ef/99RUZGqmzZsurbt6/ZcQAAAIBUoTDB4X766SfNnz9fFotFs2bNko+Pj9mRAAAAgFShMMGhYmNj1blzZ0lSly5d9J///MfkRAAAAEDqUZjgUKGhoYqIiFDBggU1duxYs+MAAAAAaUJhgsPcvn1b33//vSRp6tSpCgwMNDkRAAAAkDZeZgeA+/Dy8tKOHTu0atUqvfrqq2bHAQAAANKMESY4lI+Pj9544w2zYwAAAAAOQWECAAAAAAMUJgAAAAAwQGECAAAAAAMUJgAAAAAwQGECAAAAAAMUJgAAAAAwQGECAAAAAAMUJgAAAAAwQGECAAAAAAMUJgAAAAAwQGECAAAAAAMUJjxURESE/P39lSNHDrOjAAAAABmKwoQHSkhIUIsWLVSjRg2zowAAAAAZjsLk5k6ePCmLxXLPo3bt2snafsiQISpTpozeeOON9A0KAAAAOCEvswMgfQUHB+v8+fNJyxcuXFC9evVUs2bNh277008/afny5dq7d6+++uqr9IwJAAAAOCUKk5vz9PRU/vz5JUmxsbFq0qSJqlWrphEjRjxwuytXrqht27b64osvFBAQkAFJAQAAAOdDYcpE2rdvr+vXrys8PFweHg8+GzMkJERvvfVWskaiAAAAAHdlsdlsNrNDZJTo6GgFBgYqKioq042ahIaGatKkSfr1119VokSJh74/R44cunHjRtKyzWaT1WqVp6enZs2apfbt26dnXAAAACBdJbcbMMKUCaxcuVKjRo3S2rVrk1WWJOmXX35RYmJi0vLq1av14Ycf6ueff1ahQoXSKyoAAADgVChMbu7AgQNq3bq1+vfvr7Jly+rChQuSJB8fH+XKlctwu8cee+yu5V27dsnDw0NPPPFEuuYFAAAAnAnTiru5Xbt26ebNmwoNDVWBAgWSHk2bNjU7GgAAAOD0uIYJAAAAQKaT3G7ACBMAAAAAGKAwZVINGzZU9uzZ7/sYM2aM2fEAAAAAp8CkD5nUnDlzdOvWrfu+9qDJIAAAAIDMhMKUSTE1OAAAAPBwnJIHAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAYoTAAAAABggMIEAAAAAAZcrjDFxcWpQoUKslgs2rt3r9lxAAAAALgxlytM/fr1U8GCBc2OAQAAACATcKnCtHbtWq1fv14TJ040OwoAAACATMDL7ADJdfHiRYWEhGjVqlXKmjVrsraJi4tTXFxc0nJ0dHR6xQMAAADghlxihMlms6lt27bq0qWLKlWqlOztxo4dq8DAwKRHcHBwOqYEAAAA4G5MLUwDBgyQxWJ54OPw4cMKCwvT9evXNXDgwBTtf+DAgYqKikp6nDlzJp0+CQAAAAB3ZLHZbDazDh4ZGakrV6488D3FixfXG2+8oTVr1shisSStT0xMlKenp1q2bKkFCxYk63jR0dEKDAxUVFSUAgIC0pQdAAAAgOtKbjcwtTAl1+nTp++6/ujcuXNq0KCBVqxYoapVq6pw4cLJ2g+FCQAAAICU/G7gEpM+FClS5K7l7NmzS5JKlCiR7LIEAAAAACnlEpM+AAAAAIAZXGKE6X898sgjcoEzCQEAAAC4OEaYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMAAhQkAAAAADFCYAAAAAMCAl9kBMpLNZpMkRUdHm5wEAAAAgJnudII7HcFIpipM169flyQFBwebnAQAAACAM7h+/boCAwMNX7fYHlap3IjVatW5c+fk7+8vi8VidhyXEB0dreDgYJ05c0YBAQFmx4Eb42sNGYWvNWQUvtaQUfhaSx2bzabr16+rYMGC8vAwvlIpU40weXh4qHDhwmbHcEkBAQH8D4gMwdcaMgpfa8gofK0ho/C1lnIPGlm6g0kfAAAAAMAAhQkAAAAADFCY8EC+vr4aPny4fH19zY4CN8fXGjIKX2vIKHytIaPwtZa+MtWkDwAAAACQEowwAQAAAIABChMAAAAAGKAwAQAAAIABChMAAAAAGKAwAQAAAIABChNSLC4uThUqVJDFYtHevXvNjgM3c/LkSXXo0EHFihVTlixZVKJECQ0fPlzx8fFmR4ObmDZtmh555BH5+fmpatWq+vXXX82OBDczduxYVa5cWf7+/sqbN6+aNGmiI0eOmB0Lbm7cuHGyWCzq3bu32VHcDoUJKdavXz8VLFjQ7BhwU4cPH5bVatXMmTP1559/atKkSZoxY4YGDRpkdjS4gaVLl6pPnz4aPny4du/erSeffFINGjTQpUuXzI4GN7J582Z169ZNO3bsUHh4uBISElS/fn3FxMSYHQ1u6rffftPMmTNVvnx5s6O4Je7DhBRZu3at+vTpo5UrV6ps2bLas2ePKlSoYHYsuLkJEyZo+vTpOn78uNlR4OKqVq2qypUra+rUqZIkq9Wq4OBg9ejRQwMGDDA5HdxVZGSk8ubNq82bN6tmzZpmx4GbuXHjhp566il9+umnCg0NVYUKFTR58mSzY7kVRpiQbBcvXlRISIg+//xzZc2a1ew4yESioqKUK1cus2PAxcXHx+v3339XvXr1ktZ5eHioXr16+uWXX0xMBncXFRUlSXwfQ7ro1q2bGjdufNf3NjiWl9kB4BpsNpvatm2rLl26qFKlSjp58qTZkZBJREREKCwsTBMnTjQ7Clzc5cuXlZiYqHz58t21Pl++fDp8+LBJqeDurFarevfurerVq+uJJ54wOw7czJIlS7R792799ttvZkdxa4wwZXIDBgyQxWJ54OPw4cMKCwvT9evXNXDgQLMjw0Ul92vt386ePasXXnhBzZo1U0hIiEnJASD1unXrpgMHDmjJkiVmR4GbOXPmjHr16qVFixbJz8/P7DhujWuYMrnIyEhduXLlge8pXry43njjDa1Zs0YWiyVpfWJiojw9PdWyZUstWLAgvaPCxSX3a83Hx0eSdO7cOdWuXVvPPPOM5s+fLw8Pfr+DtImPj1fWrFm1YsUKNWnSJGl9mzZtdO3aNa1evdq8cHBL3bt31+rVq7VlyxYVK1bM7DhwM6tWrdKrr74qT0/PpHWJiYmyWCzy8PBQXFzcXa8h9ShMSJbTp08rOjo6afncuXNq0KCBVqxYoapVq6pw4cImpoO7OXv2rOrUqaOnn35aX3zxBd/w4TBVq1ZVlSpVFBYWJsl+ulSRIkXUvXt3Jn2Aw9hsNvXo0UNff/21Nm3apFKlSpkdCW7o+vXrOnXq1F3r2rVrpzJlyqh///6cAupAXMOEZClSpMhdy9mzZ5cklShRgrIEhzp79qxq166tokWLauLEiYqMjEx6LX/+/CYmgzvo06eP2rRpo0qVKqlKlSqaPHmyYmJi1K5dO7OjwY1069ZNixcv1urVq+Xv768LFy5IkgIDA5UlSxaT08Fd+Pv731OKsmXLpty5c1OWHIzCBMCphIeHKyIiQhEREfeUcQbEkVbNmzdXZGSkhg0bpgsXLqhChQr64Ycf7pkIAkiL6dOnS5Jq16591/p58+apbdu2GR8IQJpwSh4AAAAAGOAqagAAAAAwQGECAAAAAAMUJgAAAAAwQGECAAAAAAMUJgAAAAAwQGECAAAAAAMUJgAAAAAwQGECAAAAAAMUJgAAAAAwQGECAAAAAAMUJgAAAAAw8H/b12W4xmnUmQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "favorite.graph()" ] @@ -187,7 +211,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -201,9 +225,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.8.16" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/spider-algorithm.pdf b/spider-algorithm.pdf new file mode 100644 index 0000000..f1c8b0d Binary files /dev/null and b/spider-algorithm.pdf differ