commit 7da1135791ff9d7561434c7a9079ce9fb0c327ee Author: AINDUSTRIES Date: Sun Jan 18 17:29:00 2026 +0100 Initial Commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..505a3b1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +# Python-generated files +__pycache__/ +*.py[oc] +build/ +dist/ +wheels/ +*.egg-info + +# Virtual environments +.venv diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..24ee5b1 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.13 diff --git a/1-coordinate-descent.ipynb b/1-coordinate-descent.ipynb new file mode 100644 index 0000000..212ed68 --- /dev/null +++ b/1-coordinate-descent.ipynb @@ -0,0 +1,175 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "075806aa", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c9235b01", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A l'itété 0, on trouve x=[-0.2 -0.42]\n", + "A l'itété 1, on trouve x=[ 0.148 -0.2112]\n", + "A l'itété 2, on trouve x=[ 0.27328 -0.136032]\n", + "A l'itété 3, on trouve x=[ 0.3183808 -0.10897152]\n", + "A l'itété 4, on trouve x=[ 0.33461709 -0.09922975]\n", + "A l'itété 5, on trouve x=[ 0.34046215 -0.09572271]\n", + "A l'itété 6, on trouve x=[ 0.34256637 -0.09446018]\n", + "A l'itété 7, on trouve x=[ 0.34332389 -0.09400566]\n", + "A l'itété 8, on trouve x=[ 0.3435966 -0.09384204]\n", + "A l'itété 9, on trouve x=[ 0.34369478 -0.09378313]\n" + ] + } + ], + "source": [ + "# Un premier exemple de descente par coordonnées\n", + "\n", + "# Itéré intial\n", + "x = np.array([-1/2, -1])\n", + "\n", + "maxiter = 10\n", + "for k in range(maxiter):\n", + " #On mets (de façon optimale) x1\n", + " x[0] = (6*x[1]+4)/10\n", + " #On mets (de façon optimale) x2\n", + " x[1] = (6*x[0]-3)/10\n", + " print(f\"A l'itété {k}, on trouve x={x}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "999a5a80", + "metadata": {}, + "outputs": [], + "source": [ + "def CDquadratic(Q,c,p,x,maxiter=10**2):\n", + " # Ce code applique la méthode de descente par coordonnées\n", + " # au problème min_x 0.5 x'*Q*x-c'*x+p\n", + " # Le x fournit en paramètre est l'itéré initial\n", + " # Q nous est donnée sous forme symétrique\n", + " n = len(x)\n", + " # Une itération coûte O(n^2)\n", + " for k in range(maxiter):\n", + " # Dans cette boucle, on mets les variables à jour\n", + " for i in range(n):\n", + " somme = 0\n", + " for j in range(n):\n", + " if not j==i:\n", + " somme += Q[i,j]*x[j]\n", + " x[i] = (c[i]-somme)/Q[i,i]\n", + " print(f\"A l'itété {k}, on trouve x={x}\")\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d7a850ff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A l'itété 0, on trouve x=[-0.2 -0.42]\n", + "A l'itété 1, on trouve x=[ 0.148 -0.2112]\n", + "A l'itété 2, on trouve x=[ 0.27328 -0.136032]\n", + "A l'itété 3, on trouve x=[ 0.3183808 -0.10897152]\n", + "A l'itété 4, on trouve x=[ 0.33461709 -0.09922975]\n", + "A l'itété 5, on trouve x=[ 0.34046215 -0.09572271]\n", + "A l'itété 6, on trouve x=[ 0.34256637 -0.09446018]\n", + "A l'itété 7, on trouve x=[ 0.34332389 -0.09400566]\n", + "A l'itété 8, on trouve x=[ 0.3435966 -0.09384204]\n", + "A l'itété 9, on trouve x=[ 0.34369478 -0.09378313]\n" + ] + } + ], + "source": [ + "Q = np.array([[10, -6],[-6, 10]])\n", + "c = np.array([4, -3])\n", + "p = 0\n", + "x = np.array([-1/2, -1])\n", + "xopt = CDquadratic(Q,c,p,x,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "960500d8", + "metadata": {}, + "outputs": [], + "source": [ + "def leastsquares(A,b,x,maxiter=10**2):\n", + " Q = 2*A.T@A\n", + " c = 2*A.T@b\n", + " p = b.T@b\n", + " x = CDquadratic(Q,c,p,x,maxiter)\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "560043ef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A l'itété 0, on trouve x=[ 0. -0.5]\n", + "A l'itété 1, on trouve x=[ 0.25 -0.625]\n", + "A l'itété 2, on trouve x=[ 0.3125 -0.65625]\n", + "A l'itété 3, on trouve x=[ 0.328125 -0.6640625]\n", + "A l'itété 4, on trouve x=[ 0.33203125 -0.66601562]\n", + "A l'itété 5, on trouve x=[ 0.33300781 -0.66650391]\n", + "A l'itété 6, on trouve x=[ 0.33325195 -0.66662598]\n", + "A l'itété 7, on trouve x=[ 0.33331299 -0.66665649]\n", + "A l'itété 8, on trouve x=[ 0.33332825 -0.66666412]\n", + "A l'itété 9, on trouve x=[ 0.33333206 -0.66666603]\n" + ] + } + ], + "source": [ + "A = np.array([[1,0], [0,1], [1,1]])\n", + "b = np.array([3,2,-3])\n", + "x = np.array([1.0, 0.0]) # Attention au entiers\n", + "xopt = leastsquares(A,b,x,10)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "optinonlin", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/2024-Questions-3_4_5.ipynb b/2024-Questions-3_4_5.ipynb new file mode 100644 index 0000000..25c6ede --- /dev/null +++ b/2024-Questions-3_4_5.ipynb @@ -0,0 +1,691 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 203, + "metadata": { + "id": "VwavQQWX2Fhk" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import time\n", + "import scipy\n", + "from scipy.linalg import circulant\n", + "import scipy.io\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On veut résoudre:\n", + "$$\\min_x \\frac{1}{2} ||Ax-b||^2_2$$\n", + "Le problème peut s'écrire comme:\n", + "$$\\min_x (a_{11}x_1+a_{12}x_2-b_1)^2 + ...$$\n", + "$$\\frac{\\delta f}{\\delta x_2}=0 \\Leftrightarrow 2a_{12}(a_{11}x_1+a_{12}x_2-b_1) + ...$$\n", + "$$(a_{12}^2+a_{22}^2+a_{32}^2)x_2 = -(A(:,2)^TA(:,1))x_1 + ...$$\n", + "$$(A(:,2)^TA(:,2))x_2 = -(A^TAx)_2 + (A^Tb)_2 + A(:,2)^TA(:,2)x_2$$\n", + "$$x_2=x_2-\\frac{(A^TAx-A^Tb)_2}{(A^TA)_{2,2}}$$\n", + "$$x_i^+ = x_i-\\frac{[\\Delta f(x)]_i}{[A^TA]_{i,i}}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": { + "id": "ch8nmbMD2Psl" + }, + "outputs": [], + "source": [ + "def CDLS(A,b,x0,maxiter=10**4,maxtime=2):\n", + " t0 = time.time()\n", + "\n", + " t = np.zeros(maxiter)\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " x = x0.copy()\n", + "\n", + " # O(mr^2)\n", + " AtA = A.T@A\n", + " # O(mr)\n", + " Atb = A.T@b\n", + " # O(m)\n", + " btb = b@b / 2\n", + "\n", + " g = AtA@x-Atb\n", + "\n", + " fobj[0] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " k = 0\n", + " while k < maxiter-1 and t[k] < maxtime:\n", + " # On mets à jour le vecteur x entrée par entrée\n", + " for i in range(r):\n", + " xinew = x[i] - g[i] / AtA[i,i]\n", + " g = g - AtA[:,i]*x[i]+AtA[:,i]*xinew # O(r)\n", + " x[i] = xinew\n", + " fobj[k+1] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " t[k+1] = time.time() - t0\n", + " k += 1\n", + " return t[:k+2], fobj[:k+2], x" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": { + "id": "mx47170C2T1N" + }, + "outputs": [], + "source": [ + "def GRLS(A,b,x0,maxiter=10**4,maxtime=2):\n", + " t0 = time.time()\n", + "\n", + " t = np.zeros(maxiter)\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " x = x0.copy()\n", + "\n", + " # O(mr^2)\n", + " AtA = A.T@A\n", + " # O(mr)\n", + " Atb = A.T@b\n", + " # O(m)\n", + " btb = b@b / 2\n", + "\n", + " g = AtA@x-Atb\n", + "\n", + " L = max(np.linalg.eigvals(AtA))\n", + "\n", + " alpha = 1/L\n", + "\n", + " fobj[0] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " k = 0\n", + " while k < maxiter-1 and t[k] < maxtime:\n", + " d = -g\n", + " x = x + alpha*d\n", + " g = AtA@x - Atb\n", + " fobj[k+1] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " t[k+1] = time.time() - t0\n", + " k += 1\n", + " return t[:k+1], fobj[:k+1], x" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": { + "id": "ZYuPRORf2WVl" + }, + "outputs": [], + "source": [ + "def GALS(A,b,x0,maxiter=10**4,maxtime=2):\n", + " t0 = time.time()\n", + "\n", + " t = np.zeros(maxiter)\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " x = x0.copy()\n", + "\n", + " # O(mr^2)\n", + " AtA = A.T@A\n", + " # O(mr)\n", + " Atb = A.T@b\n", + " # O(m)\n", + " btb = b@b / 2\n", + "\n", + " g = AtA@x-Atb\n", + "\n", + " L = max(np.linalg.eigvals(AtA))\n", + "\n", + " alpha = 1/L\n", + "\n", + " fobj[0] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " k = 0\n", + "\n", + " xprec = x.copy()\n", + " while k < maxiter-1 and t[k] < maxtime:\n", + " y = x + ((k-1)/(k+2))*(x-xprec)\n", + " xprec = x\n", + " \n", + " g = AtA@y - Atb\n", + " d = -g\n", + " x = y + alpha*d\n", + "\n", + " fobj[k+1] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " t[k+1] = time.time() - t0\n", + " k += 1\n", + " return t[:k+1], fobj[:k+1], x" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": { + "id": "wGTAgRsp2b4r" + }, + "outputs": [], + "source": [ + "#Pour la Question 3\n", + "m, r = 1000, 100\n", + "A = np.random.rand(m,r)\n", + "b = np.random.rand(m)\n", + "x0 = np.ones(r)\n", + "maxiter, maxtime = 10**4, 2\n", + "t_cd, f_cd, x_cd = CDLS(A,b,x0,maxiter=maxiter,maxtime=maxtime)\n", + "t_gr, f_gr, x_gr = GRLS(A,b,x0,maxiter=maxiter,maxtime=maxtime)\n", + "t_ga, f_ga, x_ga = GALS(A,b,x0,maxiter=maxiter,maxtime=maxtime)" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": { + "id": "zroLtOO42jpW" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 208, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGdCAYAAADqsoKGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAV69JREFUeJzt3Ql4VNX5P/B39iQkJEAgYUcUkB0BQVwqWBRRca1i3ZBatFT606KtUFtQq6IVcalYLBbBHauC/YvFhaIoogiIIiACsikkAYHsmUlm5v98z507mck6gcnMnTvfz/Nc7sydm8mZmYT75j3vOcfi9/v9QkRERJTgrPFuABEREVE0MKghIiIiU2BQQ0RERKbAoIaIiIhMgUENERERmQKDGiIiIjIFBjVERERkCgxqiIiIyBTskiR8Pp/s379fMjIyxGKxxLs5REREFAHMEVxcXCwdOnQQq7XhXEzSBDUIaDp37hzvZhAREdEx2Ldvn3Tq1KnBc5ImqEGGRn9TWrZsGe/mEBERUQSKiopUUkK/jjckaYIavcsJAQ2DGiIiosQSSekIC4WJiIjIFBjUEBERkSkwqCEiIiJTSJqaGiIiMw1xraqqEq/XG++mEB03m80mdrs9KtOtMKghIkogHo9HDhw4IGVlZfFuClHUpKWlSfv27cXpdB7X8zCoISJKoElEd+3apf6yxURkuABwMlFK9Kyjx+ORgwcPqp/tHj16NDrBXkMY1BARJQj854/ABnN24C9bIjNITU0Vh8Mhe/bsUT/jKSkpx/xcLBQmIkowx/OXLJGZf6b5m0FERESmkFBBDfrbRo0aJX369JH+/ftLaWlpvJtEREREBpFQQc2NN94o9913n2zZskU++ugjcblc8W4SERElqHvuuUcGDRoU72ZQMgY1mzdvVoVEZ511lrrfunVrNa6diIgSQ15envzud7+T7t27qz9KUfA8btw4WbFihSSKkSNHqhFn2PAaOnbsqF7Dm2++KYnmxhtvlEsvvVTMJGZBzapVq9QHj2GI+GFYunRprXPmzp0r3bp1U5XPw4cPl7Vr1wYf2759u6Snp6vnGDx4sDz44INiBIvff1xun3+uPPHv2+LdFCIiw9q9e7cMGTJE/ve//8kjjzwimzZtkuXLl6uSgltvvbVZv3dlZWVUn2/SpElqrqCdO3fKG2+8oUoirr76arn55puj+n3IwEEN6l8GDhyoApe6LF68WKZOnSozZ86UDRs2qHPHjBkjBQUF6nHMnvnxxx/L008/LWvWrJH3339fbfG2Le8LWeHMk2+OfBHvphBRks7zUeapisuG7x2p3/72t+oPWvyxesUVV0jPnj2lb9++6v/9zz77LHje3r175ZJLLlF/xLZs2VKuuuoqyc/PD3uuf/zjH3LiiSeqeXp69eolL7zwQtjj+D445+KLL5YWLVrIAw88oI4/9NBDkpOTIxkZGXLTTTdJRUXFMb3nGE6fm5srnTp1ktNOO00efvhheeaZZ2T+/PnywQcfBM/bt2+fan9WVpbqXcDrQnCn+/DDD2XYsGGqjTjnjDPOUMOadf/v//0/OfXUU9Uf+tnZ2XLZZZcFH3O73XLnnXeqTBG+HomADz/8MPj4woUL1XO+++670rt3b/V+nn/++SoY07veFi1aJG+99VYw8xT69YkqZv03Y8eOVVt95syZo6LfiRMnqvvz5s2TZcuWyYIFC2TatGnqgxs6dKhKV8IFF1wgGzdulHPPPbfO58MHjk1XVFQkzcFldYn4RDzC6cqJKPbKK73SZ8a7cfneW+4bI2nOxi8jhw8fVlkZBBe4ANeEiy9gDh49oEHdJP6YRRZn/PjxwQvukiVL5LbbbpPHH39cRo8eLW+//ba6biDAQNZHh4s2ghich1KF1157TR3DH9ZnnnmmCoSefPJJ1RUWDRMmTJA77rhDdUOhXcgO4Q/zESNGqD/I0Yb7779fBRZff/21GsKMrh9c91555RU1PwsCPn0yRVz/EMTcfffd8vzzz6vH33nnneD3mzJliqovffXVV1UPCN6X888/X2XAMIEdYNbp2bNnq9eK73fdddepQOill15S+61bt6pr43PPPafOR+CV6AxRlIIPa/369TJ9+vTgMXwA+MFAVgYQrSJrc+TIEcnMzFTdWbfccku9zzlr1iy59957m73tLqs2pXMVIhsiIqplx44dKqtz8sknN3geamtwUcZIV/0PWFzQkdH54osv1HUAF2nUgiDzA3qmB8dDg5prrrkm+EcyoHsI2RlsgAADWZVjzdbUhGsWsk96Jga9DwjSnn322WCgguABARwCNPyRXlhYKBdddJHKOgEyKjoEgGhz6HUMPRh6NgvPhT0CGkCQsnz5cnVcL89AYIUEgf78CIQw2AYQOGLSO/zxj6yTWRgiqDl06JBamA1pwVC4/+2336rbiHLxQf3sZz9TvxznnXee+mGoDwIk/LDrEI3qvyTR5LKnIE0jlQxqiCgOUh02lTGJ1/eORKTdVMgc4P/p0P+rUa+CQACPIajBvmbtCrptnnjiibBjCBpqPvdvfvObsGPIoqxcuVKiBa9TD2C++uorFcyhqysUgijU4uAahuAM2Rz0OOCPeHRVYf0jQE8Esjh1QeCHayaCqFBut1vatGkT1k2mBzSA59ZLOszKEEFNtLqwQqEqPRZDvl02bTpnj4VBDRHFHi6ikXQBxRO6Q9BO/Y/UWKirm6s5IcjAgBYEXlBSUqIKo9HVU1Pbtm3VHlmV//u//1MZFmR2/vznP6taUdTpIItSHzw31v9CDwf2odLT04O3MWI4FD6DptRBJSJDDOlGARQ+mJrFYLhv9LRYikMLapipISKqG2o1kJFAPUtdk6YePXo02P2C4lpsOtSN4HFkbPRzVq9eHfb1uK8/Xh983eeffx52LLRA+Xih6BblESiCBozSRZDTrl07Oemkk8I2lFDoTjnlFNWz8Omnn0q/fv3k5ZdfVscHDBhQ71B3fA2CKGRdaj53bhOumSi0xvOYiSGCGryxiGhDP0D0ReI+0oNGlmrXommPxdzRLxHR8UBAgwsoRvtgGDQu+OgSQrGu/v88umAwW/y1116rRsGicPaGG26Qs88+O9id9Ic//EGN7MHoJjwHBpmgOBc1JQ1BcTEGniA78t1336mRtpj/LBSKbRur+9ELcDHnzg8//KACo7vuukt1bU2ePDlY14PXgD/YUfiMQmHUCaGWBpkZfB3uI5hB3ShGPL333nvq9eh1NWgfCoixx/uELieMsgJ0O+H58d7gteO58F7NmjVLFRhHClOooGh527Ztqgwk2kPf48IfI8XFxf4vv/xSbfi2c+bMUbf37NmjHn/11Vf9LpfLv3DhQv+WLVv8N998sz8rK8ufl5cXle9fWFiovi/20fTfD57w91vYz3/2s/2i+rxERDWVl5er/x+xT0T79+/333rrrf6uXbv6nU6nv2PHjv6LL77Yv3LlyuA5uCbgWIsWLfwZGRn+K6+8stZ14Omnn/Z3797d73A4/D179vQ///zzYY/j//olS5bU+v4PPPCAPzs725+enu6fMGGC/49//KN/4MCBwcefe+459bUNOfvss9U52PAa2rdv77/ooov8b775Zq1zDxw44L/hhhvU98T1DW2eNGmSug7hNV166aXq6/E8eE9mzJjh93q9wa9/4403/IMGDVKP4zkuv/zy4GMej0ed361bN/U+4Hkuu+wy/9dffx18LZmZmWHtwXsS+voKCgr85557rno/cDz0czDSz3ZTrt8W/BOL4AkRamhleugwOETd8NRTT6lJmRABY+pqRPAYex8NKBRGyg/V5pj7IFo++vhZmfL9E9LSK7L6V5ui9rxERDWhyBR/lZ9wwglq7hKiZPjZLmrC9dsey6mlG4ufMNwMWyJp4dCK0dj9REREFF+GqKlJZGkuPaiJfNgiERERRR+DmuOUnqINn/NZLFLpNUGRFRERUYJiUHOcWgQyNVDkLotrW4iIiJIZg5rjlJXWUiyBbqe84uJ4N4eIiChpMag5TjaHU1yBoGZ/EYMaIiKieGFQc7xs1UFNPoMaIiKiuGFQc7xsjuqgpqQk3q0hIiJKWgxqjpfNKSmBoOZQSVG8W0NElLQwH9rtt98uieCee+5Rk8zqsGL3pZdeGtc2mQGDmihmag6XFMa7NUREhoSLNlaJxhpJNd16663qMZwT6Qz1OF9fCPN4Ycbav/zlL9K3b1+1OnabNm3Uatt/+9vf1CKVsfDEE08EZ9dvrsApGTCoOV7W6qCmsIw1NURE9encubO8+uqrUl5eHjY9Plam7tKlS1zadPjwYTnttNPUQpdYFBMreWMxzQceeEC+/PLL4KrZdfF4PFFrB5YByMrKitrzJSsGNdHI1Pi0oKa4gjU1RET1GTx4sApssLK0DrcR0JxyyinBYz6fT604jXWAkDkZOHCgvP766+qx3bt3B9cRbNWqVa0MD772j3/8o7Ru3Vpyc3NVtqIhf/rTn2Tv3r1qleuJEyfKgAEDpGvXrnLeeeepVbJ/+9vfhq1q/de//lWtjo01iG6++WZ1HKt0Y+XstLQ06d69u8r61Fzx+qGHHpKcnBzJyMiQm266SQVzoWp2PzX0HoRmq1asWKFWMMf3Pv3009WK24Csz7333itfffWVOg9btDNBRsSg5nhZbeIK3CypKI1zY4go6SBT7CmNz3YMS8P86le/UlkR3YIFC1QwEQoX8+eff17mzZsnmzdvlt///vdy3XXXyUcffaSCojfeeEOdhwv4gQMHVNeNbtGiRdKiRQuVcUH30X333Sfvv/9+nW1B4LB48WL13B06dKjzHAQDoWbPnq0CDGRxELwAAhUEDFu2bFFtmT9/vjz22GPBr3nttddUcPXggw/KunXrpH379vL00083+D419B6Euvvuu+XRRx9Vz2u329X7C+PHj5c77rhDdanhPcKGY2YXswUtzSzFr/3Ql1eWitfnF5s1/JeAiKjZVJaJPFj3BbnZ/Wm/iLN6VvVI4MI8ffp02bNnj7q/evVq1SWFzAO43W518f/ggw9kxIgR6hiyH5988ok888wzcvbZZ6ssDLRr165Wlw0yLTNnzlS3e/ToIU899ZTKZpx77rm12nLw4EFVl9OrV6+w40OGDAlmPMaNG6cyNrpzzjlHBQuh/vznP4dlc9CNhdeEjBE8/vjjKjuDDe6//371+mpma3SRvAc6dJPp96dNmyYXXnihel5kd9LT01Wgg4xVsmBQEwUu0YIYq8Uj2/KKpU+HhpdGJyJKVm3btlUXXmQ2sAgwbmdnZwcf37Fjh5SVldUKQlC/EtpFVR8ENaGQFSkoKGhSG5csWaK+H7qVQut/AF09NSHb8+STT8rOnTulpKREqqqqVPeUbuvWrbUKpBGsrFy5ss7v35T3IPT1tm/fXu3xeuNVoxRvDGqiICUkqPlkx0EGNUQUO440LWMSr+99DNBFMmXKFHV77ty5YY8hKIBly5ZJx44dwx5zuVyNN8nhqNV9hG6m+gIsZHr0rIxODwjQrVRzhBW6tkKtWbNGrr32WlW/MmbMGFXwiywNuoSOVVPeg9DXawl0ldX3epMBg5oocFm00iSLtVI+2FIgN//sxHg3iYiSBS5kTewCirfzzz9fZR1wEUYgEKpPnz7qwo3i3dBullBOp1PtvV7vcbXDarXKVVddJS+++KLMmDGj3rqahnz66aeqsBi1LTq9a03Xu3dvVeODAmPdZ599Vu9zRvIeRMLpdB73e5RoGNREgStQb22zVcra3Yfl2Y+/l1+f1T3ezSIiMiSbzaa6ZPTboZAdQU0KCmORcTjzzDOlsLBQ1d6gS2fChAkqiEBA9Pbbb8sFF1wQrB+JBAILZD9QiAuoXUE9z7Bhw1RRMbqXkI35+uuvVRamX79+DT4f6nYQfCA7g7ltkF1B91Wo2267TY1uwnOfccYZ8tJLL6niX9TJ1CWS9yAS3bp1k127dsnGjRulU6dO6nkjyXYlMo5+imKmpkc77Yfl/mVb5V+f7Ipzq4iIjAsX59C6k1AYNo2RRQg8kOVAZgfBAoY3A4ISdPegMBbDpPWurEggAMFIIB0m2sNwbgQ7jzzyiApu+vfvr0YrYbQQRjI15OKLL1bBB9qAie6QudFHRenwPDiGwmEUISOTM3ny5Aaft7H3IBJXXHGF+joMgUdXW2jBs1lZ/KjUSgKYMRJ9nYh26/tFOlbz/3mKPOmqkstyRkiW7U55csV2dfyWs7vLtPNPrjUkkIjoWGBUC/7yxoUtJSUl3s0hisnPdlOu38zURIHLovXiub0e+f3oHnLLz7SU4jMffS8PLNuqKvyJiIioeTGoiYIUi9Yn7Pa5VVZm+gW95YHLtH7YZz/ZJb+c/5ks/fJHNYcNERERNQ8GNVHgsmqZmgpv9Tog1w7vKg9e1l8wD99n3x+W2xdvlAuf/FhWbitg5oaIiKgZcPRTFLisjmD3U6hrhneRM05qI0u/3C/PfvK9fJtXLBOf+0J6tEuX0X1y5IrBHaVTqzRJcYRX/xMREVHTMaiJZk2Nr/aKrV3btJDbRveQCad3lac/3CkLP90t2wtK1PaPD3eqczJTHdKpVap0bZOmzu+Zky4n57aUE9umi9POZBoREVEkGNREK1PjE6nwha/KGiorzSl/uqC3/HbkifLRdwfl5c/3ysZ9R8Vd5ZPC8kq1bd5fFPY1dqtFTmqHACdDeuW2lF656dKjXYZ0zEoVK9eXIiIiCsOgJgpSbE4V1LgbCGpCg5tLBnVUG2prisqrJK+oQvYdLpM9h8tk16ES+S6vRLbmFUlxRZXqssImUj0NeorDKr3bt5TTT2wjp5+YLUO6tmIXFhERJT0GNVHgsjlEKhHUVDXp6zBSKjPNobZeuRlhjyHg2V9YIVv3F8m2fC2w2Z5fLN8fLJWKSp98ufeo2uau3ClOG4KcDGmT7pLWLZyq26p/x0wZ0DlTWqaEr4NCRERkVgxqoiDFqs0k3NSgprGAB91M2FBUrKvy+lRGZ8OeI7Jm50/y6c6fVKbnqx8K63gOUQHOoM5ZMhBbp0zpmZPBrA4REZkSg5oocKH7CUGNP3pBTX3sNqsKVLBdObSzyujsOlQqOwpK5GhZpeQXVci3+cXy1b6j8sORcnUc2+vrf1Bfj1KcE7JbyMntW0qvnAw1EqtnboZ0bZ2mnpuIKJGNHDlSLVfw+OOPi9FhKYalS5eqtZkA60NhVXAco2PDoCYKUmxapqbCX6WCjFgui4Dv1b1tutpqOlTiVsENti/3HZVvfiyUI2WVsvNgqdqWSfX6JxhldVLbdNUNhmwOipKxR6aIyzwQ0fHCBXvRokVyyy23yLx588Ieu/XWW+Xpp59WCzUuXLgwoufDIpRY0+jIkSOSlZV13O3DVPxY++nNN9+U77//XtLS0tSCk1deeaVMmjRJWrVqJc3tiSeeiPo8ZvfUCJwa88MPP6jX3bNnT/nmm29qPY72YT2sf/3rX2pRTrvdLieddJJcd911cvPNN6v3TX8/H374YXnjjTdk9+7d6jPC4qC//e1v5bLLLmu26wqDmihwBoIa/ChW+irFGcjcxFt2ukt+3jtHbfoP48Fit2zNK5atB4pkez6yOMXyXX6JlFd6ZcuBIrWFSnfZpUeOlhnqFhhy3q1NC+nSJk0NRSciilTnzp3VataPPfaYWllbX/Pn5Zdfli5dusStXYcPH1YrYeNCjIUksegk1hratm2bPPfcc6p9CLzq4vF4xOmMzv/5+J7xtnDhQrnqqqtk1apV8vnnn8vw4cPDHr/++utV4PfnP/9ZnnrqKbVQ5ldffaUyY1gV/NJLL1XZJn1l8fvvv1+tXo7g56OPPlKLep5zzjlRCUTrwqAmClLs1YtvVXgrDBPU1ITIuF3LFLWd3bNt8LjP51ddVShI/i6/WLblafudB0ukxF0VLEquCUXJnVunScesFGmfmSrtM1OkQ1b1vm26i0PPiSho8ODBsnPnTnVRvPbaa9Ux3EZAU3P1aZ/Pp/7S/+c//yl5eXkqc4BVq3/xi1+ov/yRpQE9gxKa5cHX4uL57LPPqoDjN7/5jcpY1OdPf/qTWr37u+++kw4dOgSPd+3aVc4777yw7Aku3DfddJNs375dZUAuv/xy9X3vuusuWbJkicp05Obmqtc3Y8YMcTiq//h76KGHVEBXVlamAgcEBKFqdj819B6EZqs++OAD9f23bNmiut4QiPXq1Uu1C6uZg54ZwWP4PnXB68TjyJp16tRJZWNCg5rXXntNXnrpJdW+Sy65JOw9wWrlCAr19xOfUc33E+3/5S9/2ayLsTKoiQKH1YnlzsVvsYi7yi1izJimXgg8kHnBdm5IUXKl1ye7D5WqkVfY7/6pTPYe1vbI+Bwu9ajtq311Py/m2clpiQAnEPRkpUiHkOAHXVtZaQ52bxEdB1yIyqvK4/K9U+1N757+1a9+pS6celCzYMECmThxorpAh5o1a5a8+OKLqquqR48eKnOALg4EAsgCoFvjiiuuUNkUrNysZ34A3VxTp05VmYY1a9aoi/gZZ5wh5557bq32IHBYvHixeu7QC3Comq9x9uzZKmCZOXNm8FhGRoYKIvAcmzZtUl1WOIbgSg8IEFjNnTtXtf+FF16QJ598UnX11Keh9+Dss88Onnf33XfLo48+qo4jgMN7vHr1ahk/frzqQlq+fLkKfBrLBq1cuVIFXKNHj5aOHTvK6aefroKwFi1aqMcR0CBYCg1oQt8jPDfeT2Tj8PnW9X6mp9culYgmBjVRYLG7JAX/sSCo8brFLBw2q/RAMXFO+HBzKHVXyR4V5JTJgcJyOVBYIT8eLZcD2AorVMFylc+vjmETOVLn90hz2oIBDvaYWRlBUMesNLVvl5HCWZWJGoCAZvjL4V0EsfL5NZ9LmkOroYgULsrTp0+XPXv2qPu4+OIiGBrUuN1uefDBB9WFeMSIEeoYLv6ffPKJPPPMM+qC3rp1a3W8Xbt2tboyBgwYEAw4EAygm2TFihV1BjUHDx5U2RFcrEOhCwoBE4wbN05eeeWV4GPoPrnjjjvCzkd3TGjm4s4771SvSw9q0D2DDA82QLcMXh+63+oSyXuge+CBB4L3p02bJhdeeKF6XgR6CCLQ9YPsUWOQmbn66qvFZrOp+hd8v3//+9/BzA6yUzXfp5oOHTqk6pxOPvlkiQcGNdFgc4oLQY1a/8k8QU1DWrjs0qdDS7XVBUPPC4rdKuDZf7QibI+gZ//RcjlU4pEyjzc4Qqsu+AOpTQunyvjktkyRnExtr9/OaelSt1Hfw4wPkfEhm4CLLrIayDLhdnZ2dtg5O3bsUBmDmkEI6ldOOeWURr8HgppQ7du3l4KCgia1E11J+H7o1ikvD8+EDR06tNb5yPYg84LutZKSEqmqqlIZJN3WrVtVFiUUghVkR+rSlPcg9PW2b99e7fF6m1KnhMAOXYEImkIDUAQ6elATSRFzvBdsZlATDTa7Cmr0mhrShp4j84JtSNe6z6mo9GoZniMIeMrlh6PaXt1H8HO0Qjxenwp+sNVcRiKUy26VXAQ5GVqw0y5Dm4gQAZHap2OvHWuZYmcARKaBLiBkTOL1vY8FukemTJmibqM7piYEBbBs2TLVDRLK5dIGZjQktI4F8PuObpH6gixkevSsjE4PCNCFhAt+KL07RocuLnS3oH5lzJgxqhsGWRp0CR2rprwHoa/XEvi/rb7XWx8UQyO7E1pDgwAFz4PaGNTDYPv2228bfB79/WzsvObCoCYabE7V/QSqpoYigkkAMWcOtrqggPlwmUfyAt1ZmGQwX912a7cDxzA/D9bQQncYtsY4bBZplVYj2ElzSKtAAKQ/pu9R98MJC8mocBFrahdQvJ1//vkq44C2IwioqU+fPurCjeLd0G6WUPqII6/Xe1xtsVqtqmgXtSuok6mvrqYhn376qSoqRm2LTu9e0/Xu3VvV+Nxwww3BY5999lm9zxnJexAJp9MZ0XuEjAy61GoWEWMINuqeUOR8zTXXqO6pt956q1ZdjVr2p6hIBXQ4BzVD6AKs+X4iWEOhMLrEkjqoQaSM4iWk9LDddtttqhDLEKwOcTJT0ywFzBiWjq1fx/qL25DxKQgJdLChkPmnQCEz9kcCtzGaq9LrV11j2CKF2p9gsIPgJxAE4Zh2H3uHehy3scYXa4GI6oaaDXTH6LdrQnYENSm///3vVaZAHx6M+ht06WCkE4IIBEVvv/22XHDBBcH6kUggsED2A4W4gNoV1PQMGzZM7rvvPtW9hGzM119/rbIwqC9pCOp2EHwgO4Phy8iuoPsqFK5ZCBjw3ChaRtEt5nmpr1A4kvcgEt26dZNdu3apeWowognPWzPTg8c2bNig2lSzFgajlfCeoAYIwR9eF46hhggjw5CZQWE0Cop/97vfqSHdqPHB+4msD27jNSOb9PHHH6v3/IsvvuCQbnwQqPzGxD6lpaXqhwxD6dq0aRPvponYHJLiY6YmXpBF0UdvNQYB0JEyj/xUogU5YUFPWXXwg3MwUSHuo+AZtT9lHr3oOTIZLrtkZ7jU0Pa2LQP7jOqtXWDfpoVLbBz6TkkmtN6kLpgvBhdMXAQxGR4ughgSjuHCgKAE3T0ojMXoKQQqkU7chwAEGRodriNr165Vw6cxAR+CADyOYAUjiG6//fYGnw/DmRF8oEsNBb6oE8LQ69Bh5Hge1NugcBjdPBi5NXnyZHn33XeP+T2IxBVXXKFqZTD0G8mBuoZ0I0uDzFBdxb2YKA+v65133lGvE91UGGKO7A0CFmRc8D7h/dezbijiRhYK2R0EQ8haYeh9//791fvbnPPxWPzxruo5xomS8MGuW7euVoFZffS0GCLdxn6ZmuzLF2Xi5/fKutQUeeRnj8j5J5wf3eenuMGvR7G7KizYOVxaWSsIQheYfh/nBGLciCCeQReYHuTom5alQl2QS3WToRi6ZapDWjhtrAlKUrgY4oKLOV2ac64PIiP9bDfl+h2zTA2yLIjQ1q9fLwcOHFApLKSpQqFgDOdgkqGBAwfK3//+d5UO1CHKRN8ihpXhvEgDmliNfpIkGv2ULBA8YKVzbJhNORKoBSqqqFQZoEOBbi50hx0sCexDjv1U6lYBEJa0wBayckW9MP8PghsUPOuBjnbfoe5rxwKPBY7hce2+nWt8EZFpxSyoQZcRAhVUvaPbqK7hcJgsCZMMoR8OY/qRykJFOuYhAKTeMB1zfn6+eg7MqpiTUz1ZXFy7nxjUUEgtEGpqsGF5iYZg6DsyPKGBjrpdVKGCInSTIfBBNqiwvFLVA6E7TO86OxbI9IQGQ7it1QShRsgR6BrThstjjwCJmSEiSgQxC2rGjh2rtvrMmTNHFf6ibxQQ3KDYCv126DMNhUAGARKKjvTpomtCvyY2nT59c7OwOqqHdFexUJgih6wJAgdsfSOZObbSK0XlVSrAQTaosCywx/3A8eBj6lhgq6hSRdJQ6vGqbX9hZD+rGC7frqVLDZfHvl3oHgFQ4DHODk1E8WaIQmEM7UO3FGaZ1KFIC6OdUHkOyM6gSBgFw+hXQ3cWiqzqg8Iqfc2LmA7pZqaGmnPortOuNszJ01TICiG4KaoR+KAg+qiqBaqUw6VaNxlGk2EUGc7HcPl9h8vV1hCnzarVAoUUQevF0e1q1ApxiDwRmTaowbTKGEdfsysJ9/UJfFA9jWXN8dcqNgwdQyV1fRAgoTsrNFODFWKbbfK9QGUoh3STkbNCash5i8gXJ9OHyxcUa/MDYY9uMn3YvP4YAiJMlFi9LEbD0OWF4mc1JB7D4zFcPt0ZDIL0ofwolMZjXBiViBImqIkECoYxlj5SGIcfycyTUS8U5pBuSsLh8u4qb7AuqL7iaH1D8KN3k4mUNtoGDHdHIKYHOdhjpmh0e+n1P6obLInqfxJw0CpRTH6mDRHUYBQTJmBCF1Mo3I9kEa64CwlqmKmhZOSy26RTqzS1NUTNOlpepbI7+vxAaj6gMk9gBJg2Ygy3ERBhqLzX5w8GRI3BhIdagKMFOcj+ZAeXytCGxutD5JEBSrT5gfTp8LEmUOiq1ESJrqysrM4lLhIyqME0zlgRFauo6sO8MYMi7uvrgxia1R6sqfF4j21EClEyQBYlM82hth4RnF/p9akRYAhy9CHyGA0WOjRebYH6H0+VT344Uq62xtsiwe4vbTkM/XZ1HZBWCK1lgrCIa7zhjz+MAtUXZ0SdYTJkpsi8/H6/CmjwM42f7bpmmG6KmP2WYr0HrDqq06dtxsyDWDgM9S+Y9hnTKaOrCUO6MQxcHw1laMzUEDULh01bqDSSwmjU/2iBTkWg1kdfKsMdGBqPIfLa8Hhkh/Arqw+N33mwNKKlMvQMEGaIxm10hYXVAWVomaDmXCJDz143ddVpIiNDQBONnpmYBTWY/RfTNOv0Il4EMpjaGlNIHzx4UC0ohsn3Bg0aJMuXLzfGPDSNsVUP6WZNDVH86n86t05TWyQjwRDYqDmASqq7wI6qbjCPVgsUUhitLZPhld0/lamtMRjergc8GA2GWiA98AkdEYYusaZ2gSEz0759ezV/V2Ul6pKIEpvD4TjuDE3Mg5qRI0c2WgiErqaE6G6qiZPvESXcSDB9iHkkMMePPimi3uV1UK/9Cez1miDUAKEWCNuOgpIGnxfxTJtAoKPN/RPIBIUumREIgmp2f+EiEK0LAZFZxL+T2Aww+Z7Pp26y+4nIfNJddrWdkN2i0SUyjpZXhgU7+iiwQ8WesPvoCsNMEHp90JYDjXd/hQY5tW6HLJDKFeIpWTGoiVpNjXaT3U9EyQvz6ehzAfXMyWjwXGR00P2F+p+atUChwQ+OYSZpdH/t+alMbY3Rl7uoM/BJr84EZaU6OAcQmQqDmqjV1DBTQ0SRQy2NvkRGY0oD3V91zfsTegzBENYG02qEKuW7/JJGF0fNbiTzU1/3F5ER8ac0yjU1HmZqiCjKEFBg6xZh91d1wFNRbwCEoAcBUF5RhdoaU1/3l74OmF78jCwVV4KneGFQEw0c0k1EBuv+6pXbcPcX5vQJnfOnrsDnWLq/MG0OVn3Xh7jrS17oQVB2cK8Nf0+0CRDJ2BjURIOVo5+IKLGgmLh9Zqramtr9hVFgGOmlD3nXJ0LUi5/VnEClHtkWPkl8LYhn9CUwagY9wSHwgSHxXAOMIsGgJhqsVnGJlm5lUENEydr9heJnTGZYPcRdG/Wljf6qDor0GaIRAKmlMUo88m1ecYPPjYwO1vxSI7wC638h0MGSFzXXBsM5XAk+OTGoiRKXRXsrK7xuNR8Ppy4nomSDwCPS+X8wAeJhTHZYI+gJ7oMBkDbrMwImfY6gSGAIPoIcBEBa0FO97lfoshhqhfgWTlUzxP+3Ex+DmihxWavfSo/PIy5bjFYIJyJKQCgmjnT0F9YAQ2BTPecPCp21Li7MCK3WBQscRxCEleAxYSK2SGaABqfNqtYkwzB3zAitrwCf0xKbK7jHWmAZruRYDT4RMaiJkhRr9cqiFVUVDGqIiKK4BpgWVDQeACFTXuyuCix+qq33pe212wh6EBCpYe8Iiso8qmgagVCkq8Ejq4O2YLRXaNCDgCcneCxFUp3sAos1BjVRYrc6xOr3i89i4UrdRERxggxKyxSH2rq3lYiCIIzuQiaosFxb3gJBD4KifGyFFZJfXCH5RW7JL6qQ4ooqNRJs16FStTWkZYo9GOBg6LseCOk1Qej2Ut1haRwGHy0MaqLEooZ1+6TcYuGwbiKiBAqC0px2tXVq1fj5ZZ4qNcwdAU5+YCSYul3kVvP94D72FZU+KaqokqKKEtneyBpgeg1QRoq+OdS+ZWCfmeqQltgQrKXaA91iWvcYs0HhGNREi80uKX63lHOpBCIi00Lw0y274ZFgeheYFvAEAqDAHsPg0RWGzBA2ZIUwCkyvATpQ2LT21JUNyskI6Q5rqRVuu+zJEfwwqIkWlanRMjQc1k1ElLxCu8BOatf4GmBHy7SuL3RtYStxV6osD24XlVcGHyuqQPeYVjDd1GxQ6xbOsBqgYLYnEBDhNobDo34pkTGoieZSCQi3OaswERFFSM2/gxqb9KYNLmksG5Sv3y5yqyJoPTPU0HxAGNCFQAxD3UOHvLdScwLpx7TbaK8RF0VlUBMtVoc49VmF2f1EREQGyAb5/cgEVYYVO4cFQoG6IMz/g6wRskLYJMKh8FgUFcXOCHA6ZaXJXWNPlhMamaSxOTGoiRabU1KqmKkhIiJjBT+tkGlp4ZSTcxufDRrdW9oq7zVul+rHKtUweD3zg0VRtQDJLd/8WCQntmshfxhzssQLg5posTnEVRlYqZtDuomIyKSzQYdOioiiZ9T4PPm/7fL+lkYW+4oBBjXRDGq4UjcRESUJh80quZkpatODoXgXGid2mbNRV+pmTQ0RESURT5UvuPp7PDGoiRZmaoiIKElVegNBDTM1JioU1jM1nKeGiIiSMFPjYqbGJGwOcerz1FQxU0NERMkX1DiYqTHR5HvM1BARURLy6N1PzNSYhLW6poZBDRERJRMPC4XNuPYTgxoiIkriTI2NQY35up84pJuIiJKxpsbOoMZEQ7q1D5VDuomIKClHP9kY1JgDh3QTEVGyz1NjZ1BjnlW6OaSbiIiSkIeFwibDId1ERJTkhcIOdj+Zb5kEBjVERJRM3MzUmAxraoiIKElVcki3iTM1HNJNRERJxMO1n0zGmc5VuomIKOlUeX0SGCfDmhrTSM1i9xMRESVtkTCwpsYsUloFh3QjqPEHAhwiIiIzq6yqvt4xqDGL1CxxSvUHW+WrimtziIiIYsHt9QZv260WiaeECmrefvtt6dWrl/To0UOeffZZMZTUVmIJSc74QwIcIiKiZJh4z2KJb1BjlwRRVVUlU6dOlZUrV0pmZqYMGTJELrvsMmnTpo0YQkqmhH6UDGqIiCgZVHr9hlj3CeLfggitXbtW+vbtKx07dpT09HQZO3asvPfee2IYVptYXRnBu77A4pZERERm5jHIxHsQsxasWrVKxo0bJx06dFDpqaVLl9Y6Z+7cudKtWzdJSUmR4cOHq0BGt3//fhXQ6HD7xx9/FENxZQVvslCYiIiSKahxJFOmprS0VAYOHKgCl7osXrxYdS/NnDlTNmzYoM4dM2aMFBQUSKKwpmbGuwlEREQx5QkUCidVpgbdRffff7+qg6nLnDlzZNKkSTJx4kTp06ePzJs3T9LS0mTBggXqcWR4QjMzuI1j9XG73VJUVBS2NTdLSFDD7iciIkoGnsCQ7qQKahri8Xhk/fr1Mnr06OAxq9Wq7q9Zs0bdHzZsmHzzzTcqmCkpKZH//ve/KpNTn1mzZqmCYn3r3Llzs78OS2j3EwuFiYgoiSbfcyZT91NDDh06JF6vV3JycsKO435eXp66bbfb5dFHH5VRo0bJoEGD5I477mhw5NP06dOlsLAwuO3bt6/ZX4cltTqoYaaGiIiSqqbGHv+QImGGdMPFF1+stki4XC61xZIlpTqoISIiSqrFLG3xD2ri3wIRyc7OFpvNJvn5+WHHcT83N1cShTW1VfA2Rz8REVEyqNS7nwyQqYl/C/BGOJ1qMr0VK1YEj/l8PnV/xIgRkigsIUGNT9j9RERE5ucx0Dw1Met+QnHvjh07gvd37dolGzdulNatW0uXLl3UcO4JEybI0KFDVVHw448/roaBYzRUorBkVGeVmKkhIqJk4A5kahy2+C6RENOgZt26darIV4cgBhDILFy4UMaPHy8HDx6UGTNmqOJgFAMvX768VvGwoaXniMXvF7/FwtFPRESUZJkaW/IENSNHjmw0ezFlyhS1Jaz0dmr9J7xKv4/dT0RElEQ1Nbb4dz/FvwVm0qJd8A31uwvj3BgiIqLkqqmJfwvMxJESvOkrDh/JRUREZOqgxhb/mhoGNVFmUR1QWOwqcdasIiIiOlYc0m1iVosW1PjLfop3U4iIiJqdm91P5s/U+EoPxbspREREMVv7ycFCYfOxBDM1DGqIiMj8PMzUmD9Tw+4nIiJKBpUc0m1eFov2ljKoISKipFrQ0h7/kCL+LTAZK4MaIiJKwqDGwUyNCQWCGl/54Xi3hIiIKGaFwqypMSGrRVv7wl92BEuNx7s5REREzYqFwiZmsQa6n/xVIhVH490cIiKi2GRq2P1k3kyND6OgSjirMBERJUlNjT3+IUX8W2DSQmEfRnZzqQQiIkqW0U+2+IcU8W+BSVXhH2ZqiIjI5CpZKGxeZZVlar/L4RApPRjv5hARETUrFgqbWFmVFtSk+v0iJfnxbg4REVGz4tpPJja43WC1Vx9xCTM1RERkbh5masxfKOzFwpYsFCYiIpPzcEi3edms2pBuL/5hoTAREZmch2s/mZdNn6dGDelm9xMREZlXldcnPr92mzU1Jg5qvJh8D0ENCoaJiIhMqNJbfY1jTY2Ju5+qkKnxerhUAhERmb7rCRjUmJDD6lD7KnuadoAjoIiIyKTcXlVBKhgbY7fir/n4YlATZXaLXe2rUtK1AxwBRUREZl/3yWYVCyKbOGNQE2UOWyBT4wwENRwBRUREJq+pcRmgSBiM0QoTsVu1TE2lU+9+YlBDRETm5DHQxHtgjFaYsftJD2rY/UREREnQ/WQExmiFCbufKh2p2gFmaoiIyKQ8gUJhZmrMnqmxp2gHOAEfERGZlKdKq6lhUGP2mhqHSzvATA0REZmUx0DrPoExWmHG7iebHtTkx7dBREREzV1Tw0yNuSffq7RreynOE/FpfY5ERERmUhnI1HBIt0m5AhkaD7qhLFYRv5d1NUREZEoeDulOjkyNx1cpkp6jHSzaH99GERERNQMGNSbntDnV3uPziGS01w4WH4hvo4iIiJqBO9D95LDFf4kEYFDTTEFNpbdSpGUH7SAzNUREZEKVwUyNTYwgYYKao0ePytChQ2XQoEHSr18/mT9/vhiR06oFNW6vm0ENERGZmsdgQ7q1SVUSQEZGhqxatUrS0tKktLRUBTaXX365tGnTRoyE3U9ERJQsPKypOTY2m00FNOB2u8Xv96vNaNj9RERESRfU2ExWU4Msyrhx46RDhw5isVhk6dKltc6ZO3eudOvWTVJSUmT48OGydu3aJndBDRw4UDp16iR/+MMfJDs7WxKi+6nwh/g2ioiIqBnnqTFdpgZdQgg4ELjUZfHixTJ16lSZOXOmbNiwQZ07ZswYKSioXkZAr5epue3fr2U6srKy5KuvvpJdu3bJyy+/LPn5xputNyWw5lNFVYVIdi/t4OHvRTxl8W0YERFRlLkN1v0UtZqasWPHqq0+c+bMkUmTJsnEiRPV/Xnz5smyZctkwYIFMm3aNHVs48aNEX2vnJwcFRR9/PHH8otf/KLOc9BFhU1XVFQksZBq11bnrvBWiGTkiLgyRdyFIoX7RNoGghwiIiJTFQrbxAhiElp5PB5Zv369jB49uvobW63q/po1ayJ6DmRliouL1e3CwkLV3dWrV/1BwqxZsyQzMzO4de7cWWIZ1JRXlWsHMjtqe3ZBERGRadd+skjSBDWHDh0Sr9erMiyhcD8vLy+i59izZ4+cddZZKkOD/e9+9zvp379/vedPnz5dBT/6tm/fPoll9xOCGp/fJ9IyENQU/RiT709ERBTzmhoO6W6aYcOGRdw9BS6XS22xlmbXRmjpxcKpwUwNgxoiIjJnpsZlkJqamLQCo5QwJLtmYS/u5+bmihkXtAx2QbXspN0pYvcTERGZtPvJlkRBjdPplCFDhsiKFSuCx3w+n7o/YsQIMROb1RZc1NJd5Q6pqWGmhoiITFoobDdZ91NJSYns2LEjeB/DrtFd1Lp1a+nSpYsazj1hwgS11AG6kh5//HE1DFwfDWUmKbYUqfRVaiOgWFNDREQm5THrkO5169bJqFGjgvcRxAACmYULF8r48ePl4MGDMmPGDFUcjDlpli9fXqt42AyKK7VRWkfdR0UyO1VnajADssUYFeJERETHy7RrP40cObLRZQumTJmitmTx9cGv5ZSeV2l3KktFKo6KpLaKd7OIiIiiPKTbGEGNMVphMh1adKheB8qRKpIWWHSTc9UQEZEJh3S7DJKpMUYrTOaUnFPU3uP1aAeCC1tytW4iIjIPj8FqaozRCpPRF7VEsbDCYmEiIjIhD4Ma81PdTiLyU/lPNYIabWFOIiIiMxUKO9j9ZF7/2fkftX9x64s1up8Y1BARkXl4mKkxv47pgcyMjt1PRERkQh6DDek2RitM5vdDfq/23TO718jUMKghIiLz8CTj2k/JpqWzZY3RTyFLJTQylw8REVEiqPL6xBe4pLGmJgmCmiJPUeBA++oJ+NyBY0RERAms0lv9RzprakyspUsLaoo9xeL1eUWcLURSsrQHWSxMREQm6noCBjUmlunKVHu/+LX1n4DFwkREZCJur1ftsaSh3WqMdQ0Z1DQDh9UhGY6MGl1QHNZNREQmXPfJZhWLQRZrZlDTTFx2l9q7vW7tAIMaIiIyYU2NyyBFwmCclphMla9K7SuqKrQD7H4iIiIT8Rhs4j0wTktMRq+lWbJjiXaAmRoiIjJp95NRGKclJvX1wa/DgxrMVUNERGSW2YTtxgkljNMSkxmQPUDtL+x+oXYgs7O2L9zHCfiIiCjhedj9lDxapbRS+3X567QDWV20vadEpOxwHFtGRERkvnWfwDgtMZmPfvhI7Vf/uFo74EgRyQjMLHxkdxxbRkREFMWaGmZqklSrbtr+yK54t4SIiOi4VAYyNRzSnQSuOfkatXdanbWDmqN74tQqIiKi6GBNTRLpl91P7T2+wErd0Lq7ts/fHKdWERERRQeDmiSSV5pX+2BOX23/086Yt4eIiCia3IHuJ4fNGEskAIOaZnL+CefXPtjqBG3PQmEiIkpwlcFMjU2MgkFNM8lyZQVvB9d/atVV21ccFSk/EqeWERERHT8O6U4iLRwtgreLPcXaDWcLkRbttNtHWCxMRESJy8OamuRhtVhrBzVhw7rZBUVERCYIamysqUkqwUUtgUENERGZaJ4aJzM1yeVQ2aHqOwxqiIjIBNzsfkouPVv1VPvOGYHFLIFBDRERmapQ2CZGwaCmGX135Du1f/qrp6sPcqkEIiIy0ZBuh501NcmrdWCumqN7RapCZhsmIiJKIB4O6U4uV/W8qvZBrNRtTxXx+7TAhoiIKIFHP7lYU5McdhXV0cVksVSvAXX4+5i3iYiIKJpBjYOZmuRwuPxw3Q+00YMargFFREQJ3v1kN04oYZyWmNANfW+o+wFmaoiIKMF5OKQ7uQzLHRa8va94X/UDrU/U9lytm4iIEpSHhcLHZ9euXTJq1Cjp06eP9O/fX0pLS8XIqnxVwduF7sLqB9oEghpmaoiIKNFrauzGCSXskkBuvPFGuf/+++Wss86Sw4cPi8vlEiMLnXTP6/fW7n7C6CdvpYjNEYfWERERHf8yCS5mappu8+bN4nA4VEADrVu3Frvd2DGZzVo9y+JXBV/VMazby9W6iYgoIXnMXFOzatUqGTdunHTo0EEsFossXbq01jlz586Vbt26SUpKigwfPlzWrl0b8fNv375d0tPT1fcYPHiwPPjgg5IIHFYtC1PoKawxrDswCR+XSyAiogTkMXNQg/qWgQMHqsClLosXL5apU6fKzJkzZcOGDercMWPGSEFBQfCcQYMGSb9+/Wpt+/fvl6qqKvn444/l6aefljVr1sj777+vtkQpFl72/bLwB7K6avujzNQQEVHiFgo7DNT9FLX+m7Fjx6qtPnPmzJFJkybJxIkT1f158+bJsmXLZMGCBTJt2jR1bOPGjfV+fceOHWXo0KHSubNWp3LBBReo888999w6z3e73WrTFRUVSTys3r9a7X8s+TH8gawu2p5BDRERJSCPmTM1DfF4PLJ+/XoZPXp09Te2WtV9ZF0iceqpp6qszpEjR8Tn86nurt69e9d7/qxZsyQzMzO46cGQYbQKZGpYU0NERAnIk6xDug8dOiRer1dycnLCjuN+Xl5eRM+BomDU0fzsZz+TAQMGSI8ePeSiiy6q9/zp06dLYWFhcNu3L2SemBga32t88LYP6z3V6n7i+k9ERJR4PAZc+8nYw4ea2MUVCsO9jTDku2N6x+DtIxVHpE1qm/BMDbufiIgowXh9fvH5xXA1NTFpSXZ2tthsNsnPzw87jvu5ubliZvroJyirLKtdU1P2k4i7JA4tIyIiOr4sTVLW1DidThkyZIisWLEieAx1Mbg/YsQIMbPLe1wevL1kx5LqB1IyRVJbabc5szARESUQj9mDmpKSEjUaSR/BhCUNcHvvXq1mBMO558+fL4sWLZKtW7fK5MmT1TBwfTSUWaU50oK352+aH/5gu77aPv+bGLeKiIjo2Lm93uC0a3arRUxXU7Nu3Tq1LpMOQQxMmDBBFi5cKOPHj5eDBw/KjBkzVHEw5qRZvnx5reLhpJLTV2TPJyL5m+PdEiIioohVev3BehpMuGu6oGbkyJHi9weqhuoxZcoUtVFIUAMMaoiIKBFHPtmM0/UExmpNEthbFDKEu11gnp1D38WtPURERGaYeA+M1RqTapvaNng7vyy/9mrdRftFKivi0DIiIqJjD2qMNJwbjNUak5o5Ymbw9gtbXqh+IK2NiDNdRPychI+IiBJvNmG7scIIY7XGpNqmVWdqVu5bWf0AiqtacbVuIiJKLB52PyUvm8UWwRpQDGqIiCgxeAy47hMYqzUm1aNVj/ofbK1nanbFrD1ERERRqalhpib5WC0NvM2tuml7ZmqIiChBVAYyNRzSTeH0mprDzNQQEVFi8LCmhhrO1OzCgljxbg0REVGjGNRQkMfrqb6T1VXE5hKpqhAp5LBuIiIyPneg+8lhM84SCcCgJkZWXFm9QvlXB7+qfsBmF8kOFBIf3BaHlhERETVNZTBT08Do3jhgUBMj7dLaBW8/uu7R8Aeze2p7BjVERJQAPBzSTbrNP9VYwLLtydqeQQ0RESUAD2tqqF5te2n7g9/GuyVEREQRD+l2sqaGagnN1Pj98W4NERFRg5ipoTA/lf8Uvlq31S7iKdZW7CYiIjIwN4Ma6pjeMXj7+8Lvqx+wO7XABg6xroaIiBKlUNgmRsKgJoayXFnB21t+2lJPXQ2DGiIiSowh3Q47a2qS1u1Dbg/enr1udj11NSwWJiIiY/NwSDdlp2TX/yCHdRMRUYIVCrtYU5O8UuwpkQ3r5ggoIiJKgKDGwUxN8uqU0an+B9ucJGKxipQfESk9GMtmERERHVv3EzM1pCt0F1bfcaRWj4DK2xS3NhERETWG89SQMjRnaPD2nR/dGf5g+0Hafv+XMW4VERFR5FgoTMpfTvtL8PZnBz4Lf7D9QG3PTA0RESVCTY3dWGGEsVqTBLpldmt8BNSh72LWHiIiomNd+8nFTE1ys6IYuLERUIe2i3irYtYmIiKipmBNDdXJ6/NW38nsLOJIE/FVihzZFc9mERER1YtBDdVpf0nIApZWq0h2T+02J+EjIiKD8ni1+dQ4Tw2F8fpDMjXA5RKIiMjgPFXatYuZGgrz5vY3ww9wYUsiIjI4D4d0k+72wdULWz63+bnwB9v11vb5m2PcKiIioshw7ScKuq7PdfU/2K6Ptv+JI6CIiMh4vD6/+AJLFLKmhsRlc9X/oBoB1ULE6xE5/H0sm0VERBRxlgZYU0MNrwGFEVB6XU3Blri1iYiIqC4MaqiWCX0mBG/f/9n94Q+2H6Dtf1wX41YRERE1zO3VRj5ZLCJ2q0WMhEFNnPRv2z94e/nu5eEPdhqm7X9gUENERMZSGTJHjQWRjYEwqImT87qeV/+DnU7V9vs3ingrY9YmIiKiiEc+GaxIGIzXogbMnj1b+vbtK/369ZMXX3xRElmD0W2bk0RcmSJV5ayrISIiQ/EYdIkEMF6L6rFp0yZ5+eWXZf369fLFF1/IU089JUePHhWzKKssCy8W7jhYu80uKCIiMhAPg5rjt3XrVhkxYoSkpKRIamqqDBw4UJYvr1GLksD2FO0JP9BxSOCBT+PSHiIiooZmEzbaHDUQtRatWrVKxo0bJx06dFBdK0uXLq11zty5c6Vbt24qMBk+fLisXbs24udHl9OHH36osjNHjhxRt3/88Ucxi//s/E/4ga4jtP3uT+LSHiIioqTN1JSWlqrsCQKXuixevFimTp0qM2fOlA0bNqhzx4wZIwUFBcFzBg0apIKXmtv+/fulT58+8n//939yzjnnyOWXXy6nnXaa2Gw2MYsXt9aoEeoyQsRiEynJEykKWcmbiIgojjwGXfcJ7NF6orFjx6qtPnPmzJFJkybJxIkT1f158+bJsmXLZMGCBTJt2jR1bOPGjQ1+j1tuuUVt8Otf/1p69OhR77lut1ttuqKiIkkozhbaOlD534j8uEGkZYd4t4iIiEgqA5kah5kzNQ3xeDyqwHf06NHV39hqVffXrFkT8fPoWZ1t27apritkeuoza9YsyczMDG6dO3cWo/njqX8Mu+/zV8/SqHQ4Rdsf+CqGrSIiImo8U5O0Q7oPHTokXq9XcnJywo7jfl5eXsTPc8kll6huqOuuu06ee+45sdvrTzRNnz5dCgsLg9u+ffvEaM7tem7Y/YKy6q44JTuQiTqyK4atIiIiSsyamqh1P8VCU7I6LpdLbUaW2yI37P4zXz8jM0fMrD7Qqpu2P7I7xi0jIiJKvKAmJi3Kzs5WRb35+flhx3E/Nzf8wp7MXv/u9fADDGqIiMiwQ7otkpRBjdPplCFDhsiKFSuCx3w+n7qPuWeS2TUnX1P/g1ldtX3pQRFPaczaRERE1HimxmbeoKakpESNXtJHMO3atUvd3rt3r7qP4dzz58+XRYsWqYn0Jk+erIaB66OhktWZHc8Mu+/1aaufKqlZIilZ2u0jNSbnIyIiigNPMgzpXrdunYwaNSp4H0EMTJgwQRYuXCjjx4+XgwcPyowZM1RxMOakwYzANYuHkz2o2Vu8V07IPCG8C+rARq0LKqdP7BtIRESUIDU1UQtqRo4cKX6/thx5faZMmaI2qn9hy5e3vix3n3Z37aDmKDM1REQUf5XBTE2S1tRQ5F7d9mr4gVaBuhoWCxMRkQF4DJypMV6LktC1va+t/0GOgCIiIgNxM6ihhkwZFN4lV1FVUX2HQQ0RERmyUNgmRsOgxgDSnelh99/+/u06gpo9Io3ULBEREcVu7SfW1FAE7l1zb/WdzM4iFqtIVblISY1lFIiIiGLMY+Ah3cZrUZK69KRL637A5hDJ7KTdXj5NpOhATNtFRERUV6GwizU1VJ+bB9wcdr/IU1R9p98vtP3mN0Wev5jdUEREFP8h3XbjhRDGa1GS6pzROez+ku1Lqu+MultkRKCY+NB3Ige3xbh1RERE4aOfHOx+okjNXje7+o7NLjLmAZGTRmv3F10kUvpT3NpGRETJy8Mh3XQsKr2V4Qf6XFq9wOUXz8alTURElNw8LBSmSFx84sVh91/a+lL4CadcJ3Lab7Xb37wew5YRERGF19Q4mKmhhkzsG75i+aPrHw0/AetEjZwmYrFptTVH98W2gURElPQ8+ugnZmqoId2zujd+UkqmSPsB2u29a5q9TURERKFYU0MRsVqscs3J1zR+YufTtP0PXzR7m4iIiEIxqKGIXdM7PKjZdHBT7ZM6n6rtd6+OUauIiIg0Hq82VxqHdFOjurbsGnb/je1v1HHSmdq+YDOXTiAiopjyVHnVnpkaarI6g5qMHJHsXtrt/V/GvE1ERJS8PBzSTVHXcbC2Z10NERHFkIdrP1HUtR+k7Qu2xrslRESUJLw+v/gCyw+ypoaOyfeF39c+2Dow/Pvwrpi3h4iIkjtLA6ypoYiM7Dwy7P4jXzxS+6TWJ1QXC3PVbiIiigEGNdRkvVoFioADPvnxk9onZXWpvl2cF4NWERFRsnN7vcEJ7u1WixgNgxoDGtNtTOMn2V3Vt4/uadb2EBERQWXIHDUWRDYGw6DGgHq06lHr2JGKI/V/weYlzdsgIiIiMfa6T2DMVlEtv/jPL+p/8PN5sWwKERElKY+Bl0gAY7aKZPLAyWH3C8rrmDm421mxaxARESW9Sn3iPQY11BQXdb+o1rGyyrLwAyOnV9/2lMagVURElMzcgUyNEeeoAWO2iqRLy5DRTQGvfPtK+IGOQ6pvv/fnGLSKiIiSmYfdTxQtj294PPyAI0XkrDu129uWc74aIiJK2nWfwJitosj9LBDUFO8Xyfs63q0hIiITq9S7n5ipoWbhSK2+venf8WwJERElSabGxUwNNdWozqNqHfvuyHf1f8Gnf2/eBhERUVLzsKaGjtWfhv+p1rHlu5bXPrFlx9g0iIiIkpqHQQ0dq9wWuXJmxzPDjs3fNL/2ib0vjl2jiIhIkr37yWEz3hIJwKDG4J4Y9UTjJ/U8r/p2ZUWztoeIiJKXJ5ipsYkRMagxOKfN2fhJHQZX334gp1nbQ0REycvDId0UbYXuwvADqVnxagoRESURD2tqmu6yyy6TVq1ayS9+Eb6I4759+2TkyJHSp08fGTBggPz738kxhPn8bueH3V+4eWHtk64PWanbp/3QERERNcvaT6ypidxtt90mzz//fK3jdrtdHn/8cdmyZYu89957cvvtt0tpqfnXPLp9yO1h95/d9Gztk7qMqL794/oYtIqIiJKNh5mapkM2JiMjo9bx9u3by6BBg9Tt3Nxcyc7OlsOHD4vZdWjRoWmT8P1rdLO2h4iIkntBS6dZgppVq1bJuHHjpEOHDmKxWGTp0qW1zpk7d65069ZNUlJSZPjw4bJ27VqJtvXr14vX65XOnTuL2eF9runBzx+MS1uIiCh5VQa7n0wy+gndPQMHDlSBS10WL14sU6dOlZkzZ8qGDRvUuWPGjJGCgoLgOci29OvXr9a2f//+iNqA7MwNN9wg//znPyVZvHfFew2v2E1ERBSj7ieH3Zg1NfamfsHYsWPVVp85c+bIpEmTZOLEier+vHnzZNmyZbJgwQKZNm2aOrZx48ZjbrDb7ZZLL71UPdfpp5/e4HnYdEVFRZLI2qe3r3XM7/fXmcUhIiJqDkk1pNvj8ahuodGjq2s6rFarur9mzZrjfn5cxG+88UY555xz5Prrr2/w3FmzZklmZmZwM2M31evbX6//Qb8/lk0hIqIkytS4zFJT05BDhw6pOpecnPAJ4HA/Ly8v4udBEHTllVfKO++8I506dQoGRKtXr1bdW6jjQRcWtk2bNtX5HNOnT5fCwsLghuHgZnPfmvvCD5x1Z/XtQw0sfElERHQ8NTUGDWqa3P0UCx988EGdx88880zxRTgHi8vlUpvZ5qtZvruOBS11g28Q+Xi2dnv1EyKXPh2zthERUfKMfnIkQ/cThljbbDbJz88PO477GIJNx6fm4pbwY8mP1XeyulTf3vhSjFpFRETJwmO2Id0NcTqdMmTIEFmxYkXwGDIruD9iRMjkcHRMxp04rtax93e/X32HRcNERJTEhcJN7n4qKSmRHTt2BO/v2rVLjWZq3bq1dOnSRQ3nnjBhggwdOlSGDRumZgDGMHB9NBQdO6vF2nCmhoiIKAY1NQ67SYKadevWyahRo4L3EcQAApmFCxfK+PHj5eDBgzJjxgxVHIxi3uXLl9cqHqZjk+XKkqPuo8H7r257Ve4+7e66T/ZWitgcsWscERElx+gnm0mCGixhgKHVDZkyZYraKPr+ctpf5I6P7gg7VumrFIe1juCl9JBIy9rz2xARER2LpKqpoebXMb1jrWP3f3Z/3SfPOVmkOPKh9ERERA1hUENRldOidjfem9vfrL5z1QvhD77x6xi0ioiIkoHH60+eId3U/LJTs+s8HuwSzO0X/sDuj2PQKiIiSgaeKq/aM1NDzWrA8wO0wCYzZK4aHSbiIyIiMvmQbmO2io7J/tL9ItY6loN/f0Y8mkNERCZTGeh+Soq1nyi+Hlr7kPxv30pZk1LH8hBb345Hk4iIyCS8Pr/agDU11Ow+3Peh3LbyNrm5fR1zAi2+Nh5NIiIik418AtbUUNSsvGplo+f8Ored2uNHsP8JXdT29ONdpP+i/nLac33Fc0+m/ObZ/rJo0dkintIYtJqIiBKZh0ENxXIEVKjPU1PUfn1IV9Q/WmWqfanVKv/JaCGrHSKz5bDI2n82Y2uJiMhMRcIWi4jdasy1BhnUmBiyM7+qqytKRO7NblN93s4FMWwVERElclDjsFnFYtAFlBnUEBERUcKv+wTGbRkREREZhsfgSySAcVtGMdXYIqVERJTcKvWJ9xjUkNFNe39yvJtAREQG5g5kaow6Rw0Yt2XUoJy0uguAj9Xmo9uj+nxERGQuHnY/UXPxC7uLiIgodjwGX/cJjNsyahhjGiIiiqFKvfuJmRoyeqaGMRIREUWSqeGQboq6szqdFdXn21teENXnIyIic/Gwpoaay12n3iWndzg93s0gIqJkq6mxGzd0MG7LqEFpjjSZddaseDeDiIiSLFPjsBlziQRgUENERERN6H6yiVExqCEiIqJGcUg3NSuLGDcFSERE5hzS7WRNDREREZkjU2MRo2JQQ0RERI3ikG5qVux+IiKiWC9o6WRQQ0RERImsMtj9xNFPREREZIZ5auzG7SVgUJPALBbj/mAREZG5eDikm4iIiMyUqXGxpoaIiIhMUVNjN27oYNyWERERkeFGPznY/URERESJzJMAQ7rtkiT8fr/aFxUViVkUuYvEW+6N3vOZ6L0hIqLoKispFp+7TCrLS2N6vdC/l34db4jFH8lZJvDDDz9I586d490MIiIiOgb79u2TTp06NXhO0gQ1Pp9P9u/fLxkZGVEfCo0oEgET3vCWLVuK2fD1JT6zv0a+vsRn9tfI13fsEKYUFxdLhw4dxGptuOsrabqf8EY0FuEdL3yQZvxh1fH1JT6zv0a+vsRn9tfI13dsMjMzIzrPuNU+RERERE3AoIaIiIhMgUFNFLhcLpk5c6bamxFfX+Iz+2vk60t8Zn+NfH2xkTSFwkRERGRuzNQQERGRKTCoISIiIlNgUENERESmwKCGiIiITIFBTR3mzp0r3bp1k5SUFBk+fLisXbu2wfP//e9/y8knn6zO79+/v7zzzjthj6MWe8aMGdK+fXtJTU2V0aNHy/bt2yVRXuP8+fPlrLPOklatWqkN7a95/o033qhmag7dzj//fEmE17dw4cJabcfXGfkzbMrrGzlyZK3Xh+3CCy805Oe3atUqGTdunJo9FO1YunRpo1/z4YcfyuDBg9XIi5NOOkl9psf7e22k1/jmm2/KueeeK23btlUTm40YMULefffdsHPuueeeWp8h/l9KhNeHz6+un9G8vDxDfoZNfX11/X5h69u3ryE/v1mzZsmpp56qZuBv166dXHrppbJt27ZGv84I10IGNTUsXrxYpk6dqoambdiwQQYOHChjxoyRgoKCOs//9NNP5Ze//KXcdNNN8uWXX6oPH9s333wTPOdvf/ubPPnkkzJv3jz5/PPPpUWLFuo5KyoqYvjKjv014j8cvMaVK1fKmjVr1FTY5513nvz4449h5+EieODAgeD2yiuvSCK8PsCFIrTte/bsCXvcSJ9hU18fLoihrw0/mzabTa688kpDfn6lpaXqNeECFoldu3apAG3UqFGyceNGuf322+XXv/512EX/WH4mjPQacRFFUIOLxPr169VrxUUV/+eEwkUy9DP85JNPJBFenw4XztD244JqxM+wqa/viSeeCHtdWEqgdevWtX4HjfL5ffTRR3LrrbfKZ599Ju+//75UVlaq//PxuutjmGshhnRTtWHDhvlvvfXW4H2v1+vv0KGDf9asWXWef9VVV/kvvPDCsGPDhw/333LLLeq2z+fz5+bm+h955JHg40ePHvW7XC7/K6+84k+E11hTVVWVPyMjw79o0aLgsQkTJvgvueQSvxE09fU999xz/szMzHqfz2if4fF+fo899pj6/EpKSgz5+YXCf1FLlixp8Jw//vGP/r59+4YdGz9+vH/MmDFRe8/i/Rrr0qdPH/+9994bvD9z5kz/wIED/UYTyetbuXKlOu/IkSP1nmPUz/BYPj+cb7FY/Lt37zb85wcFBQXqdX700Uf++hjlWshMTQiPx6P+CkJKLHTNKNxHhqIuOB56PiDy1M/HX5FIoYaegzUskDqt7zmN9hprKisrU5E7/tKomdHBX1a9evWSyZMny08//SSJ8vpKSkqka9euKgt1ySWXyObNm4OPGekzjMbn969//Uuuvvpq9VeS0T6/Y9HY72A03jMjLtCLBf5q/g4ilY8uke7du8u1114re/fulUQyaNAg1TWBrNTq1auDx832GeJ3EG3H/zmJ8PkVFhaqfc2fNyNeCxnUhDh06JB4vV7JyckJO477Nft2dTje0Pn6vinPabTXWNNdd92lfvFCfzjRdfH888/LihUr5OGHH1bpy7Fjx6rvZfTXh4v4ggUL5K233pIXX3xRXTBOP/10+eGHHwz3GR7v54caBKSD0T0Tyiif37Go73cQqwaXl5dH5WfeaGbPnq0C8auuuip4DBcH1BItX75c/vGPf6iLCGrhEPwYHQIZdEm88cYbasMfF6gFQzcTmOkz3L9/v/z3v/+t9Tto1M/P5/OpLt0zzjhD+vXrV+95RrkWJs0q3RQdDz30kLz66qvqr/rQYlr85a9DgdiAAQPkxBNPVOf9/Oc/FyND0SU2HQKa3r17yzPPPCN//etfxUzwFyI+n2HDhoUdT+TPL9m8/PLLcu+996ogPLTmBEGoDp8fLpLIBLz22muqzsHI8IcFttDfwZ07d8pjjz0mL7zwgpjJokWLJCsrS9WbhDLq53frrbeqP4TiVd/TVMzUhMjOzlYFlPn5+WHHcT83N7fOr8Hxhs7X9015TqO9xtC/DhHUvPfee+qXriFIn+J77dixQxLl9ekcDoeccsopwbYb6TM8nteHIj8EpJH8Bxmvz+9Y1Pc7iOJvjLCIxs+EUeDzw1/4uNDVTPXXhAtnz549E+IzrAsCb73tZvkMUYKDrPD1118vTqfT8J/flClT5O2331aDRDp16tTguUa5FjKoCYEfsiFDhqgUfGjqDfdD/5IPheOh5wOqxfXzTzjhBPWBhZ6DtDgqv+t7TqO9Rr1qHVkLpEaHDh3a6PdB1w1qMpBWToTXFwpp7k2bNgXbbqTP8HheH4Zbut1uue666wz7+R2Lxn4Ho/EzYQQYjTZx4kS1Dx2OXx90TyHbkQifYV0wkk1vu1k+Q3TrIkiJ5A+LeH5+fr9fBTRLliyR//3vf+r/wMYY5loYtZJjk3j11VdVNfbChQv9W7Zs8d98883+rKwsf15ennr8+uuv90+bNi14/urVq/12u90/e/Zs/9atW1UFu8Ph8G/atCl4zkMPPaSe46233vJ//fXXapTJCSec4C8vL0+I14j2O51O/+uvv+4/cOBAcCsuLlaPY3/nnXf616xZ49+1a5f/gw8+8A8ePNjfo0cPf0VFheFfH0aQvPvuu/6dO3f6169f77/66qv9KSkp/s2bNxvyM2zq69OdeeaZalRQTUb7/NCeL7/8Um34L2rOnDnq9p49e9TjeG14jbrvv//en5aW5v/DH/6gfgfnzp3rt9ls/uXLl0f8nhn9Nb700kvq/xm8ttDfQYwe0d1xxx3+Dz/8UH2G+H9p9OjR/uzsbDVyxeivDyPyli5d6t++fbv6v/O2227zW61W9bNoxM+wqa9Pd91116kRQXUx0uc3efJkNSIU7Qn9eSsrKwueY9RrIYOaOvz973/3d+nSRV3IMYzws88+Cz529tlnq+GvoV577TV/z5491fkYWrps2bKwxzGU7S9/+Ys/JydH/VL+/Oc/92/bts2fKK+xa9eu6he35oYfWsAP+nnnnedv27at+iHG+ZMmTYrbBaOpr+/2228PnovP6IILLvBv2LDB0J9hU39Gv/32W/WZvffee7Wey2ifnz68t+amvybs8Rprfs2gQYPU+9G9e3c1TL8p75nRXyNuN3Q+IGBt3769en0dO3ZU93fs2JEQr+/hhx/2n3jiieqPidatW/tHjhzp/9///mfYz/BYfkYRgKampvr/+c9/1vmcRvr8pI7Xhi3098qo10JL4AUQERERJTTW1BAREZEpMKghIiIiU2BQQ0RERKbAoIaIiIhMgUENERERmQKDGiIiIjIFBjVERERkCgxqiIiIyBQY1BAREZEpMKghIiIiU2BQQ0RERKbAoIaIiIjEDP4/HEWqm+7xn1wAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Pour la Question 3\n", + "xopt = np.linalg.solve(A.T@A,A.T@b)\n", + "fopt = 0.5*xopt@((A.T@A)@xopt)-((A.T@b)@xopt)+b@b/2\n", + "\n", + "#Affichage première figure\n", + "plt.figure()\n", + "plt.semilogy(f_cd-fopt, label=\"Coord. Descent\")\n", + "plt.semilogy(f_gr-fopt, label=\"Meth.Gradient\")\n", + "plt.semilogy(f_ga-fopt, label=\"Meth.Gradient ACC\")\n", + "plt.legend()\n", + "plt.plot()\n", + "\n", + "\n", + "#Affichage deuxième figure\n", + "plt.figure()\n", + "plt.semilogy(t_cd, f_cd-fopt, label=\"Coord. Descent\")\n", + "plt.semilogy(t_gr, f_gr-fopt, label=\"Meth.Gradient\")\n", + "plt.semilogy(t_ga, f_ga-fopt, label=\"Meth.Gradient ACC\")\n", + "plt.legend()\n", + "plt.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": { + "id": "T9duI0AS2vKH" + }, + "outputs": [], + "source": [ + "def CDNNLS(A,b,x0,maxiter=10**4,maxtime=2):\n", + " t0 = time.time()\n", + "\n", + " t = np.zeros(maxiter)\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " x = x0.copy()\n", + "\n", + " # O(mr^2)\n", + " AtA = A.T@A\n", + " # O(mr)\n", + " Atb = A.T@b\n", + " # O(m)\n", + " btb = b@b / 2\n", + "\n", + " g = AtA@x-Atb\n", + "\n", + " fobj[0] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " k = 0\n", + " while k < maxiter-1 and t[k] < maxtime:\n", + " # On mets à jour le vecteur x entrée par entrée\n", + " for i in range(r):\n", + " xinew = max(0, x[i] - g[i] / AtA[i,i])\n", + " g = g - AtA[:,i]*x[i]+AtA[:,i]*xinew # O(r)\n", + " x[i] = xinew\n", + " fobj[k+1] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " t[k+1] = time.time() - t0\n", + " k += 1\n", + " return t[:k+2], fobj[:k+2], x" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": { + "id": "k1Y3ofiJ2zNc" + }, + "outputs": [], + "source": [ + "def GRNNLS(A,b,x0,maxiter=10**4,maxtime=2):\n", + " t0 = time.time()\n", + "\n", + " t = np.zeros(maxiter)\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " x = x0.copy()\n", + "\n", + " # O(mr^2)\n", + " AtA = A.T@A\n", + " # O(mr)\n", + " Atb = A.T@b\n", + " # O(m)\n", + " btb = b@b / 2\n", + "\n", + " g = AtA@x-Atb\n", + "\n", + " L = max(np.linalg.eigvals(AtA))\n", + "\n", + " alpha = 1/L\n", + "\n", + " fobj[0] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " k = 0\n", + " while k < maxiter-1 and t[k] < maxtime:\n", + " d = -g\n", + " x = np.maximum(0, x + alpha*d)\n", + " g = AtA@x - Atb\n", + " fobj[k+1] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " t[k+1] = time.time() - t0\n", + " k += 1\n", + " return t[:k+1], fobj[:k+1], x" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": { + "id": "acjPuR7x2z-7" + }, + "outputs": [], + "source": [ + "def GANNLS(A,b,x0,maxiter=10**4,maxtime=2):\n", + " t0 = time.time()\n", + "\n", + " t = np.zeros(maxiter)\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " x = x0.copy()\n", + "\n", + " # O(mr^2)\n", + " AtA = A.T@A\n", + " # O(mr)\n", + " Atb = A.T@b\n", + " # O(m)\n", + " btb = b@b / 2\n", + "\n", + " g = AtA@x-Atb\n", + "\n", + " L = max(np.linalg.eigvals(AtA))\n", + "\n", + " alpha = 1/L\n", + "\n", + " fobj[0] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " k = 0\n", + "\n", + " xprec = x.copy()\n", + " while k < maxiter-1 and t[k] < maxtime:\n", + " y = x + ((k-1)/(k+2))*(x-xprec)\n", + " xprec = x\n", + " \n", + " g = AtA@y - Atb\n", + " d = -g\n", + " x = np.maximum(0, y + alpha*d)\n", + "\n", + " fobj[k+1] = 0.5*x@(AtA@x) - (Atb@x) + btb # 0.5*|A*x-b|_2^2\n", + " t[k+1] = time.time() - t0\n", + " k += 1\n", + " return t[:k+1], fobj[:k+1], x" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": { + "id": "P_pEc_un23n3" + }, + "outputs": [], + "source": [ + "#Pour la Question 4\n", + "m, r = 10000, 1000\n", + "A = np.random.rand(m,r)\n", + "b = np.random.rand(m)\n", + "\n", + "x0 = np.ones(r)\n", + "maxiter, maxtime = 10**4, 2\n", + "t_cd, f_cd, x_cd = CDNNLS(A,b,x0,maxiter=maxiter,maxtime=maxtime)\n", + "t_gr, f_gr, x_gr = GRNNLS(A,b,x0,maxiter=maxiter,maxtime=maxtime)\n", + "t_ga, f_ga, x_ga = GANNLS(A,b,x0,maxiter=maxiter,maxtime=maxtime)" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "metadata": { + "id": "A7zXKfw32-C5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 213, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Pour la Question 4\n", + "xopt, fopt = scipy.optimize.nnls(A,b)\n", + "fopt = (fopt**2)/2\n", + "\n", + "#Affichage première figure\n", + "plt.figure()\n", + "plt.semilogy(f_cd-fopt, label=\"Coord. Descent\")\n", + "plt.semilogy(f_gr-fopt, label=\"Meth.Gradient\")\n", + "plt.semilogy(f_ga-fopt, label=\"Meth.Gradient ACC\")\n", + "plt.legend()\n", + "plt.plot()\n", + "\n", + "\n", + "#Affichage deuxième figure\n", + "plt.figure()\n", + "plt.semilogy(t_cd, f_cd-fopt, label=\"Coord. Descent\")\n", + "plt.semilogy(t_gr, f_gr-fopt, label=\"Meth.Gradient\")\n", + "plt.semilogy(t_ga, f_ga-fopt, label=\"Meth.Gradient ACC\")\n", + "plt.legend()\n", + "plt.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\\min_{H\\geq0, W\\geq0} ||X-WH||_F^2$$\n", + "Si on considère $H$ fixe -> convexe \\\n", + "Si on considère $W$ fixe-> convexe\n", + "\n", + "Pour l'algo on alterne entre les deux: \\\n", + "for i = maxiter \\\n", + "W <- Update(X,H) \\\n", + "H <- Update(X,H)\n", + "\n", + "$||X-WH||_F^2=||X^T-H^TW^T||_F^2$ \\\n", + "$H^* \\leftarrow UpdateH(X,W)$ \\\n", + "$W^* \\leftarrow UpdateH(X^T,W^T)^T$\n", + "\n", + "$||X-WH||_F^2 = ||x(:,1)-WH(:,1)||_2^2 + ||x(:,2)-WH(:,2)||_2^2 + \\ldots$\n", + "\n", + "Prenons un sous-problème: \\\n", + "$||x(:,2)-WH(:,2)||_2^2$ \\\n", + "$\\min_{x\\geq0} ||Ax-b||_2^2$\n", + "=> NNLS" + ] + }, + { + "cell_type": "code", + "execution_count": 224, + "metadata": { + "id": "6jAZ1LdT3FIC" + }, + "outputs": [], + "source": [ + "def initialisation(m,n,r):\n", + " W = np.random.random((m,r))\n", + " H = np.random.random((r,n))\n", + " return W, H" + ] + }, + { + "cell_type": "code", + "execution_count": 225, + "metadata": { + "id": "UM8Q2o_a3Q4L" + }, + "outputs": [], + "source": [ + "def NNLS(AtA,Atb,x,maxiter=10**2):\n", + " r = len(x)\n", + " g = AtA@x - Atb\n", + "\n", + " for iter in range(maxiter):\n", + " for i in range(r):\n", + " xinew = np.maximum(0, x[i] - g[i] / AtA[i,i])\n", + " g = g - AtA[:,i]*x[i]+AtA[:,i]*xinew # O(r)\n", + " x[i] = xinew\n", + "\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 230, + "metadata": { + "id": "3bnnXhgm3TEP" + }, + "outputs": [], + "source": [ + "def optimizeH(X,W,H):\n", + " # Pour X et W donnés,\n", + " # ce code renvoie la matrice H minimisant ||X-WH||_F^T avec H>=0\n", + " # en résolvant un NNLS pour chaque colonne de H\n", + " n = X.shape[1]\n", + " AtA = W.T@W # O(mr^2)\n", + " AtB = W.T@X # O(mrn) <- le + cher\n", + "\n", + " for j in range(n):\n", + " H[:,j] = NNLS(AtA, AtB[:,j], H[:,j])" + ] + }, + { + "cell_type": "code", + "execution_count": 236, + "metadata": { + "id": "9lAMyXi23cVA" + }, + "outputs": [], + "source": [ + "def alternatealgo_l2nmf(X,r,maxiter):\n", + " m, n = X.shape\n", + " W, H = initialisation(m,n,r)\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " for iter in range(maxiter):\n", + " optimizeH(X,W,H) # optimisation de H étant donnés X et W\n", + " optimizeH(X.T, H.T, W.T) # optimisation de W étant donnés X^T et W^T\n", + "\n", + " return W, H" + ] + }, + { + "cell_type": "code", + "execution_count": 237, + "metadata": { + "id": "Go3S1Mik3kSm" + }, + "outputs": [], + "source": [ + "#Pour la Question 5\n", + "X = np.array([[0 , 1 , 2 , 2 , 1 , 0],\n", + " [0 , 0 , 1 , 2 , 2 , 1],\n", + " [1 , 0 , 0 , 1 , 2 , 2],\n", + " [2 , 1 , 0 , 0 , 1 , 2],\n", + " [2 , 2 , 1 , 0 , 0 , 1],\n", + " [1 , 2 , 2 , 1 , 0 , 0]])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 238, + "metadata": { + "id": "Ruodf3-13-UT" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAEoCAYAAABy5QoYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Wms/vld1/9T2rIJWrBgQRBHxQKldGhnugNjV1mqxMYoJAbQIIm0ia1GqIJY7lRjIr1hFW+YcgMa0VisqExjS+lQuw/doAuKCy6oKFtZytb+87z+53H+r/kyrTPyh9/097s+yZVzznW+38/63rfP/T7wgQ984OLczu3czu3czu3czu0+1D7iWk/g3M7t3M7t3M7t3M7t2M4Cyrmd27md27md27nd59pZQDm3czu3czu3czu3+1w7Cyjndm7ndm7ndm7ndp9rZwHl3M7t3M7t3M7t3O5z7SygnNu5ndu5ndu5ndt9rp0FlHM7t3M7t3M7t3O7z7WzgHJu53Zu53Zu53Zu97l2FlDO7dzO7dzO7dzO7T7XzgLKuZ3buZ3buZ3bud3n2jUVUF70ohdd/P7f//svPvqjP/riMY95zMUb3/jGazmdczu3czu3czu3c7vRBZTv/u7vvnjuc5978S3f8i0XP/RDP3TxiEc84uLpT3/6xf/8n//zWk3p3M7t3M7t3M7t3O4j7X7X6rLALCa33nrrxd/9u3/39Pf73//+i0//9E+/ePazn33xjd/4jR/y3Z79b//tv118/Md//MX97ne/36YZn9u5ndu5ndu5ndtvpiVyvPe977341E/91IuP+IgPbSN5wMU1aL/yK79yceedd14873nPu/quiT7lKU+5eN3rXvcbnv/lX/7l00f7r//1v158zud8zm/bfM/t3M7t3M7t3M7t/7/2n//zf774tE/7tPuegPK//tf/uvj1X//1i9/ze37PXb7v73e/+92/4fkXvOAFF89//vN/w/ef93mfd/FRH/VRFx/5kR958Tt+x++4+Kmf+qmTIJOF5ZM+6ZMuPuETPuH0/9/5O3/nxU033XTxH//jf7x461vfehr/gQ984Om9X/iFX7j41V/91Ytf+7VfO83pYz7mYy7uf//7X32y0nzsx37s6ft+/8Vf/MXTs/Vb/x/3cR93Grv/991P//RPn1xW+u1nnwc84P/d6uaW1cdP49RH7xePU1/10xz7/lM+5VNO33/yJ3/yaS5JoK0ld9j73ve+U18///M/fxLyeqd+f+7nfu70XH8335/5mZ85ffeQhzzktO6ExP7u3fr8Xb/rd53Gao1ZslrXf/gP/+EkSDa/3qmv+rFXfRqzZ/vZeI394Ac/+PS/5tYY9dvce64+/vAf/sOn8TuHLGH//b//99M8Oru+r7VffVeffX7pl37p1E+f5mvPe7597nf70zi/+3f/7tNceq+9TKjt9571CS76X320pvawZ3qv/tuHf/fv/t3pf33XnIJR59SefdZnfdbFD//wD1/8+I//+Kmv+uz/rbu+WkPn3/u909war//V7BsYtrYHPehBp/HASv113j/7sz976g/89n6fnqtv5+I9v3eGxjf/PguXzanzDcbbHzBaA4uN+V/+y385/b95d2Z+t0dwpbHgR99ba+sPNpqb98yx5xrr1a9+9RUuWwf4bt7BWHsEDnqvc2oNzT8NrXnp1x51Pr3fsz/yIz9y2u/+bw7BQK3voyGN8dmf/dkXn/iJn3haezQmGhX+/cRP/MRprPaz55tbfTXfhTNGamdVa96f8RmfcfF7f+/vPcHqQx/60Cs8ag3h3jve8Y7TXv/v//2/T/vVvOu7udfsXXuDLvWBM81n8bpx2qv+13O985M/+ZNXeFFfrbEG51t/z/QOnOzZfaY9Rb/62AdrBZMa2Oz/9dnnVa961V1g2Z7Bmz/wB/7Aae4xtHCw9XTG7U+43Xn0s76ag/mYb/2msdeXM2nuYLR1Rj+i6f0Otxq/cTrrPs7DHnYurbf19X1MF66haY0H34KTYKn510f/C+bCu8YJN+DF/e9//6s9aC6tB060zuCzd6IHnWHPNO8+jROtRwOjH8EuvAY7zd05NV7v1WfN2UZzGrf1mgeYar/qq/779Cx+2rPgwF7C3//0n/7T6f3/U7smAsq9bVlailfR2oiYRxth4/q7jQ1gADdm0MYEdAEQYOlvGwkYA5Q2vu97LyAIcNpMDC0m0f9C9ghX3/Xp7/qMSb3nPe+5EjrMpb6X0TUHDDcmDcB6r0OMafd7fXqnvxGg3nnXu951Wn8AY18AAYGiFkA25wCZkNDvIWzrgzw9098Rgfr0v4C2/uqnOUQoaghia4/YAc7G6Bw6j+ZUvwSr5ufcer51hjiQKeTs/xFFgN17hJHGq9/2q+8ax+8JC+bb95CrvepMWk/72Bj2DUNp7N4LRvq+/oKphM0IF6bW8xhze9jam2/9dlYhbJ9gpjnUmgdBsneCEUy3jzMlnMRUCBz9bG8jjJhJ7zYuItwe1W973TzBW5/GXThvjs2nMdrz1tkc6rez+Pf//t+f3us7wj2ht5ZggIE0r/YU80Fwm48xmmdMuHeaA8G0sRqzdzE0hK85rgDX/+vXWSPk/d18aq07OGo+7W/n2BkReFo7BaK5tbcxvX72P/hVH8EMYafvEhZ6r73q98Zv3vUTs2kfCabM180vhpmA2/8JnP2//bX+mB4hq7V0tv3vla985eks2mNCf8/Ah74PrsGwfYSn9qvvKUn6aW393VopOT3Xu5S6+miMYMq49YkhYnSN7ZzRwta6gmX72f6t0EvJo0ygoYSdcCE46RzhcGfcXDvjlLa+a/6Uphg2IaN+7HXvdB79Hg6tgoU2tS8lbCT8/KE/9IdOfTRea01QTCgNp1tH+9SewIv2KVijJLau+mm9zb119Du6Ay7bO++1TntGgLj/MPfGak2dGZzubPA8vIWAaY2E7yP/sH4CFvzu/wQ4dIPwi363vuW9BE0CVd8RpL3TvPodDtfuSXjGNRFQAoYW8z/+x/+4y/f9HTIfG8n82Dr8AKy+br755tPhsWy0+QETze3HfuzHTs8GxAFeAH7bbbddfNu3fdtJkwoQAXX/T7rr4BqDRFq/AUXf12+/d1BJzQX5Bth33HHHlTUFU4sIAbb6D6E7qMZsniFkzyDqraOfNJT+7l2aaM+FMKwXEL69gwCN09wjoM03JGnfQ4b6aD25yd75zndeSeR9R0oPkWsxl5D+D/7BP3iyWP2Vv/JXTkSXtak5IEQBXu9+8Rd/8cXb3/72E9JluSLItN7WQ/AhOCUoNU7Epvn1XetCzHq2/W1cQmbn6H1I3R62bwjhox/96NO5szalsYbQiGPvtkdgrPPt/+175/OjP/qjV9a3WufMAkFTi2G1dtp8TO+JT3zixe23337xmte85rQPfd++IDKYPoRmaasfWldr6bzar+ZC24MHhEkWRHDRGdDIWGUIfoRGlq1+Dw/6m/WoebWWfjZeMFEzNwSnBv4QQfNqLa2Bdcr+EC6bWzC9Wmz4Rpvsf525MfvU7Jc96lnMOVhc5tn8+y54qH8CbsQWw27+CREELkrIwjR8WKbsd3sQbnVeNN/+B0bCMUyLsBTzCtbadwT/zW9+8+m7+g9W25cUBYpO+9P7zaX3+jvcbg+aj3ExHnOhoPVusN5Y4AF9wQTXgmsP7H37htnXF0EIrSDItH8yM1kvCRqN2bvNvU//76zDoeAQow8+mrs5NC80pDmstYs1qdacGi8Brz1hkaO9txfRGda35to7LJMpAc2nn55JCGrujRUsEWIoOiyl7Uvv1RfG3Xlg7o3N0geud96EB4JF/3/f+953F0tUfa1SgxbWWLd6Bj0PHzqH5t7v+IKzIyhQauAq4cJPwg88qa/WwlLfc+17/bGAs9w7n8Zc6949bddEQGmyj3rUo05awpd/+ZefvmuR/f2sZz3rHvdDWwuQEjL6CdkCOGZfUiVgDKE6SOamgI7AgJHU6gNixUSf/OQnn7KPAvKe6aBi3j3TuzHCxuz/AXEaeFr9X/trf+10gLXG6/eIDvN3SFBDMCJUCQTNtXnGjEM6plyMPgLWp+e/7/u+7zQ+wtM4zNnNqfmzQNBW0wgAfIjZJyEEs+lnfba+5twnIYh5s37qI+LSnNrD1pPVIaRo/BA9xHU2fU+zob0UMN0aWmPrSshbph5hSFiAAL0b/LT/BJKIGubSM31oV7XOor1q7JhS/fWevSKwdHYYbuM3f+4yVqXgJ+YQ3LCeNPcEmP7XnjR2e8QN2HutpfUyydYnQgGB4UL992yEvPlkLaOx1k+/12fr793migDS8BAYmiIGthoTKx3rgPUQMFpzc2GpaU79jzZYv/0kPLA6IEI081UyYlg0qlrraK6EtubSGbMe9B7LEfym5fU/pmbwte6EzoXwHXwQeHs2eGcqr++E9ZSMcLp9S2GqvzT71UB7tjkGo+FDe/C2t73tBI8JwRittbePjU+g7v8lCHBFhV/HgP9oD6te811rKQ22c2Nx7NMe9bz9Ibz5ULJYSxPe7WmNAEvoZUFznvohqPl73SgsXOuWq7G6sh4TlDCs1haeEXq5lX7f7/t9JzwLNnumNRA6gpf2sDF7p7NJmQj3snqwcmDi4TarSO+wpizTrD+WGoIf6yfLVbwG/HGRYPLrgiNI2L8VainTrCydB6tJ6+NqfuClVYxrx7opCsY9Mn5W53XLwWvCEUWbAMdN2RrNf60yxliXLLoQDnMxgf2jC8nvhKd70q6ZiyeXzVd91Vdd3HLLLSdN94UvfOEJIL7ma77mHvcRUNbaqIAbcjqANm+lVQdkczKh1iIOgDlAsencEQ45xsY/idikOfk9QO5dzMkcQ3JAgik5eEAk9oU2uGZzvj3IhAFjpH3XvBIEAHiENWLEKoK4Ijz9XLNwjbRvv/hY/Q1BuMH6m6XJnBG/fpKiMVREdAldfyeg0X5ZN1Zz6LnGXI0uBG+c5k4Is7e0R6bP5hYTaq49y6e667Q3/Z/25mwQGNpm52Fe/OngijVLf41LQzKeeYo/Wjcdor7wQZBmeu9v+04b7T0xKDTz5lcfYIQQYV/7vv7r21iEX3sd/HDxtReNYW/5xglFYAQeYbisJARblgR7QeuzJ+ISVmCh9a9VBbEW89L+88ETbMwDPCGqBD3P93vCRXCGsTQHcG6/4DVLA0GA1WnHIUytGRx9ahyaKVwHI2AH02ht3rPny+zsVf/j14ffwZb5OAcMmMVkY2QIX/YF3tGMVzlBU+CesxGvtBo0WtUYje3szB3jcy4J3hg/pWvx25j2oXVj9L2TYGNvCLf1Kf6rv9uL3uld8LvxiMZz9pQZlnPrEgN3FGKXQdtjfW6sjTMiBO1+PeASZuAfemNe28/OlYDSfFnduKAIGPo3b78f41TQi6Plw340TvtI2TLPtbSav/Xc03bNBJQ/9af+1EmC/et//a+ftJxcNJnFj4GzH6ql2SEmG4hDshTUug2jjBCnudjgmpgGhw1RuWoyw9KY+AHTliNOMSJMJU26Pgqc7JOgUF+ClRYR+VsBSePyp5Oq0zh7b01tTK6sBCFfgpDGdSHOBcBieLQd80Dg1pTPxChIleZLmGp+WU8IPLR2rgiElPZI40a0+FGzuPQOQVBcwQo2abHMtu1Pe+yMW98yAnsEYcVeIPyIv7WJNzLvFcTAEkLCRFtDqFkmapgops1tCBY7F4RzA1V3vxDL1o+ZbmyUOYlL6HffrQDe/MBWzR75nRCGuIqVQWB6l3UFjLQOFhNrpNVzE6yljEBAeGoP4BvCXX+EOM+3Fn+L1xJXQWgGu/t8fbdG2rbgTi4Sa+498G1/H/7wh1+Zq+3zWg7AIibcnAWBp51zUR0JvvWbIxwHzyukYLr1CX+be1ad+uYqYl0U94IZ9Hx9dpYsEjXvWTuB9hi/YK/RCPFqnRsNmrAOX+EAvBMIymq3AluNZQwDtwZB2M09PtDv9hROrPBIkCBoo6+t63M/93OvYIXiBYYIF6yZrFQYrLNeoRD82zMCjPivjfvbwPRVmPecCP0rHHoGzD7w8gzglb43jgS920aoEMgPbllxV3gmPKw1xR5soPJa1a2bZTIawe3ZXoONnQ8Fa+nnPWnXNEg2d869cekcW4y/FnAigAhOGxZiJwTxi7OyYKYJG5g3S0lWCNqCWBLIJ6COabnnQwQCCVM6oMCwuVtoYAkfJPq0Nj73jYLnbhLgm7XnqNEl/HCL9H77QQjIpQHpIxZ9nzCBQRsnM7Z3AA+fafPKNcQKkhC2jKXvBR0KmgKMGF9jdQadiUBg1h99IYgAm2BgjN5rr1oH8zzkoyUyw3fGzh5xycqVcCnYte8yGzPFN0bf1wefN0ItBoMwSPur0SwxJYGQCLT4EXApQ4QQ5NwSNJj0MQt7DJk7274X8FcD64h644qmZzlbuNqg1o0bQXCcI8G48xO4yyUpcFz2C20cU+771mnfCCwbYNc+IZLcj2KpfCemyfoJMJgdHFzzOUsKAX4zNwjVYJ+g0vkLzMSk+l1GE0Gc1i37rXc7k+DIvAlgLGxgmtDV3Bqrd8MJFt/GaR69S/lpvIc97GFX7q1cr+KLgm/wzxWGca51yRlxRRyZQ/MHo+gKyyea2ocywN3Dsta7wW6KHuUA3thvGXwEc/sgYwmDBNvoAYFyXVi5ZQmLXMrOpDkkJKLL9rxP+0Q4232JnuVKF0Minm2tKM5Fdk/f5wZk7W7/JV4cLaHgAmws7WRZp8AUX0fgRxsfcCmkgKP6u7sA08Xj/s81B9Y7o8bNUg0HKCGEIXu1IQCU1rWi4HFcnOh8ey8mB55bx7qDWFfvafuwyOL5YE2AnshxpuA2oNiJTYFETEmFNBREl3a2Ju2eyfcZs1lTuzRdgYjMegGyPlhHelfGEeuBYCX+w+YuINGB12L+gvnEKEgJJJAQogSVAiBuDESj4E1zW6Zx1BBXeNlAQZp6cRxHQto8+Ewhx6YbJiBwS9ECNJYE5mlMHpFojNaSRtVe6FfAKULYM4LIWDQgbD8Tzuy1ta2lSCyTdaxPl0XtaPZcLcdz5uZZZ0yjaI6dAe2HkAGWCcO1tQ62bgIigYLmQwu1/zTCzbSgIbfHG1gooNT+c3HUCBw7Tm3dagRB80KYNx1y4xGsg0IBN1egJcyxCDoHGjHt2by5RbhaZO8Z03wJa7TOnnVGUu3rJ6FfrBfcpsDYF4yrtcQA7A0tcgMOwSiijgHH+AUyUhLsfe8F0ylR0Y/mh3Yw2YORPhi6vRbYu1YO/YIvAugyuNrGoGAshKl1TdmL9k2dKi6ZFXJlMa31lMK3LmiMUnCzwProYMoYJs11BH9YoMwPDDV+9Bd+cv8szKWUEDQSGhuLQLEZoWA1OrTZmfXPOpyFmQCg2aeN0xE3Bi57JliorTX7fuOCgc97Ts50cRmOURC8Hy7l9kpIOVp4ln6tm2ktX2s9o4RyIxKs4gPR2fCHwou+LQ39sHDx/P/ROmiaAcDUmFBpi2u+x4hZRKQ3kqQRO1oKiwvC33gIGEK8kinCjKkzla7pDVORHkejwxBq/SSQMCuvBArAxVhsXAcrBWQzH8QHgMpuYI5tvQgql4C0TMi96cviFfopPXY1LQxlTcAEsEUw84IMJHxxMn2HmG7sxAoo6+uHaGuira2ZG7LQghBURLn11LgJ+w7Rwpztl9TTtQStGRXSE3LXD3ycqz1epHZe3Bp+X1fCml6PJtYawdhal6Eh9LRn5084OTKCNdEv8yOEmjcBbv3jztrfcGJNwwSq1dz2A/53bOfrjK0bAdU/IovpWiMTP8WmdiTWGwdAcNkARzi1QjYXJFrDrShW4WhKt19wclNG0R8Ky1oiWXeXXuxZ+/9xTStk21f7CB7tI3rmTFgdPLcxT3CcJXKFfLSOxYPl0ZmGZ4RAwo8+N87s7iwUO3cC6cb2gD/CJ6GP4LWxLhq4s2cLo7tWczpaOBaHl/5ZNyvqxmLdb9wqi2+Uqg1Cdu5LF1aAU1pD0gd8WcGmtQiCZ1VbwQR/Wfq28+LuUVoC7C6dokzfEAIKJkXLd1isH+pNSH+DPJ5pM9etwjVE6OhZTBfDWhOeYNQVSBAOQLFMfX37xiQUSE3kp64RajBFDJk/mFBkfTSnlXDFNTRHggNgYcaVUUMTo+GzdjDLCpgDnOYE8RWBEqgnY4HGu1o8jRTTQ5zW7FhDQMUp1MS5YASQZy0c1riEd4MjrWWZLtM14pl2xPRLyCSsEF65B5h8V1heIQWR1c8yX8wK8dHP0ZKzQaRgw3n6/44B5sBrbTOFVojRwOq6VHYuR2vJCpNLXBGvo7BkfhitZ5dJrkVkNbwV+LyzsKgRMMGTNWz/cMQcajJQZCGstigVWp0Ve0rY2LiUXS8362qjGxfhGe4plhOZTawFm7rszMXJgPsVdPRr38DMfreM6kPt62rOm40Fp9fyszhs79Gp1cbB51EwJjRHkzoHyhbYW5eHM4Y/aJZ9Yk2o/xXaKJo1afcY8u7XWpFYQMzV2iRiiMtaYWmFFDCn34XL5pKCSUFGjz5wue/Od4V3AhOhCCwSxFeR8V5wGL2ikK1lzVx6Blyt8CPuBe1b3IXPPROeZEnZEgP2zNpZd657AYX7g//a4mkv+fX6LkaTKW+tHCFD5iibvwFdECxg2b6X0GDExWnUMPEtSNZ3jct6s6bv5s40WOOuILg48AhZsQ9cECrmChQDELJVzE1cBz8u9wGJv78xYAXA1IeRO996BObFjMVBICIIOcm/1npZtgiH/Z/rJBNpzyiKJ3CNGw2w2yPCixoOCs3VB4FBbZr6Ekxcf2klPa/CsBTLxlhNH4OFdJiF1FQCVqbLGEf96J/liMWu51TrRRxogrTCtXQs812NaZmKYEGEGpFmFUI4EGrEhABzd5qYMddNJdZiidy6mxBiBBHsGmcFmG2EMWP3HkF8mZQGthBcwt8yy6Mg6nfWxaNgskwbA8BgMB/CvTRnxf5KXc1FqoaSbBHwvgG+BGZ0pUZzpK3bY3MJbhujmimEfmmoYNBaMBTrt+e05xoYYH1dTXpN7n1Yi9aN44NmOCOxIBjeWk5qLDzH2AW4tm4Fguta15YRc4OJW8vVjq4V01I1avEYrTW8by1i1QhjrMDh5mYiYc7r8uYW70yjU8VVhO/ol/4lRFhfQg6aqjgkpYZwI+MQLmwGU8/Ixls8vv/luxSn6L/CavssSwUeRHGnKHHbBlPFTOXmEfeEtlPM8BWu8NbY+rgtuUI3Tk8MXO+1T+FKbv3GaL4bP1h/zu26F1BqHZ68e9Iun7LCUwhRgJ2vTyBlgKbsvqA8pbL50BAMiMTXxpdfvn2HWTBen4JsmTR7Jr8fLQCTWfMuDY1PudZ3jaHqZvMt9sPlSsXXCFqLSbYubZmN9E2xDBvo1yegQUgJY+0JywlBpe8av+8VJkLQEcYV7CBMP5OkCQjmW2DaloYvUJf0rUAdoqkY02pahDLCTXNKGE2AaB79r71iBQlRShFvrNbCxVOfqt0SHAU6YpJikwiUtKjmGQHbINLtS9DlCrQYKOaC4WyGCDhRSG3dkohG37cODGUFBLEcsrgIpzWCOJN253KMuQmWBJwiRLQ5LpAIeH0p7rZMT2wSHLImcClmgbWO0L9WohXkCGTMyxv71D70WcWBkN/77dEyY9ZEmrIgSy4eVpLwS7kBAnzvxCTD760xU5/tR23XgKERTtfiSQBfTTi6RHtWcDAYUDCMMO0c1fLwnXgzuMwysNaN5hGOYK7c3NbR7zLorKd3w/3+H2PjOobnYJ67lKJECwfn4ThXuri/FRp7nstdfF37HoxGK+pXlVv7zOpBMOh86l85fHBaa24qaWOq4U/vpwCqqisQFh8QvE6wLlC33/faAPBLKQ2H4DWYFVsjsFTJAwJSdL6EiWhie9XaPmZillh84eFmJFKmuf+53iRbEESV6Kfs9px4QZafTX0nyO+1EZ0bQa/fKZGdVb+rJo5/rILmveV117WAQiplNm3zSbOAOOQJwKvoGZNSSbRNg6wADFGsOXTBaQi5tFnMUooZDVkdEASqvzd4k7BiLNp57SiVQ0CHS7o9uhMCMkCkbwLCxjL46UNw8KwiY+1pTD2EPSIFwMW4j4W6uLw2lkLtgD4h4pYq3zRw/SJ+BJ3V0hBNiFE/zlQQ3GZoERS44xJcWJfq19oJJOsGWL82AtPzrQGhDdH7m/YlsBMTBDOYIbfeup5YIwh9TLDruiRo1H/EDQMAD9av3ggNaffOfq7p/Jh6SDjpbwyQpcZebSaYmC04B05X2FI5mGbO1GtfamuqXpM+E7E90v+mgy78CXylzdUwQ2cB91TodcbiqY7nH2MOdltv2XSynbju1rS/KecECUx3LQe7tmBJBdK+j5FwLW/WhPOz39Kk61+shp/w6Bg0vnVRuHgxfVlmXN/mmdYtU8YZODv3Nq0gtO6IxmJRtZbmT0il+C2TrymSZ5/Bt2zM+kejWAL0pUJt7xLAZEBRypZpU0jAQn8TEpTRXyukkgtcfxvgvK5G+4xWOzP4iXbVmi8BYZMsPuZS4HaW5gC+NoasZ+Cs0AD8Zd3IW5F63Uhr0fcOnDYmHtbflChuNooFy9RRcYFbaON1L6Csr3o1CYdJY00qrWoi7R+gpLUEsOvDXxM4gFtrR3+Lq3C4IsBDOoxzEXg1K4B8DMBCjAgBzZVGVQsQGiMA23LPK2Ah4gSHDaJbLdJnL/6rn+YqWl6dFRVdXYqmr3WLAUoEhvC2hBBih/iNody5GgeIi73e1D9rWzP+xs1gxGsdsq+Ieg2hWV+4vaAhERzsK7Mkptq7jd06WmPEPI2XYEx4dW6QHrNMuNi0TM9gIhsAeEz5s58IFoZGCF0BjSC0cLZjrAbPgnD0XW9Gkf2jubEcHTNPnJ89XNw8uhrsDXhZhroCi7MEqxtYenx+XT/M7BiEPUAs784dtAKzfhDtFf69Q9Db+CgCLxctodE7GLV1d2aE9mXSG49Bg7YPLE1iGMAfgQGeWoezJmCusCQbQzVXbmHauQy6lBfKEoVsmST4Cq/BkPWxGnnHGOjoZg32TALAxpV4nqAfDTEH+yUQF66h9fjC0gyMNt5A4FNskuDp3hs0AL6yXsHDYwzLCrdH6x1GTukBVwQV+yW+5gETpweuVqBYvGD9dSau7dhgVa7Vo2V36Se85MI/ZhY6g/oIXjaZo/7sy2bZ2Yuljde9gLIEnrmy38UlkHDbkA5rNcH+n0mwnwkpG0CKYSFY/P02VkW+DlAcSi6GpHlmedaVLqlLAwFofLgOD5BaD+10b9Ztfkrdd8gJKrRo97GstoVoMvMtMecP7yfTdd/TNFzS13dMjFkHWpuqqAQn80FsAfumzUrFVu49Zv7a1772tO8IRvuzQZI0JQIKYU9A2pq6+VjNIYLTmYmZiagmTPR/FX0RCJqPcTA0PmKB1MyWtfqMeHbmraE11r9YFBYUMAQeaXmZn+uPlWgJDrN7Y9bMIcIr5mbjENanvn9zB4lVWvM7mNvMKEHB6kUQFsErYY5VSz0ZjGotHvZJMKXxdpx1c3CtmjcLT2e6gaSbLdIczdXfygwYl5tBZUvM1nmvULjWFVWgN5hPvaXeqTaJst5coMGDIHxzJZRSWNaNF4y640vtos/8zM+8goXiwJqHPep3wZ3rrpWy3lzA+K6pvli61gXb3vWJhmzQfzjq2o4aC2Mw2xyjcWgGmMbcwGW/i1VQ94Urj8DWGD3PvQCfWUbVelklK/gXKA+ner79Y6Xg8nXdAbgFq50butI8KQqETtk1rDt951zXKsiCinmzzlJwVpgQ64Kxr1VxLYOCezeL8v1j7ea6g2c71tLLVULgN8ViXZxwRB2W9SKwgqMt686nNKwyUF8rXNunVW5yHbKqwOnrXkBZ86ogxhA/wiwnXa49ZKcNdAgxyxCOT7D/IboC2QAK5q48Mt9r4wqoFOhE03CFdq6lXA5MdwAGEkBegBixEXsCWWMKrujuPQSMH7jAJA3BgPwbla0AVcgpFoe1KSAyBnOdiraN1/8SJviQj0Ii/zTrjNiNmrtlmmvn1Nz4lKXp0roWKdekvIy8tSvKZZyIGDffG9/4xitXWc+0fxuQCRllbRE+wRSinhDLnUBYbP1ia5qXwGLE00WLzPKQnOmzPgQWr7XEGIKBBXz3neBrApZzXm2tfapwYPty5513XjFoBAuM0aQwEJaCLfO+7i1/O4cnPOEJF//23/7bk+ujeW1MlfOR0caNQPgCkyydazpet574AH2v1RExh08EfumLTN0b40A4QGj7WwVmeOFeHPvrokH3SFmjYnSYnmcJX41RX8FIeMNUTysNPjCb5h08BJ/2nmJR3xgfZYiSpUZSSkPrj8YoLEfg4v6x7ywMcG7ToY+WCgyx56vD0pyiD8XnsOAScglPBGrKlwDfjbmR8eZsa/CccC/xYCuaEmaMc7QCcusQZPu0X+KVVMNF81ZZNIagz85js99WILT2xXfXdLBoEoA2TgfcLRyvBYXlm1Wn/z3oQQ+6ck+jVy6Mdasya44YOTgrrRhtIVSuxcf9a+gXPHE7vTpAe5uxhpaJZcEv1pqNV60lnxB4QwgozG+CdUJ80fdiM1TYFKzDbLbmRISHeZwUvmZvB51pMSImsllcwNZY6MABJcm2Z2kSgISpk9kNkXRJIMnWhXM0W9HctAzVJNVCQdDXlIgx0PzdGOp/zYs2V7Oe5kKzgYCCD42zTKw++YVXM9kgRBHgNedgvUynEBZirImRwMWPS3OQrtdaOqOaiH4atXopR58+AdScm0cCrHs3lsG6u4PFjpaCALGwOVdCVvsbsS/Q0ho3PoD1iYVrM3UgOU14Ccb6dgu0i5FUORdTxJBrTLuYsjFrrI6bNrwCqDE3AFjKpH1c6xYCtdZDAYPrpjnGHHmHML9r2GyWZcDr8lzzNy3T/qwgxeVrTMLAjgN2N5bH3TgId+/I9Nh4DszDbbKC18Eyax0L77o5uUYJrVw9BPhgv77FQvVRbtyH+w8dEy9HeGFJO84HjKEl7YPAc5k18IRmftSoa60V/oAjNG1jUjBtzA0ur/BtzgJL7dW67Ai1+ueaIQBQTDH65tl3KYPieXonvN8SFoQT6xbDZv8I0YSyhAf0kfCw+No7aiyx/nNHgU8WqgddFh5E+1SFjYYcXX72CO74Ds4fren2vPmvQFalXG7rjXlEowj1S5/g4Lp1nK3nwMAN4+JBcMRlkI6ZsATxIaQkYMQDcTlq7qwoHQ6Ginlm3disD9YTB2RsEiXJdX3lGCFNCaDxRYq2hgRM4xtbwwSOUJDat0YBgrQmepkPhCuMd7UuyHQM6EMI6g+SbjAoQsfNsr5+fmjVG2sbWIUINDcpa+tGWssHUzHXjzNkFdjqmBDG/CPsGxS72v/G89BmmIsRL+tfoY/msb7t+qalEuDaZ8KdNPItM26eCzvLQNYFaW1gt9Y8YiSyCBCqDWK0D2Bk44cw2HWVrECPuez/MHJWKP0jhBjwxkut5cM8rd04iN3Om2l4LSvO/ihwbRyHvVl4qlEc4D64J2TVju4C8zmaqb3re8IJ/N+qrqx+3mn8cIaCs4KzfeBusnbKiXo80uk348n4NP0VEpy3MzLGxj1s/AQFhvVQ8CWLgTiWGhoEP1lRV1gCsxs7Ya6e612BsluSYOsfUWTQDsrHutGdOZxmmaFgyEwB/+uSJBjC6foRRExIZ71o7tG2LOiE9rX+oq/2YC3Cntk4rPfPtRuYfpb4vnvTm950F6EEzMOrrZnifMHw0qpjrFe/P/ShDz09U9wmJdY+9lOQrbnBW2dhrzfOiHtnFZPrXkDh0yOgQGq1Q5ICaRgxPb7fTdFr45jTacKQqo2VvsWKwAdr0zc6f5FqffOIBYIrtoUFyDO9J/vC9xAYgPWczIA115mnG4wx4/X7QcINfqovQkt9hHzNjcawaaiQxiVkGBO3AcJGWEQIBMLyeYZkzNdrBSKUNQ+l6TEOKX0aKw1CL9XUGBFt+9daOnuXibEG9TyEgoDG6f/gBRMJIe0JP37z47c3FwSctYX5vrVJ42TR4SpYwmQvNniTIMji1hojhrRJc2SmVo9B5hFCv2fLR02z4u7j1sjlSUPSWJHgVWuVJr8xFva1ObmHBWGURupOli3QhZEi+Ag3vNxAVTC3NTUIhfrF8Oyh/p2xQEJ7RwARk4TQEsgoNiwNLGn2ifVi74rp9z7W2XvtESsIor04DdZ7Jytg1guCDTxuHuIW9kZeY+ydQKxBK6RYP6tYfSyzI6gdXYIE9RqrJItDbQMw4V/z7f3OvfnufVvcJPVFEOr75p/rqr06zo/wgQbY474PbtVjIQiJnZOC3RiVCVAcz3i1dY2jPxtIm5Uy3Os5590666uzynppXX6at3ioDch3Rp49ukd+7RLe+j5Xfvv3Pd/zPVfKuUagMZa1rwWFMLQWnVVAGvNRj3rU6cyKFew5cZxwD/2JRrDo1EdwgD+2lwR7AhbF64aJQWHyRDAFPdGe5IDTfBwgSbfDRlRrabchxAagAfoVgmSfMLEqjoOAYfaYEqAR3MeVQ2vQzyJ88wDY/S+GvX6+vWtHzQpEo3FVo+SykXffM43H1aEQUnNv/+wdM+PGqPS+gneEEbEjBDzmyJ5jEeIigQhJ5ggLYixIk/UkIpAQIi35mBHQ/zBcF/nlHzcXF/8RRglmBKW+D7kU0GLmF9zb342TMEW4EdwmNgdSb/BbfSSQiLlpPrl1itfAaBBLzIW1hCtAYPbWhaAF0Zgirlt1GAzX6vOWW265uuStOREqEVyCggJ59tXZbgolmFpteisOwynWl40B0c9qcAKWxWb4fjXMtTbSzlmXwAwhYVOtKSDNu3OgSWqepfG136ykjZuFtLgjbjruNkx/4wwoKo95zGNOY7HSIuSbZaaYIHfwWlsi9H1YpHpHCYD2KIYbbVoXFNyP0apdBJZZfqVab/D9Cmxr0XKGBDOwXOu5YCrYRefgNE2a4kVwtZ+0aIIzIQbOsAI0z5hb71a0rvW1r1kjohfwXVA8tz1lDV6Ha32iH2Ar/EUr+omRCjznsuhn3ys8pv6Miyc3k28zGMWiFehcfNZ3f/d3XwnQXPMb43NMxsDDalzF9uUBY8HuE95XW6v1Re8IAI3DIraxX0d3ituG9yLUrZlTq+94Qa6e6r4Q9OAAd2bPNIe13qAjtbWEEsTR2htCQGGVaHPFd3BXxFiYA7d6aA1j3uwPjFvsSK2+Am5A3Ke/A2yFuRBbSClQVrqia9hp+Sw5JElBnZgRYQTx5HdE2AgozTdA3fgVAZysHDRyRIfFJ8QDnAkACJqAJ9aWCCKhQQZN/7N+mk//3z2rIX4Q2tjiQWpcO7QGyFhb//IGktYIZFJdudAEMdOANqq9tufUJ0ImKA3iyrYhEBCezK3fZXWY2zElepF5hbn67Swx041TMafm2FyY7sWE0JQ2QJTVh5XBvve/iMsy+s5XUTOMyPjLrDCRJUq7LkJzTLGA6Xe961130QoFuK7mivkxbTMNb2yKsyV0GAsMNQeCjjguheTMdQkit+hqsdyWGAbLEstGP8MpVqB+KuxFUOkdrgTm7rJcjLXpt/AIvSGINteYQHB0LFq1CgcG1V6xmKz1hEDg0lDPLT6BYfhsnRIDKASsGXcXw1NrHHjfu1sEjoa81uKNR5FhtTEIPhuzlPAfPUKf+l9rq2qsO2IEkBPK1pXMhcyCTJCQ1LAKnizO+ARclBnmjAhEApHt455rfW9QdUpvZ5v13v5RQuAQ99FahOHBWgFr5rs4GIx+xVd8xcXf/tt/+y5xgCw6lL9geC2xlB1wQeDe2Cxw9chHPvK0R41hP2rw0u9rdUSzuU19KBb27IYRUBBnGRE2bE10G0exvlgBeHzjEET9EYflsKXcQnBuof6HQHAJMQnTPNZUzPy7wXqsLhAlbQyTgqRbGpyEysyIOGAMAsIAJjcLbaa5CoilGSA8K9Rw4cRUEb81VYuMby82ruMYpIfh1azbHpkfQZEwwepxrLUAWQE+gWgDjkns/kbozYUWo4gejdd79g3iQn5m+JqzE8NTQ+g3loFgTIBrr9JExUo509rGm2ywGUIJtq3BHGobSNwzEV6BwIQWGU0bBAvOazITWPxYKVgh4dwyLPhjfwk+1iT+Zvd8s1E2yE+Dyxvvs5kjG8C7cRK0ex8MChGvwZWNl1kC3fxcYQAmxGWsW7cmkJVStL54mrCA/Y2zYlnaQHPKU31xfYF5wrYYCsxuLY8ES9YNTAvNI+Bb/wrFuyerrW8jPLMWc82yIjk3uAge0UtWI8qGseAQWhv9zYoV/KIfjRtNXKvWWoXAmXnAXfEhsmxWmVCEzTnAQynGC4/rgrQ2fEEmJ/d0SmJWlH/1r/7VVRVac7Wnq1BorBBwhzWsdhTmEuAe+9jHXt0cvNbGjdXz/Lp4dr0ESvDiLPqkWCekfPZnf/apVAZ4QmMWlghPRyvTESbA+g0Tg2IjaA0dHN82RN6AIJpYmxjQB1xyzgWVrqS7DMl3tI5Nddu8dZX1luAdrTgCJgGVQCwEPI2MbxhC1tZ/516e9R+q8yGGwdhMvYBGHEgSNo2e8LIuAH5Z940sk4Gkq2VtIG0NcSLIQQYAuvUwVkuobayIMTB6hArz5cbYLI4agk3jWWSp0fYIQQItmV25EmjPxhQ46R37svEiELIxN94mBtX5pr0RWmT0YMDHDIUay8FaC45ZKb0vQ8v+714sc6IhYhYsF8zQx+DWDZrMpA2WVqAgdHjfWYoTs751ZRy1SO8hhhvsrlm7sbnjtoz59rOZHc6fxW2ftQ+5VPaiyK3x4OZZ+wXuvb+aJpw1JgutPWIJ8xxYC7ejM1sLaLPVMO6N8yBA0aK5GDYYc13OrFoYjv0/ngUXiZipDXQlDB2DPsVG3N04fjr33UOxC+Dd+dai63CZW5XFmVKy9Zk8t/GAeAWrRPuVxcZN7TXWUrRs8WvjNHqfCxxe2PcnP/nJpzR/OGl/rNFncQuthH9owq9f0mTClsyxlJwsSyxju8/o+bpNNzh394iACYa5KXu+Mb7gC77gFG5AyUBfnbV1rGC1SQrOHO+1J/e03e8D90acuY+0gDhJ92u+5mtOzLNPZriIClfPRjJz36xmKAUO83JPRZ+AtufrM8Sw8XzFTJZLdCHzSpXMsQAdQ1Q6WxaOi5QEd/ZTeuwGAmIYmOAGyNJm1IFRtp6QIt5BrRMBawCb5eVYY4NVaGNf1ABpn8St6LPf2zfaljobtc26YL1B8OozROjjXoclZplNCWiIVv139q2JyXQFQ0IfU36peSpU0ir2EjGBtpBaTYQQlUBIQCGMqCDsvfYy827p6PnNBYzWnOVqPAhxfTQGN1TPKNjmokQEqp9KcZsrvLCeFQ437mDjTGhpiKQG7lZjWsvaO9/5zrvEc8ED56lyMAEAw9q+4CGB6cjw22MZSe2/4ExCCIazQu9qqRt7sNa3YCC/eUJcNWPSFFdJYYmB06yI1ke4leGlVLq9ViMlOtI4aZ9wcPdqXVM1Lo3axs1gLPZm97A9qB6Nmk8UoVUkVmO2P0ur0C9CJXq5MT/dNwZf62NhikUPDVlBZIO89Y8+rpukn295y1vuYokjNPh7cfMo7OwebQwdyxN3ebEsLEfiNMx9s4uO+LBM39mgjxSRvRaiGJrcMNZwd/cPraW2n+j33m30MZeutPC/eLK3vvWtV3BWv8Fuyg7apGjdUSA1DqvzxuVFo+JH/RTgmvLKiieWzzmIV7IPlG1KXu+LHRQTIz4Lv4h2vfKVrzytS+2b69KCAgDbkDY9gqTWhsucAB0NEpElAdNKjulg/XRHA4QivfIRu/FS1DgCRhBR0yRi5V1ISIur/w6OBE6Tqv8Apb4z5fFJr2bdejtwlU1riwDmI9W6JlBU2vIiPcKDgK2VxL6Iykdcac80k84hQoAZxuBbA6YlEJXg1jsBbGtBLEM0+wcB3FWxgpb3YzqIJ6ZYYxL3M7hgvqdx9a66NhAXk62vzi4EZt5X/Ej8i6DM3u93sT/GaDxFtHo+4a1zjelyGwlYBmsEZ+Z3wX2CwNvviOBmjxDAXKzGDE6ABdO0WpoO0zRrC0LjzJdw352ViGXOO1yIsmhY2+AfM/sGkfY+q+QKbWI6wqFgRAAzfNwicYgvOO879S1q+u0sO6vm8P3f//1X8Q6dUwJLe1w/nVdMwbssBoizrI3HP/7xF294wxtOsTi9Q5CD7+BgrYRw5uiKWtcLJceeOoutXWKfCMZwdwWYFUbQG2OyBoCPGrxeIYAOa84rzIBbAiM4WmvVuuGW+aMfPgtfa8GzP7VdDzgklEqZNw9jYNhreSIY2l8WWozcPCluNXC3czSGn30X3LHa9ZGWbD8FFa9rrXdlP0YL6+PBl4pXLfgX79GzeAO8AXeLpxreouqxytji3Cg+jZuQEv2uz+C7/3fLdmM1RkGz4RBYkWXWGOhnwcKPfvSjL374h3/4JFSVEm3NzcH796R9WAsobQhg6fcIisC/NrRD3ADTNc1FTFw7jWgIGuIaWtM1hI9Y9lyHvDc0sqqIMYnQddiNEZMDkKTS9b0fM4Aao3nJUOldWRvMmzHsGFJj9FF9UHbE+rVJ0rIAelYVUGl/NHhCDWQMYWQtIboKHq2P1P6xBC0xotUvYeKP34u6+EhZCxB6jZVG8aLOAPEWd0QIhLDWXJNODWYIW4gcwaP+7cfe9yFgdImU+cvycUbrd99bf81NufR+bx0Yk6BGmplnMPVafXSGSu1zYxBuCbJbhIzgvIGEzNwYFsF6byKmARJq1IZgmdjAN9YMN4kT4hDntVw6F7Apzsv5u9EXkVRJuXeDd1dKYChwj7ujs0uIe9vb3nYiytwTvQe3gn2WyPrp+Z5lxeu56EcKgqqeqm/C+TTYxXUuXnVuWEnXLI7eeM6aNzaO8L1BkoqUsYhuXZ6a5xYn18rlHAgZ627w/DFIGhO1z86QaX/dLayhLJg1OMm0D86PgbnrilhFct9Zq575WDPliBC18VRgbwWLxTFuDv87ftY9zSqw+7pptBIe2kdpuD2b4iAOhmtqA2GjAcGj8gHB/4/+6I9eWcMaNz7CusSy5wb4xqHA7PmwoKFD/d1YPpQslvetoC4uszUVEN+7/d2zzaP1NdeSDVof+tq73VgfjUpwb948AvVNKLruBRSZFx1Eh+UCqQ6jA0uSi+hEYGSasLTE3Ltbgsm/zUurRexJ1ceg282awAhYBzB3AkCErsPp79qm2m3AFUkUUFkDRF3LAYbfWjMhB5Q0d+mSANhcadRb6lj6bxp9+yN9bYUbSBGyqECLoZHKEd5a/wvJAuYaidk8alwnW7uA31dzHhvbwcIjG0DBPVqRwD3aFGuAgOTWT9ASyEtTRXzMrTUQOGnnBNWNL7FP/NDNl3sG01irBSKWNhT8LVPvbEN2wp1x+JLBEIGF+4gQDaYwqHUvbtorIYOAQoCoXwLxFhlboZcbwnnqkyC0BF9QaD+Zngm3zgGjXmKLcAffzMwbnBmBhFdbm4PwES6w3N16662n24fDk/ARg3IJXERUC6bFlqh/U58JRhWuigh3RmmDvS+wvPELJIwQEwoxGfu5GS8rFINb1qYtfMXKswIjxmaf3J+1DJ1G7sy5MrgF1s23FVLNz36je8dsE2e2cMAFQ7DZ+CJKApdG4zvLFcgJIqtcwIHFocVFtBId4RZmIVZhF73yrvlvjNfROsQK0+9S/+3XxhYSwjH+4Mx9OrXgJ7jKhcUt2zpyWRPSgumsFgWlRoP7/NAP/dDJAtFeOK8U8NbDbRUeNOdgsz4TkuNnFMKeDfe4kBrn8z//86+stMXJrHVNnFO8gEWy/VdSgSDGzaOWzGd91med8BEvqM/WHA6i9ZQPcZz31IryYS2gtFExWEW5OnCEO2CKOCGabWJNvYx8tx1S78WM2ug+NKQOxx05CQHiOtps6Y2N524ZGkr9RVxjQL3T34ooMfHL+tnCQe9+97uvan7I2mH1qT/WjT7No+chixoqEAWhCJiKQ6nPxmNNYglpjhgGN1mII1g0hEoD7afc94SZBDlmV/EOtKDmm88aA+p/WbNI5RDCXSXcGfXfPrbXAp5pxiE5zdZ1682lffLpXXEX7XfzaJ8gF62+ebSe9i/tl99fBH57kubSOFwvPRfDEYSN2PGL15+11S+rE+uPegp9uIRoY80zRsm6h/kxsWJYEaf+5lZpPSG5gGip7eqaiLshjBHcMCNCSFZGhLt5J4yyjPWd6yPELG0gon4IqrW1HGAye00DBYEFoe8VupMR1n6FrwLr+r6z/7zP+7wrK2dzCpc6m5SQikvlsmFeb37BacJD77797W8/wV3rjQHIWFMTCG63ZiZ5eFIcSWcS3ncO7ZFCgjGe5toaoimtLQGdlYiQ3N+EALjC/do4sqIoXOEHFxXLXn/3ka7e+jFxdGTTOZ0hIYU5vmbfxQoQFINlVitCOqFnizfCfYK9ujjwjyZPaBQcDKfFwnErE2DXYiRInquMAsbF3jtcFrL24JRzdPUFYYPgDUacS3tu7gRFAl17QmBkealx+zYGQaizBze91zPVcxHX1D53BsFtCnT9Rt+dgSy/2k/+5E9eCeet5+abb77iTQSg5t3zT3rSky7+wT/4ByfYbMz2t+cbJ0U82GxeCTONG19IAIrerQu++LKFw55/1atedYLrXD0J6+JiOp8EqfapfppX+MUV1Bg91/zjrQRtc7/uBZQWnOYSkCaBBhQR+zax3wPMiET/axMDdianNjEADkASWKr+10EHYMzzHWrETcxITLx3InrMzQECQYR7p8NhUhbwmi8uYuZiPwBdC0BDuPrpQBFd1g5+OybxgCFATJjgl4xwdkEeQton4GLubh4BfADVftXnxjE0TvsEmVtbRF3GBstKgCpQWABV84zY9WkPWk9rCyiLAm+ushWaa325bygk0Bctqb0O0BG11shKwdzfOmI0bsnsPNQkYIlCuBqPVoCYMlluuiRXjuJX4gZkz9C6BE3WmDwJnX0fwrNQbPBx4zXnLfUOjtvv+qBx1Gf72XOYd+vmYum7CB9TvJgkhANj2ywu+7saqjRVgi8LUK2+CVkyLFiBaNJb0I2gtPFcNWZocULhg6w6FsH+R7Ouf0US6z9YCD+DxWA2QcX5hMvBcnAQwW0ewVLvve51rzvBIkETPtS4KlTi7feEy4QNrs/2KrxyJ0nrT/jelPzeqf/W97jHPe7KxE373AKBrGgYDGbMvULjpckv3PU7Bomhy/Qj7HJVsOZuZg0XI4bXmDHQnoObNfPFuO0zAZpFdGN/ZFkRljovt5eznqC/ShWwrLCSrQa/VZnXMt0+E2jUbFrLCoECzdiiklyYBPPd+6PAKCSgedk/7hKueK4aMWnO0PjxkvA3eAne+xDww9Pgxp5Gj+MJnTWlsX5uuummK2FRSjSrmX0P/l//+tef9rIYKnWhmku8rjHRqObAdRqu967SFCzvD3/4w69SrcHVU5/61KtEAYKpixlVrFbbq33qf695zWtOa6i/+lUmAM+7ZgLKC17wgouXvvSlpwMICQsi+1t/62+dhAbttttuu3j1q199l/e+7uu+7uLbv/3b79VYtOM2UzEcpkypUjT5nhVBHJB0WDJ1+pm013MRNNpG76sIWmM6RiAaU92UxsNU+MeZxAIoQbXSGGUYBFAJJDJ4aMG0gD6QSvVYV3Xz4XJptRZagDgYN8kmEBAgmNoFN0FyUdaN3X61Vy61klKY8NXvzaXWvFdroomoKYBpCbhFgBCunms/6htx3pS1Wv0wHfNjVimVZcb3rAUrSLDi0FK5RLg1+OK5PzZYUwZTja8ZEa0xz6qb0zOdwTErQ/G/1tGer0+daZu1RNCsObGE+BtBZ63jZuz31se3uym0XAncY84BUbcXLB2b8uonC5AL2ZyHORCU/J8ma9/8NAaNt3dYIzaovd8V4OuTYJeAIZW+51xEx5UYvDYO1yRCriAfU7dxMZ2F1wjxZvYRkmpcWb0nHVacUufenGSg1dCA2sZxiF04xpdsPArrHMYvQBgs+j8XJlcJS55x4AGBkKmdhZh7SL/mvOnEtHtwZXzMX4CkeJh1V0k5xZxoz6yKGPoKPWBhM4xYV+AlXJEl2D6BMfil3s7Gp7FiOZ8NNkY7fOfsVOUlzFgDBRS8ivUgGLbG8J0liuXJ9RDrwhMcy9UaTvzcJXzbdxZie1Rf4uW4SVV3Zr2LpitE2Tqi73kWOq+EB3ScdZ4F1tlGkxP0COysaITM4CCYt26xjpRGClrzuLtbkX/bBZQEj6//+q8/+X+bzF/9q3/14mlPe9rJdMQVUfvar/3ai2/91m+9+nul+HvaSLHuO+lAYtTGgZy1DiLpsZ9Mc21UBwJo+p3g0NzTul3E1eE1Bk2QybA+Eb4OxvtcQJgEraL5JS1ndiO4ECw2kHGj2xFGgorSy5gDxpoQyM0jHodLhXUBMNcCbmm/iB33WIAcgjRvvuNN3aMdco1A6g2Ao/mQsplVN7DNGdYv5ssigKGKk6AhMdVjXrtPNUSTe0/sUXvPRQFJaKjWQ8JvXJHnYkEav/MWY0IwBS/NmymT8OjdxmgfBGZu2iVTN2GE9eMYVAmWPY/g6Y9lZrMhNkUSXG0GwqbIs+qtcLHBj/4WVGp+9nyzqAjmCOvG6GwAJoZmvsYgeGFsmaWzGGKGfW+ehDrCRz/FliVw9On7rJACKblAWUM6m86uMxdIi4HQpNt/whxrgtRzqZ41DJklyPoJDoSLdZOZk/0ihHIDi3dwlgRcsGvvNki0vwnULCjOsedViCaAYOobJMuNTTgCTwQpwgOc3UwjAfNqs2jcL/CMcOVv1qbtSwquddpL9AzOWBthiPK12YjG8CxBnMC48C4Lp7XAcxmbBH/7rQ9nIBYpRYoS014HW8Ek+kFwUkyTFfaXLqtct27Wmxomb25KbVAcapQMCjOLZmMkUPRcFpeEFVYxSRwbp6YmD3zZ+EO0UfYagXQziZyRmE4B49dMQLn99tvv8vd3fMd3nBh7ATlf+IVfePV9C4nJ/GZaRKuDERS65b/7ZGZiThWlLMq/DU5QaLProwAlAkYH2EZWCAdwbkogs7v4DlqdGzU3Gyh30AaAOlzaPKsMUzwpvD7yfacVAh6EhgTdM+qA9H0EvBbg9L17EnouxpjEvMyBJam9ycJSSyhBoMUN0DSZKhHxmHUIkFkc00TAa5grsyg3A4aI6fZpDwkTrRdhx7AQUIwR0eJqaR6dHwTD/BDw+mxPNnvE/ns++FBUjt9bAGPPut9oUz43I6A+cjGKkVlLhah3gjQhZ5mS7BTaDqK3dWoQgtbiVu0NKGStWQFgA3Zrm5lGYBTz0jMyT+DOZptw+2xwIeZFqLIviCKLCmGEK8fcBaNv/RHuly2xjpHo2yWUzTP3pMsNCTgsBf3NSkcRENchJsw5s+5RFAi5ayavcekFM+JzlOAXtyDwV3zFZqo4d25TWr1UVzFnLDmEBII6SwhGRNCu7TiNL5CZkMCKKJtwXSqbSYXJu+6DoL2ZN81RUC3rBJhjZWGJAi+SBQgSfaKlLu4jHC9uNAbrgDO3Pvd/seLUWBsIONbMskmhQmcoFCvI6YdFW2wVSxEBBd0D+zI195oE8F/fhJVoFqUoC6GsPZaZT7+0GLoCoIYWssQf603ps+ejNe4JghN4L1xXhkGs0AqHaI6aP4258Z7oB1xkhcwjUHhE9IzVlEB4zS0ox8aEBLG17/qu77r4zu/8zpOQ8oxnPOPim7/5mz+oFQUT05hXY8g0MgXabELMXQAXArEaHe0qQkBzZZKL4e9lYw7NRvOHqtiJgUAugEhLKt5hU5wXKZbgbKGlfN+YHI2KyY/vVfCnWBJ+QO6K1VwxBgiDMOTzlLkhPgGhofnk828v1kQqSDGt1L4w227aYp+INZdbwIvp1Xq2fYTQ9q626Xt7Hw4BDRPl9qrFKAi+vU97ELQIYZYAsvS0NgHA6yZa4YRFSP0M59z6BFMLcl5Bkhlf2W6wAi5ZlFyJIK1WSW5WutbROBEn1jIMQ3wShk/rWabF8oMpHeta7J1M637YvVoNFJM6asNrATqmlapVxGLIPG8urC+IvuDx5hR+BitizNbKJCOsZ7ImqguzKa6sgX5X3M4+YQzNKwFfsLZ1E156JgVHdlswzpKwVrja0SVCGRF46sZs88KAMBLrBYs02RVCjwoUHBcIupmJ24fA2YV31ix9bqqvM/J/Vrloj6BWfREg9M/at2UFCKTGWjhj/WCFlqFCOFqYEziL7tjPhU38wfvWtPDZGIS+FRi8i2ZtxopxjMnNKHOmZ+NVXMMbJIo2NVYw2ztqL33EJcxRUNetikayrG+9H3vZe2IYxWDJ9hGLgsZTxsRLsei4poGrJytj8wM/LIj9HQwkaH7Jl3zJqW/0MF62GYb3Jg7lt1RAaVJ/8S/+xdPdBJmTtK/8yq88HVjMoEDMb/iGbzgJFMWufLC4luc///m/4fvV2AFim6XoDCImdRNiQupNceUjJGUTGmorbBBmRHXXaO3S/JYoKzgGMZhtETL+zSWa8uIRQ/U/FOmhXbLaBAgi6O27vgE2IWJ9w6LsaQWq5q5rQgCYyHCWEMwGkisxXiPECLaD8MyehDF+U37jWs/Ze/7x+tpbYJfYsijZG2mbtY10d6Ybt7NBo6wsNHrnwTy8jIwQ631nTptcTRADlilAg0DIvBvRoM0IbBaT1P+ca//bOJTNqNlUVmdmHQgXawZ3yLqEEH1Mad05+//WQCNdLVd//NOsUObgfFmuVihxTp7ZsQnjzOXtcTBv7zFKzDg4dn9UBHLvYqFNO59dh4v/XAS6+7ZuJ1aN3u9Sxog9vBC4uib5o/tKILiqoayMGPbRQrHm8mNK7jEOyFzFb6Ej8GOFwBVaawsvqyjAF8IduHf2LIbGELuxwiwrzwaTgikatflYgz1kheEOQVvtB6VlhRbwS/lYq8m6rwTd4h27zqMrcn9nqSHAwM/+bj9YoVg7g0kwCGb3/BJIykRDxxVre98UTtxzZfmipEYTilsJL6zB3qHJjVHAqxo/4HUDksEhdzGFxaWSlM2tUQOXua9KxW8urVu6N+XcmPcJAaVYlCLrc7Vs+/N//s9f/Z7bocV0f0Fm2q1NoD3vec+7eO5zn3v1dwCQNAjYjsSNhl9TMId2swwCAzlqV0z+CKf/6Z+G0IZjGMx4/KH7nujmJfRrmQFEiB9Ng8DDz4ioWWPvWavIb8QQwV4NYImPLAbMs7axJKtBbJ0QxHU1d2vd4DGxHta8gWtM/AilOICNaWARYFnYeB7Mi6C3wWkEFHtgj8TpHItmbZwKeDAOV524H3uQ4CCgd4We1aoQZVYRFkCmfLDFLy3YegU58U7gEfz5gP9dzzLfJbYYE4FuNXYwCf42nsj3zsSeYTIb90Cg3ewI57OCITfGWmHsiz1BXFeoFV8mDmqZxLFYVoJJFj77Bx821gBu+b8YIee98UoYmnUwuyfQqHshVgR+wl97t7DaebvugpDkPIzpnBaPFp92v4yxjFvhxw3i3v8T9p3/uhydGSvgCimeWWUKXoEJ57kWT/0734U5Y+xzLAa9vwGjuweYN2vfCh9oof0kQMAHlpd1peEH+nceaL599oy+Ft5r3DtclGgMmADflL3gKZgNFqPD5v3LcwP2njUhjgAgkQCtpoDZR1movY+uiB2hKHLlSCjgItvaXVzkS8/DGZbKxs3YwFLf2uyxOD+8+ZoKKM961rMu/sW/+BcXd9xxxwmJP1QrXbJW4OjdCSgk9mNb8xpgArSkedkzfdcFbQEBKVxQ29GEhnkcpWaaFqtHB8yEKS2yv5Vo3yCuGiThR1xzKWEBAK5lKEKbG4eJWRyAuADBUKxBq/HVMGuIZH8wRGttn2ridQRtMUO2HpHZmL/UPAWICAcCGEn3LmZUXXEvvuv/zMB7vxAEZTr2vPULCqtPhFEdDTEFCGk/W9/Wiuh3zJxgiFnYv7SOkE+cQOsmoKzplz+359uH5kBIQQARZMRR2mOCeVq4IMz+33640XYDz5p7z9LKuASPRAyDWEIqGFwQ92qIBIct9b8lunefCEGY1jLMziXYIRjAKRZIboTW7d6htRxgBL0bnLhniyk5IpvrhvXBudP46jsNsZooX/qlX3pVTA2hZHbnVgmvvNsc1QRqj9MWmye44ppsjZ1ze8Ut3DjBRf21F6xIP/IjP3IXIaXWvAtOXGvBuiPQJHvNLQb2/UQr9jzAWHCSi2rjJdZyQnAgqFEw7Kcz3TivFcC5D6I77dfez2MMljzp++uGWlfeCkE7BoEzOpSbQMbMWo0IWVzJW48FbdQvnLC2je0KJhQbO2ZeUUYJU2KlKDKECWt0/Ynsnd7JU8D6UHNvE6Gun6XFF1f5sIc97KpY5Acu19c+K8zZd/HUQgfcZB2+VLNKTSF0oz2TwdoaG6PYSnFXaDVXTGPUWE7Q4Y0ZEhQebgbveUKikc4+wT1XzwpZPBbRn569ZgJKm/fsZz/74nu+53sufuAHfuC0gP9Tq0ZITbrhPW0IBwGmA2ESj4BAPIycX7dNi0BUVU8J3hqrhdoYfb8BsrS0BKkOHKATUgKGLEYdbn3xnefOWnPpCiK0yTW1IrS0Pr70iKaIboG2NG1Sco2GhCkiFjRfY3P7WBtA30yLDfSqjwg7BEUk1kJES+Aiai+qBUCgIqFXX0bNAdeSk7gRDP003y30xLwJIbgt+FOlwQUD+sV8wQFNmv8X8yQ0NM+Qtn3fYme9KxuLcLA+6NbVfBWiEgxq3/Vf3y5dXC2XZkKw7v1gdV0dvefCO4SmRuNeN5i/+19w21gIaWMI0sO0FOgjXDHt3h0MravHmSiOuBYYY2AUtG7l5gVAbjxOZQqKJVLFNmK42QBcOfzi+e/DyZgMglitnM4BowNPLBftmztOwH1jcomw3MQMxKtxWVpfY2TNtcc05H5X0gCOCT6OeINX1j04C8ZlZikix4IkTk86tzgeVbXRFyUDMGo0hsCCLrQOhcLaS1bUtXasNYgLT9kDFX3XGrfCMeGmoEmXbzrvtfrBY3Oqj2CVAMSaS3GDL1yoMufUdpGmvqnU8GIt72iRgoeCTVdYXKFMOXjXMMC95iI+LBhS26r1xte4wJt//CBBpDgz7hb425oTFFrTz13e6yU4N/rPBSz2BP2HB/GK/q8QnCxMe0yIkxCivhThoXXyahC860MRycpMKHBaf51NH5W9myeLYrxfHRZuwMYJj6prdE0ElNw6L3nJSy5e9rKXnTYiAK6ZdNpi/y+Qpk1NsnzOc55zyvApGPPetDW19VPJ9zZE7EAEs4MNiRpb2lsb3Pcij7knWD4Q5fVZ8nELvGTRSHIl+DSGwLr+bv0BZGNscBBiCZlpsuIllAJunlvRFUNt7xBiNV3Wp7vMaV0XELMmkJNG+9rXvvYqRTlgDDCbJ6sEornMyjgr2K15kTDUcyFjF6v1nWyYGqFi42QQe75R/e8axdGwljVn0eNSTWmnCB6GuwG0mLmgReuqP7VuGruzbNzGUC+mYkj9/2gpaGzXD6ymipg2tuC1zlJFTKnnCSAq6wZTUlG5RvodLBD+1iWx7itaTP3TUAmzG+HfMwRLxKcmHsgegSkCylZE3sJuGxPDerdF62rLMP3dp8ywvUU6Yh78s/Dw59tfRe1o7M474UHmGRiSci+eZWPOwjv4Eoxuqmr7ImPFOKr6Nj/xZYT0+lC0EVMn/LCiboDjCivikQR3YqQKdy1T32Bjgl/jyD47uqvQAFZOa2u9zUdlVBlPzhqeUyCsvUb4YvWhaaNRwXjPi9cRpwdWCA+EgZq1cE9tZpxEgKWfsr1kpCjaJ7GBUoLWEvb7cDMJCkebele6eX2wUotDFBuIppS16VoEsNteOW+xSwkh4TzmvetprW5vf98lveiZ+mA1VBKflZPLBo9hpQtmElr6m+DWTzV/CBYyeHZMsA8u+i6cKe4KbkejxLCAGUYBbuuElFVoNuHlt11A+ft//+9fFWPb9uIXv/jiq7/6q0+b8IpXvOLihS984WnRHeYzn/nMi2/6pm+612NBTsRWemw/RfiTSttciEjaV4IZ497Mk93QJcokwf5WqVauOqKx7qYO0r0eXA1ryvSpEbYaZwN29Y15ix/wHtNb7djvUVhZgc6zBDJFn/gl16JDC9tYgg00XMa3GpV1cAdhgnubcj83jXItEjR0xGsDF7ktxOM0NwRNSun6o6WlbpCdNSB0mA7BZeM/WMFCeIXANsjX/mDOGDfLW43VhnBxtMAQkhJK7Ivy95p5g39ZTtbhLDDajclihbFumU2YFncJk6z3jInQ+x2jJnAd/fabGm2N/R9+9n/1LVgRel76poBqeO7dmChiL7VSthOCjRibK1ePfqSoMl+zZspcIGwrAudSNftrX1gTa/rbrDh7ZD/BIBgjwBAWMbP+3pRQY687wfkSUsQIrEtrLYMbZEp5sE9qjcA3bsNVpNAmDJ3rzTk7E+5z+Lu1ZKQt23ewsvE+zR/d405Bd60TM2cBRncIUmB7hXbCBKWHyx/95fa2/xuYb0/xHu7MDRSVGs96al9lyajGKj6oNelzM5ka8+MvSw0Q7qWVc08RqlmUCB4soWCXG7w+9gb0nkvgdi7GkRYuvoXi5ByFTKBxMmDRuLVmmxerD3i8pi6eD9USSI5VZP9vG2ZiTKmgNFdmSkiWNA1JBVqGLJgEAGbSpxFtWitpssOoP1YPzF9KMU2lPhoD0Q54HRIGrX/7t5k/ynYnUfd+48cgMQJzVplw+yFgaQhbjYBW611ZIwgHQQyC1tQIWeEHkzTexugwHUImWg4iIbKb9F9bK8pGlxtnXU8rfPVdkjpG13Mh0hYREkez8QT2itC3aXmiz7n71NkQf9C83Jthb1kJnE1jikfhukOYZFNBaNWQ64PmDUZU/UXEBEUTDvpbCXPm8A0eFB/F703TxYQQI/1Ld1TXZwn1KgV+Zz0TME4QJaQgpuI9lL+m7bK46dP3tfrNorREvrpFaaAusxRTxE3RPDNztwdqkmTyhnsKrW0gZpbDzNJck8GT28j72VoIi2BU+rCCjdxSRwWHsEixodULTvQR/yM+R6wCCxlLjMBglhFnyVJH+BIQzLLTRyA5axCBtHVwq+j3WN+EsIUpE1AoYwQhZ7xFFgnx6jOhWysEwWlzdebOyV56di8EpACiPwn5hE44uu4qgo7+CUWssqoIczNa7wYrd+7NX5Zh+K4YKN4k65JFkHUW/GUJYc1i4Q0WH/KQh1zNa5U7fIBAjs72vJu3nUnziW7xMAis7fnmjl9tLCFriTlxJblTLhwjdMji2mD3+B2LZXNuLc2LVZCwe93fxbP1UdqcNsbtvm2cYCUXS9UKlOUza8NyB9DKeof02AGTWDFgZl//x6AAkiaID8L2Dq1AcCTgXeEIMPd+a+ETbQ0RTkDWvJRY53MtuBiw1kSlGxfxW5dLTJB1pzVEwGnO9a/8P+Is2HkD8TbyfSPn/S8m0t8BqKCtEAMTEZ0vda19a0/52Gsb9CzYj1Dj7hkl6pk8278YDAGAVoHwCELdgDg+WuZahN3eNa/6LN6BFSKk3QJre2eQKH51BGqCOzExtWt6JzcB4YnZOYLgDg9nzn2BgRE2BfzRduwf5tL8WTJq3GKIFosFP33KRO6sGiZGIFkrDYLTu42BWRCGgwHxHDRCFo3mkLl7mZh9QvTrpz3LtIypRiSDR7jUGcjU8nzfN4b/5yZVKA8ctE5CbO+rF4QphXsEaXEO9YFRK3bY/nRmxdOFqzIWjtZRWjbh2PfcF/2//jAD59f3MZOEJa6B4AJt2jg21pV+F+zIYsCVSgCiNRNGgu1ilWjHxt8gXOe6mrd9r7VP3BuKZ1p731U/pjOnbLACcSELHKVsaKwFXKVb1r2GSa5wwVq0cLruTbFH8IJljyDeGMHAWoVZsyVACBLmRqXsUXzUeCKc2A/WJtbReJeza4wf//EfvxKM0LC1SK4Q2d4El2KICAvBCkW597lC0QbB/+bFk7DZQ+Ab/rowFQyIK7HPxUoFn84yfga/7y7Z5boVUGo0FdrDAvcGrq3PlsZdY9lQvbMGWdY6wL2DoTIhBxSZm/XDV9pY/OSI1d0h/JrLBUYp062omP7Fp/T3xjREtJgUl2nQpNe/z0TrgifSv/Rf1S97xyWILolDwAHwxjggHP7PfYZ48mfSegh06x9GGBJgAnJWLlH6mzaHYWMCtE4IwC1FeFpBc4ttqZEj1oZFxxpoEZBPkCyiwkJBW6CZN1+3HzcPgdP1nzCIsXIn0cjqF1HawEOExVgsbVKrG2ezadZVqXFHYjS0HEIYaxfBgTvAuazbzV7YX/DJIgC3NoAWTLYuRfnsJ00XXHgP06ixXGwNIEyv32V5NI9wBHy3BtY1OL7KDXchhmrf3Ra8AornuI5YZFlF3E1CcFy3KsGSAGjfpE7DWwIT9waY5hbkHj02c5K2jpFiDGsJXuvR3iMju8me1FbIcjYCImUy0fzR4j72X38bnL63GK97Z11n6LKaVoojYqIUDv22b85BVpIgVrFlhHN7r5+1Oh7dTpRAjH/dc+glYXLpIYHb/hMSjAFPpPAqhkk5/rVLHsBaB6/RVPRirbXoNS9C614+Q7Db91nJrG8VQYJLZ9D+9m4WMDeSg8WsVfhm8yaw1lfC2lqKNxbzuhZQlgBvkFibx7y40uBWcGVBQSxXy60dYzgAJCmW8ANAAHs/xaSQetd/zydnjPUfI5qeN28ITTvggthUPcTA3wCF1vvBxlkfOAHPnonbMRfuMPtxDPQF4KxMW99g4x5oD4IGCW5iNQROrnC12lv/dx0BwrYWnNpqqBoBkqVK4CnCiqgwp7LIHa9RYK1hmRI43cc9Fyw5agVYP6LF2rLxRQQyRITFS2CnOA9nxZog0JMAh4AtLLemNL0N6Fu3Qw2hlx7pDDaocJnInou+Ei5rm+JNYF+tmMZFoVicpkD4iLVwEd/euAz3E6ZZ4VgmWy/G2PjcNrWtVUQYFMPEbWGfCbCYoUrWhIHNKOMaZAlj1bSWmjgpLoMVdrnfCK72A41a5re44RzsFfwi2Fvj0h+CIxO9W4UJNTT5bY3Dumk/VjFkgbNuawGf9tn5W8OuBf5j3Fy9G+9FcN71g2uBxkt7t9+F9/qVRUgYvru4MAKL4FGWPS7jTdk/4p6gfTSiPRfMSwlAK+EbQf2jxvKwc7JfhDGB0QJeBfCu4MsNyGLEci5W0LqtBf53dvqMtqtyTkFxA/sqa9zx7VWCvqKTR6vYdS2gAMwNGoypFLmsmuT6RwUdITJZKvjrINgiew3RoX2Q6hF66W4Yd4fSHPbOl/7nVmApavo6+vVpG6wcGL13CGKIoCBObgOa78Zv+O4oULQPXA6Ah3ZAAJLGSvvrb35cVgnaNSbmziOMceMVBA4qPc8lAqlXyNiAXn/TwLIabXE3DHK1gPXtc7chXoRU2jDrGpM3QTCGy3VQ62zXZSj+glssc6ZL5xCC9iyYpP2CH6nMzV+fS3gIim7J3piNjYOiBW/tldV2CUcyjzbm4ChoEvLVpmH23UDlY3Pusg06Q3PBcFdIXXh1hqthi9/yQdQ6C8Jcfbp5GHEGV4h9mi/ztEqb0YT6YEVbi0jnxz3RvitVoB4NJWWzv1gjtpJyLozV3tEHjJ81lZWCMAi/awg9S0VrXebU3nl2aZa0WvuOSUiLpfmuO0aQsjWgAyyVxsDoBe0SIgTCg8GlZyxqBE0MtfmgHTVlEoxjjSvUogcsVRvj009WVFYbdGcF6/3ADVYw1hGWBfi9QbVqumw1XfFwlB3jo/HhfnscbQimOgN4i/5v7RKxgDfddNOVFX3rFtl7wicBOvyof9aivVJhlVYuPqn7hGX9o8GUCsULG8Mlsqzp3Et35w0gaIlxlMZ8dzTkuhRQahC8DUxSw5Dkk7dZEaU2GZC3uW4Q5qLpJ0kUQWURWS0in3zA1MFW8Ca/eK4CEnUSaQBZrEufbnHOp4tAAjYCAyke4jZuYxQfYn19IrZ8tRCyd5p7AbT5jmv6RURrYhP42SFf/nJBf0zScu8hTT8L4gpZWhvrhw8NCUAzv2LaaQ+0vtVkIY2falwIKDu676xD34QR66Wpr0AjpXHTZ4ODTQEEE7ROt4IGG13PwMrTuQhkLRaAtt2nc4bAxUU8/vGPvyrg1ju9T0uNYXY2BKXmFtJzeTBVO0sEMD+4NEDBhZ158xV8umZz+7B3MAlMXtcnArNuCIQKAdw045pnjYNhYSxid8D1sYLvEnpCgiBg8IBgCpKsj97JlBw+OUspnZ1z+F6fKR7BnYC+9i7Y7dnOnQvFXpl/fZea2Tzd53PLLbec1tw7YtcEO/d7gnKfhNLwu09jwak16asrscUCg5vmGx7LqFiBsbVHmygGzkAqLMEGsyaIiKMhIEhRZnmBI9JNKW7iYODfKh4EMq5LGR5gWf0VTMk9Qq2NxWODVAms9dvesPCBTTfJb70i8EUg2Eqn6LW5EypYjK2D20KND2nY3K5gT5r2WmjUnlqrONygKPR3fbQmAe3Fk7CcNGb7x93IsuK+qfruzD/5kz/59Gx9Fg9IQasRhrfgm1Rv6db9rKFtCtERWNX3QaNZb62rvijXG1xO6G8MyuvWlul9ONuzW2iRMHiP+fvFh3FbYBM3gYlG9BWXUa2Tf9fGp+mQIgMolxth/iwDe5Nq9yUoklVRtqTigA2S9p6CahCpgnABgkApNTLMgybJpE9ypgny27GeMBP2TMJXgFwfip7xQSJoKwRshdrWQvOsIY4EFMWf2lOVERszQE8axqBrtH0ETFBrBNv8aQssVSRsCLGawdGq5NP/WWFCLKbs/uccMNX2BuOD2KuVC7JD3De7iusvISXGx8qmBgdinuBIqIrgqJJLi+j7CC9BAxL3fUzNObefnhd8JwCw9/s/mKmfqk0KfiRQBXfiX9anj2Bi5LRQRI5ZF9PjrlgCbP9WWN++MQsXKjpzlpHd92NsFMuVcyB4sjT0XXBU31y16sawhLXvG2PCCkALB4/BTPvZXvYOAYWw399pofUfUw/HgyFaKusVnGlNzkKV5J6HV5gt9wQrBVcgywP48rfCdayBrYE1ePHUh8vSuoMR1g+uD4oJvDPGug7g6bqD13XM4iJuRXDo0TWxsAOenDcBjwu7duutt1784A/+4AmfWDXgMrerG3U3fgJsEjjBZU3NGbggOHRjJdxCzVVnfiy11rTBttZoTeiy37nWBNJi1ISrjcNw5oTYTZn+6EtBSVyJWDG0xT5ZP2Fh6dzG1YRD6qHoM34XLOKTrJEEPokOYvNU0OYCRL9VCmcssBduiK/VD4vgDSGgrF8N0LZBUnMBJ22kzZQ9ITuCRgHBN1Zi/cfMmb0fIevAMYMNwOyToCOTIsCkOS2wCb7cGAmEBFFdJiPASDVGAYIqCbKAECw2ngTDXa1InMRqv+4gQThVLaSVrduBpkPIOgYqMw9iUvZy10tD7rmtI4M53R0RJgRuVgBiKQLfOjHEjV0xBqSm/Zj/FptjcnWXxmprG9DKCsY6VNtAW/+zP4g5xE14VWzNTb8beMeds6m6we5aNVgN1xW51iWw5f+Y3jE2xNnX1jVn7+DSEtZlRAjUBhUeXXWbreM81jpIm8PY9/4PFiEVca2DcILxLG5t3QmZX4RR+CA4mCtzGQZt0TiqlLKAUmAWDrgv0SexHwRsLo1l3Nu4hbyDDjnbxTWw7LoJYxA40S/9iYdZl8bSU7i9rt49ay4bAsTWlzIG3IPjqyRsnALBISWuawEkCIiBq1kLOr+uFGtb2gJ3jUGo5hpcoXGFBetdl/Jafjco1Z5vrOBaqvsJb8XtwB8ZMWCj/ysxgHYQFH7mMpWYsM7SQ0lVZRjNQmsp6WiD8hDOgoCjurQMwQ3eR1MS1BfnWR4bU8HNpT3gbuPSpK9vssh1L6DYQMhMukRsxHLs9wg6hsbsTVultTOvhzBr/gR0NCHmLAwJIxPYhOgh2v0/oBJxLYaEQAO4aTibCYDJCFrCUNb0r+rpCk0bwLvjrDlTX5h+82KZIMApP0/AQngJN8z6BKoVho7ExBkglKwrCC5tbbMnmEgFZXFB2GfZIM5uBZMNesQUEWYuGOfLXIuJrcWBeVRUvZofgn171tr7tGeyb2go0r9ZkviBpYRmrRIroabDZiQhqHzNq60QgJbZr6UDweU6WeERAUJcMAPET1vBGSPDnAT30qbEu9zds8aBNz6bmr/Mh1VyYzpYrsT6EHRowBhVP/n/ZX/1O4sgiwPBRLGtlJHOo74FR7qripWSRcPeZKFpLNbYdWn1rL0hSEhpXka4TNya1q2wbrQVytE3Ctje1o7WgAH4vsqF38G+s18BAyNnqcG4V1ihvRMiMXH0Df7qEx3yHgHHGXMVgklKCoFolRt7ssppjfJAuGLRZpEV17PxHku/VjhBUyh1KzQScnuWFWeDXJ01+rk1pjbO6ecv06cFCsP3HTsYg9fcPWgqHgN/xFNtmIDQAS4wfI6lLKHCtS540sZLCRA3p/oloIDV3o+PbtbiDSGg5C9uIzAwhDELQ77jXDg1Pr2eEVHdc8V6qCsgAppE2OYqALUZBYJ/AuZM9MWhcBPxs5lX7xZL0r0ipFeSMwsKZr6my/VDpl03hnL5Ap8qsS7ItTVUpp5laONAIpbSR/2PFlTjn28cY2BKuTb4LgNkd9uoT9H47UdxNgLymLEF8dbfzTfffDoLxAAC1XfEPgm9/t0fwke/vmHaPkSRVk1gqMS0mAz+91q+39xw+XDf8pa3XLmmCIFcZmqdOF9Cz7qjWk/xJZ17exactaZgqjiU3IiddfuEMNXEBK11o7axI6wzzftzPudzrurGIIgC7ATC0Xy4uNSjOQqcW9WyluDTWbeGfrZfKmK2hvZLiXH7bU/UXem5DbIl/BN6KlOf2yN4apzWHwzZn9ZAmyUUcGGydCgQt+6ILcG+RdtaQ/vFNM3dhWn1s/6qg8KdspcaUhTqg0VRarL7fqSwh5NbX0hQMYYYXHXPSHsiYHEDexuz9XTG4UVwWw2jYtnWjRKs3n777aebYdUh2vgxd1Ox4or3AJPm7U4ntVvEU63wWf/hX2eEJllXOImGcnWgI8FW8Wli/JwFwWGrbIsL6qd5wMPO4y/9pb90hXPW0ZxZeeuvPTpafFZ5CsfhHsuMLKWee9zjHnfl6my+6oYQjNAuyhLY1sybdVcGX/TPHVy90zPuHhKMSvlg8aV01FihFUlDj9773vde0W/hCgKBKTAsXOJ1GgucVMxQ2Qc0B13qw30jfVhtFVmJ9c21RClo3+KtXOrVzlIrCB2SxcnK0//w3Q8WaH9dCigRbdpgm9tmhGgC6WLsMRI3vyrYJGulINGt3lhjCutw+M8gs8NGQEmXrlxnxjNGCC5GoUNURbZ3AEkHZvy1hkjrUsVSkSoIKg7E7autPWZAYHMXhVoe3E00tvakftvD3i+upr9VAq2JyeknhiVDQR0SBAdy0cgXKGNKmXAjxjEvVXEb78477zydAyGn982TqVXA7WqCNamljfXGN77x1M8jHvGIk6BSQGRnGFNq/OCheIL2rrMSuNW869N5EgL3GnNIHPNuTRHCzqNYofYx4tQYMZOEU0XU2mdCGTOoyx5XIycMx/i7fK7LFZ/+9Kef9ppL8k1vetNJ2O2cGg+DWBdWMMcF2PyDyxhIe9HvnTMBobWq8xEc1ff3fd/3XTFjLiQWIgSTEEDTZo52iyztfjW71t6YbgjusxYaVgWEVEwZgt7vCVPtt3uu2uuE8hi9cgKtP8G9tbSXXI+sTgQ1jFkMgtiR4LKL0tQWiskEV1/wBV9wpRWGLwkOzX2Lzzmn1iZAvf4FKzLtN1aCUHskXRPNsX/BW+fcuptPMN14wZ/4nc6/ubSnAnjDEUWxGpfS0f877+gDl2rzY+UhoLAwyXBijcBA4R2Bs/+1PxIForV9gqvm6DLB8EUwMU2aqwHtoMD1//aFGwEz7uzb135XCI3yRLHpvAgo3CHgicKC7spebL7iPdQT4hLf2iaEadcN9JNSW+NGao/a8/beNRW9G14ThLifWWIbT8YYC1Iw/IuXwi0LilpIm0YcLWDp6rnoK1yE92JJwIEqtP3Oai2uJXjigmJlsbb+Hx1lNWn+jSF+R1kGsS3oJlyXlKBC9HUvoAj4Q4Qwlja0jYpYtUkEFMgPuNo8Erry7mIQHDjk4WNP6BHk2qG7+dUh933EheQo48c8N21vTYUEj+YRg20Mt02GhAIv1coIgLck8V7op76H/lkAmNbEMEgvXJ9/iNw4bszdYF8VPAM+e1gjxdt/VSoxpp6LMdaXfpncA/iYfn3TmAQRmrfbNzED82hfm0tjNIf2CQLHoBrDpXu9z+pBmIyYI8aIEp9yrTOJqK/7q2c781rrab6Yb2dfvwKXWwd3Aq3Sh7WjfUoQSSgR+9Da06AbB/Nt/5Rsb39jctyTG6CnaBZGRLt351T71ppjdjGO3m+PYgqyXNpL/u3ebc+4KgTxiqHpbFiUZFzELCOctfaheTX/YNrtwEzK9sMeCZaV2uu5BL/mmaAv5bbxO39Zcj3jQsesEhiR2DQZFeBZbJhYIFYX6cHNvXNQUTl4KE5Clg6TfWe3sVA1ygj82ngcAYYEqGiVip5cdcEvIWDjLQRoCkTEPDE91ob+TlGrX5bYaIX4OQJS4xBYZZqhZ2gCYX0r0DZHadm9j4aYRz/hZuMQoNqv5gCmKFGNvRlI7aXLIcNTLmwKSetu/OCsMfoZPYFX6t1Iz8cjnBtrUM3VFc2HJYL1DGO3751JeLFlJFh91UpKKWrftwAmayc3qtpFrDxb36d+w8X3vOc9V+slACgSSbCwntZCoW0/8UFufVYsCue6ntbFum53vInVvdZYe69dc4oWiZlx3YzAd9lKXHb12fmEM9e9gMKEzpS7Uc9tkLoPNl5aIBO2zScckEQ3upyfl7Uj6ZiJsxZgu/VUifKQERL1CRhpShvnYt6k8w2go9UztwZcKk42Rki5cSaAgOlxUxUJT6wQi5wryLCAEHIakx9/TcLrx7f//MI+EaC+Y+ZzKRdzu3Uo9S6d0s3MovwFN5u3+fb3pobT6FW/FT+jLka/x3wj1Fvtlom8BvHtnQBqrjkMBMPnjkOo+54FI0ba34qLMWtyGdEia0phg0GBZfy5xmAJax0xeSl7YIDwtrVQmO4jWGm6Mn/ap7Q6afGtJ+G7dTLxMtUKaiU4qDSryrEYEIJv79enlMT2M4GoOfV8jam878IPwYAb1yWd3L6wTvR3QmDPyECoNYaihu1/Z9J3cFmm3grU3B0YXrjLMia1Oeueejgx/W5dV8BQZo+AbplkmA3ByP64jRix7p36jq4w87fO1iR2Dv7KOgKHaBCXlNorXNH2a2+ZxoDa/xh/65EN1zjtG1czZsm6IK6u+YNT9EmZdtlzvms/pWfXWHf2vhg4x1qGsXP1ggOCGutG6yOcJASx7rlMcq3Um5VWn4S5Pr0bjrQHrKZZHuurval/7k08AQ+RFCHMoP4TpHsmOALHhDAMup/9f1PWWVP69L+fuKTxeBBFdGOUNuiZsGPNjcP9ArY3G7A9UQmWYC1NWh/cmZtxxs3IpenvDbCFXyzem1GE91z3AsoGQhE4NuIdU+sQ0qje/va3X0l5YkRYKlgNbHZNnARGX/8BMymWmZfpkdYkuKrWATaGjAuxJ+vLZT6vBdxZfgAEv2wEK6RB2ASfkXIF7rWGEFc2DuTv+95p/jKSYh41xDNtqjEUHUO8zbm1xNRWgBCngFBhvLIqaPOsP82HOVwgo4wMQlKEc4Uj+7kBprRt59M+0e5jEkn19dkaIzJiNnxoEoSX+utcmSSZ54MZmqq5R/wQ6/ZLZdk0sfbAba3NPaIgHRYhIbAQ/LIuLIPmokkA28slaak0pjT71lb/CJLAu+A8IpeljaWnvwUB1+dLXvKSK201QSUXHMFDDFPEWfEvxKhxnFvvdvln39fHYx/72BNzb9+CY241LofOpn2v786kdZdi2k9apTgTykZ7Ij5EVhy4qI8+zUGMkJTjfqapBU+t54lPfOJV7Rc3G8eYaIPcup0pYtp8XvWqV11lWXUmuV24r+ovP3xzFF9VE2umDgu3RD9Z11zY9oY3vOGqj8Zvzs2n7whOwRY8IjQoWNZ5K5WALnIBCgZunurpsG4kvHERiGMg+BJKKIEEVq4b+Ev5IqhJSVVVmUK4rtm+x3AJdv0Pfq/lkNLWc71HgAnW+rs1yBLhFqKAhR9oA9c5WsPSFOz13Lobw1mCt7Lu4VPnFnxn4Q6+xWs5EzE3NRaUxhZHJOC3cdsXdLh9yPoXXjRG1hOxYh+YsvatVzmJ+ueetUYlHZYvEmg6O3E/gpnRjLXm92z7T4Fg3eGaZymUdtxec2Gykm2/9VNMFoGQQHZDCCgItiJtAVqH1AEHWB1yG0SL7f+0tjap/7tcUN59m85M3qb3P75+8QqN0XNbNTPEbw4YE4tOhxLBC6BdmkaCpXnSgLkB+r01kIZlHLm0KuBm1mVNyE1QHYG1ajDL8m2704TQRguEnK2rfiJem9FAI4zBRawRFSZGlTfVfmieMoTaE3cFkaIV0KvP9kY6XPEEPZ8ZPUIZY8G4e1+dApoiQaT5RGhpxHL6aezcM+39k570pFOfr3nNa07/k/qGsW/GC4TP8sBd0zj9L0KX9hkyEzJpDY9+9KNP+4D4R/gJQwgDQSSkbx0JB/XlyoJgljAiyBKhbYzmVFyKLKD2Slq0PWle4ifEWNmj/v9FX/RFJ2abIBEBjUjG4MFO+xNTJ5ASMluXjK7m1DuCDAmsggWVwFYQkZVHZgzmtBfoseRZb3CbG6nAWzAUgSwGpT38I3/kj5zW8b3f+72neSle2B5W66cYDtaO9m2D0fUffNUH6xAtMqJbHxXna87/9J/+06vaR+Fo/bq0EA7A6frpPFlYmk97mUXmmc985tVt6PX1d/7O37kq4tiZP+UpT7miN+3ND/zAD1ydYWOJbVFzpb7bo3CLq+JP/+k/fdojhf86t9bQ+9Gizjwa2J4678aR7ajaray4xivw8vWvf/3pzFP6Eg7CAxZSFbrdodPcgsfmmYWunyk5cDxYzCWCPgQn0YQEzq//+q8/zTtazlIicLT1i6Fpv8Kf+ohGJTi87nWvO61HETLF1bhyVOpuLeLE7G9rDl+bZ/vJwi0otu/W9U24oihyCfVsykfza+012Xy19okyLZU4Wtn7xdPccccdV7QIPq9byJUU7UX71vmr4h18t/fcin3XeNxo/b/zednLXnYVh1NzG7KLSyVQUHY37ZkwKXtQZez6wCdZRDsHlyWGPzeEgAKZEbMAvp8dnoIyovGZnzFevjeBShgaRsNMrriW1MOtWBiy8x3SDqQfk+Y7RJVCNyVuA6KMYR3MbmJXaEg7j83W4WtHfESbI8SsGeZvfj3HBN8Yqu1yMYmRINRFGGRlbCrixrpY396bwjRKSFBum4WIyZ020Li0PlL6MZ1S9o99x4DaJ8JEjYkcIQnxxQExobNscCfpr/WGZEo0K/Jn3rRkWgufeu/VaBmyCmqYou8jvIKO3YDt/oqt4xBzUE3T8wQjWi5rg6KF7UUMaANYmfP7Pa0oJsOl2bybl4v1ZHS4INNaEcHGaF4RM+5VmXK19o5wELEn1CQkgFNmZMKwNTtHgo+AY2mQzaFPBDTin1Yb4xcQ2B7FrAgOtHpaMmYiIFAGRGvp/2K/OqNcOrLQElSk2SvExQXMVUlbh7cyxliGxMRtDR2BwhSf5rvFvZ72tKfdxbXCTcAdQrhub8XVtN+uXRDMvni7qe0qfiaA0NazqGLutcYgnIFddNDdUiyF4J0luWeUCqDstO766fnWtm7w4EZ6K3duzFACA/ihXLE4UjArsMiVKb6pMVgb6xNtQqtr7X34zt0U/mSFJChQGliDWZOWnlGK0AhWZPuvrEHnYL8E1uMJzfWmm266igMSHxTsqC4rHoiAXVMkk6uF4ETxkjrfz3CfcOSKmGAtfJKksPyPxwDOgttN7RdYL3W+cVKEEiZlsQU3aMR1LaAAAoAgRaxPgAXpmfM6dJX0eidA4QZCHDc1kfDAXYS5dxjSmTEMmi4hgMBR63nfL2F26CE8oYG1IgBQsK1DFQHNmuJ+AwS5sQUCY+w0dW4iQof19qw0U8BoX2ndpHQEtzULWPMd4Y57jJ+XaZ+LxN4ijntBVU1QMIHRnot/2FTjo8WDP3+FmJq9IUSI7aixDnmWRQDREN9B6yJocD2ptSKzQiopgUbhLJlia51RI8L+SasmPG8BL7C49WIi1uCHsNucWe0wRJUsI8QIRA0h5zbp9zRVhJsvmkDmzLY+j0h+rigwZW71E0Pv9yyILG8sB4Rrvnku1f6m1W75AFresbaFMvHhfGMTcuEDpreuHH59rrpj6W5BlWgAZhajVZVaPAXY4T7iFlVPiCVI+m/WHXRFvFfKVd/3dy6BYCjhQlp0Z7S1SuqzZzZwnIBtLeI6BKeCFQ1zByPqO3GVc6UShsRtsS7HVN0RBh7A5Lo0jeXcBC2zXqobxSormLexZAUS7PVXMwZcIRiyJKIhaCuaJiZiL4/U3PZtTWppGbtxZJJRlI6Bt6wcG3eE7lOW7ClaKk7GfKVw//RlnN7CEHcnQQBNZ3nkxq4p07CuNDSivmruCer9vs9igl7aO4Jm66YosaCvIIRm4YnNq3XUn5jQzjYcuiEEFADMikHijpDwSwpwRLABDWKG8GOUUnVpblwEG+zDItOhit5ftwqBiY+R5oPJbp0J96wIAtv6FZ5nehYj4E4Hmjjt2xi0FQJPTMFeLfEgBNWYOBE5QlgtRMJI7DENV52BLWhHuu85BYNqG5+jzomAOP7b5iybR6As3+lahewvLZ/PcysVpjkiwqLXNTUDMBepnta1VoQaBk2zc379vZfFbflpdTU2aBnjck6CSVkyBNeucEfoaS09FxPDPNaHrI4EuN/gRgLYMvveYUFgveFWIHCtYC3om5AOzsERK8W6bIxJSAOThD0uEdYswgamQDPFYMFwMKIMgPkgkKx/hBBMGywzsxO2MLDFD1rqjtveZrb3f4HRXCGuTyAsEhRlt0UzmMzFbHS2T33qU08WrawewXLWm1Lz0YbOiQXKmWEghMHWJR6jeWb1kVljPqwbYFxqv9IFMSrXLsCb3Xv4tymzvSfgEmOj1KFf4rJY8sREcPWy8tYUKjNG47E0mitc2Mw7zFh5B8UsBXYL4gX//leDz7lvwsX+j5YQosBwsEnQdzfTxsu4g2eVTucFbnIP1upHNiVBE9x8ymUcXWcUrReE3e/o9J5N/bo7zLUZstbUVoErhIngCxywqNc/hZhFnGBVk21I0FLrBt3jjvI7ntj4ApBzrV33AgohQSEcTAaR6aBE1ZOwbVqH5tAdgBolWzwqac/lS5gv7dq9I5uaBVjEgjCva2IkmMkDqr0Uila1RXtkA0BWyCl7SHXV9Te6IIwGWP8BPALFrROBZO1A7BFobhcCFwJSs18RJxUzWZgwX1q3PeGjZjLeFL72QLCZ7BXaCwsGAuWzWgciwQS7flYp5ZlMCQGr7SJCW5PGGrh+7E9rbWxXDNAqXU4XU9h0decijsO4NAxws4KlYDhpi+1L5nYp0lvheDO+6lsGkT1aYai/ZRhEIDFtgZzifFh8aP+rtbpZl7CGsVtLf8fkCLcYQtYBqZLgdMfYINz2U9Any5BnEduXv/zlJ5gR3xCMZnFo7zDQ1oExSZdlnhYvtBZFgowxipNon+pf9k1/szqGX8GUdGLCIhcTQavnMee9wXk1bpYdyhW3wlp1uKUJioKBa+q5rDIlY6P5NX+pooRB1o6YOWWmPZS9RKheGoMO1ton2j1hnsJnnphaPzfWr3HWGtv/ub3W8ozBurDO2IRbZ12fW0TTreFooXNhNeROI1jJANxg44QimTO15iI7kcWphp60B9x3+qdEND81WoKh5gxnCUD9T5A4t+AnXLrdZYhSssGL/UWzKWfStMXQUC5bI/rbeTQGK3m8juBPwOB6JdjIJOz/Yp9YUZTLl8Is1RnNjAepY3NP24e1gCIyvkMEOJAjxllb7YjUXGvzWSUcxKaOCTRj/hTQitluHZA15yF4JNLVKmTCBOg0N/n2orN97zZmY4gAr2+X+G1RKyb2jYNYwWJz8j2n0BuNj2brd0IADY1/nXtGBUJEo+dYpxBKTLJnWZgi6r3THEWKywggaAjIUk587/9AtJ2tM0Qs+3+CQv8r5gRTYjqWfdE77mbZmgK0b/BRPxCPdaB+IjRcOOJnmq/UPlYHNSPAADfdugObk0BDRKN4gp6N4SvOpAYMTd28WJGkWTLl6rvnyqiJSDYG6wMBorXmZig4sUqRjb0CIYGUBQTR3OyV9jfrgpgr1ZUFS4thSEgqQ4VQw3rDAiilWqAehtUeu+zP/K2BoNN4zSMNLd83RsxKY/8pAjItnH1zTxhM+ICn9tI4CWg09PoU97ExZmBbzQ/7qA+0AAPc/hO6ElCcL5hD8L27FqPGl4aMfvmeZZGF0FmJmcFA92y5wRTckz3TmAQczExRSkHUWw6Buwh9tO8sPzJCWFLFa4AHLtj6aq/sg3ouaGD9hHfmxmJO+WptCUVoJwEaTVe4jCUd3LY2FztyPcMp8UTB9NI+sRqU096rf3Dc78GQGKPwOngSc9g8FEp84KUrqrX3/WZwon3wiHsswYog4lwJ6WgP+rlhDSyOBBCKMIENPBZM72zFs+CDFKq9gmJjhgiEN4SAgomQ8CFAm66Y1gZ9rs9eVgttBkNBaASpEjqMAUH3YAEvAcgYrDCqE/ZOhEKNBD5FY6yQQ2s3hv4BI58u8y2pV8q14EnEBfHbdD+1ETY2wvo208EYEG7rFxBgMALxLog+YYD1ChPh+uJ6YD4m2JiPNRIONmgSo1mXHIbJRYZZWweYQPjsiRx+fdDcCbQQ1Zog72r4Ur6XeYth2XtTMATvclltPBQi5G990ZikYRLIuWGUr6YFq/0gULS2cR2dJ8IfvCcUq7lDc3UOnQFtGxw4V0Ik1yVY2GBrZnPVKhGwxlKFUl2TmA3tEjzWnD84AbPguj5jlqokb/GvdVWqS8FqtooLrXHPZpWccI2FDBMXlC6YXCwDjZiAssIo66N9wAgoRZ0FHz44RrtYgcEEhuUZcLj1hDAneMbiy8VH+AEvaI/nwAwhoMbKae/EndlX7nP7YE4YGQvKjsGiRIjp/WCSNZa2z72hidNh0QD7+mbREy9GECHAr6VO0HDw6Byal7hDCugqTcFFVoJ1vUkMABfm0lkLYA7uS5UnrCeYEzY+cClsYuxcXOgCRZJFhuLce82lMdBZhe+40AWDO8tVoJYeBZ+UUlY5lrX6D1cb1z5yx+PNvAGbSHFDCCiYEOSHABAGocT4MZYaf/seVIAN+MR9bFAVxiiDQqDeEsoaQkUaNwaGgRCwTGCKSxQBywaVMfnXCGLMqAiYjI7GZBXAJADdWo2WaSP09o9FipAguGoJEgQlqLH0LDMX8EsQIghiMiwV+kSECSk9w5RoDAKA/vo+4gEBluhBahrXwkAN7HQ+TMzOi9bDHy/1nLsCo8Lk7NfG2tijdRVxHZkDARTMIAb9rqaNs0McNkVc0J0qpBFXmjJhNQtJ50BQWaZLUPD/mHt7fryiIe1JhpBMOQKYlNm1Jqzv3sWZ9Qu/VEDOYtFH9lbxGIQ+cSRpnRFvBcCWkNob8TER64i+9GaMVpHD3ufiBHu9l/VCOr9yABs/RVMW6Ntz7TmmWJ+uIiCYrCDLldUzlT2Q+un8uXWaQ3FGAmQJMTXMS5ApnBEky0LK9Sdg0pz8bk59t7Fmgs8VMUSH9A8n4Jag6LU+sDTA0b7jnrSnaK75cwmvgtBPQse6r9qfTU7o/+gsy5T6TZQogaHo3saNoPF+NleuTApmsFW2mDL0hEDxcsFaQeH20Nh7fQf8bz6sD/XRu+FFY5VJFZ792I/92JXw4BnvghXKTv22nwnmLKkJD5VuaK7SsoN/SjP6wb0d/KI1Kwhxe0b3EtYEBtdHNKWsH3dMBTO5Rim07RkvACMAnnNNBJS/8Tf+xsXzn//8u3zXoWb6rXVwXQz1j/7RPzpNuDtH/t7f+3sngLu3bQMVSeqKcPHhIbwqF9LmAp4NbqR9MC8uk9mALPn9im/xIe9tugQV5rsOiADR/9bFU9+QtNbv6iVsVDTkYgbf4F2+4IhmjVCyjXDAlaWC6+6fVE7+SsJf/1P6fFOGab5SlT0bAyA0lcqWK6Tv0hhVlWyOmTqlirpvo3lXuIprZ4kPF1djRdwby8V39aeyJK22Z2O0TJEheIWZ2tu92t0Zr2UJ8td38RN9l4ukGgvN3+VnChQpcR/Cto6EhL5n2oToGkLQnofg/aweSWsILntWQUEI3nk0RvVAcl255wlR7/f+35zFZ20WSf0xRzd2exXMuECx9Tb/vutneKvoX/vhnpXWXn8IkAB1OBVxJchF0FSXRWR77rbbbrsiqq2vOfc/6db9JBDDrcbElAkG7UPjNK/OBuEM9qItXJHRn+Yio4WrpnXCTe4J7g8MN0GhcaNRyq7XxO8EHzWmbK7ixgvOYgyyXVg4E4TUIGH+p2DJTKJIxKiCjZ5nAVIUS3C4e8hYZbkY3HskWBvdNB43NIbFqmSemCx8ZF3YrC2F3eDPZrRIeZd5hL6IHyFsCQJGU3uuPVCFurFZ8yQZsKArvhnMEBbsNQuSxsXt0zpcd+HZ9iwBssyzfuqz84iWqQ7LMoWOsVSLsYB7jRO9oqA2V/dS1WewtTFjYs0+4zKryx73vhRm5+jM6jP6RIkO7sMNbqnghRBJeOJi0ljj1mom8L25cs82r2hA9EbhUtbPziV46ne4ZQzK0iYqXBMLSgT0Fa94xf83yFRnfc5znnPxL//lv7z4J//kn5wO4VnPetbFn/gTf+Li3/ybf3OvxwFUbSSg5yvnt2xzmJbSqPj5mcto5gGK6GdMhWZMOyS00EgJBgFxfSgfrebAav9MiACbFYJ1gqWBNExz3OJALCS0W4RHpVnzgwTqEtgXcQo0Rm4N5jmENGAMoPk8aV31IwBSABviggFDMr53pmq3Y0aYM1lz99SY/wheT3jCE07viPRnpaCJ0/pc0ihTiL9c0OemRoq2b769U0XI1oLhNQaBVYCjdD61ERCKGKk7OwiYmBPtrzoMYoEUvhNTw/LXPPu0HtkXtIuEHG6d5p7AQwCtr3Aspq5PFWJpovCOECtbCHzYr4RG7qfm1P60Pq4CAeLcNwQKxHeD9LgdWXnCA4SR8CoIlBXNvT6d0cbUwGeWMIRW6jaG6sK2cBsxFFzY+9yJ0qFVxiRkErQEwXKTtZYEGIXPZNvQgMG5YHlWN2XNnUdChWrDtHPMLqFDqnDzN/foCSuZCr+sT+gOF9VWeOUO8MFw1EmqVY9mhQ+CwaadMtNTklglKThruYP/rByqTauojKbt7d7BgAJ+4k+WR6BV1qPvvem6/8UsrUOwL2VDvZEVUOAGWMUr0MfgpN+zOqC97b0x8JIN1OXu6izQVMqs+Qs4RiejKy4h7XvCqLuvNh7uVy6VZbBFeIbHPqxUwSs61Ln+63/9r6/2netdQTXuOvsN/lir0HzWbEkc7qZSUsCdT8ZpPSp1s15u0PQG3V8TAaWNlQq1LaT6h//wH55KbFfRs/biF7/4BAQFtcU07k0DvACHdG2jmHtpgZgkQkmaBLArnAA+RJPrhwa/8Qtuhex3N/gCMHEczOrHMQgrMnoQVIGjkCbAM4+YCiDVaKM1TI2FBNNrXNouYYmVqWcDNEyVv3KzegTvci0hYqwQEIXLaoNQCXW+EzeyRFKsg3TQJbjOArNF8BGizcNnaieg6MddTK2RqXRjkozhecWIIj7NT/olAikAkNmycaWOxiDXKrMuOwRBdH0tuFG2XkVJ71oLxqRgFSaBABA43VdjjYiZNEWWPXDnbLl8xGURRPQt2wmzWU25Zu8aQ/VUBH195hu8aP+Y5Akl0pUJN9aw9Rx8TzAiHDZ/hb9ogzU/nTdCbd4sAtwmXF/2EM0gZAhUxzT46TESjGldtSy4rEAsZa1XHRrXOTDlO5u1KIpTcjZoiv1rf9wcjObJgtpYgPphpZBt5hz0KS6FEL60UUHEjZMQQGmecKX9JqgSUDbFH3P0N2FEgLz59tNllP7u/wRFwf1ooMDzjbEBD8fxoysKvomBYo1n/cacl2aY9/FsNkCU1aq+4o8qcPdeCgraLE7k1y/33vurCMlokm1j/uJ/moMbn70nENna4PMKKTum7zbWkstm4+TqK5wn7Hl2+euGI6zV5poIKJmW0j5Crsc97nEXL3jBC05axJ133nlaeGWctXzN/a/SxB9MQDma6RB1yIpIbN2Ifqb90ZiUR17f5saELPFbny5g2EBVACquhSazTAsRo1FixkdGCFk7dCmR/U+1VWtyz455ImAEIAIHJIGYG8+CYCOW7lKhBYsBWK1mhSDWGILSscjQ5r/rQ2lqQgQiIXaEBaxnep82R2OoD4Re/xDDGMprOxfm+Z5DpPrbhWaNofYCgrz+asHMkItGz3XoLhkVfyFlH3dsYECYxtEyRzsVTCk4lN8/LUUtAkxBWp+zZMrdj0C5DcZdwiMWiAVrM0HE2RAUXfNAKOGuRKC8I6B2rWBcfvrfbJq+J+QImgQf9ulYHMv7YKa2gXgUCUxfmil8ZDUyDrpgHatBOiOCkBiufjJPI9DSOpdegFsuGEx8Y+JkkzR/GW7BMNqhki5Y2mwsczcOZlO/mE775rJAdAAtge/tY2M0F+7K5qFfjA1ThBvgT2ouJsayeRSKwIV7rsSomDv45q72vluD3Z8jm6mf4Y0MHPSM4uN7Vjj09mhZqqEX4EtGG9dUQqN19LGf5m0//A3PNIoF5QrdEVfUe9Hd3KIsl64M+ZXJbNu+wdkKD/4WJ9ceZamEX+1XsTNcXKxogmT1i4Y6e3hBqGNpE/emhlXnwvWoKi54RSNXMb9mAspjHvOYi+/4ju84+a+TCotH6T6Q/GMRbz7SbW2ktOC7awk4x7iW2gotNdoY/770xqRVWsn6DpufwESmuRomSkq1yQivKGnxLZlxBRgJroMM6lWQSDEDQLxSvQ+zLQYT0GXOB7jMdw4d46xBegKMedQ2up3rSKaLdE13JtCsEKKYFYImihvRsB51LPhWWS0yZWMUrFy0XsInkzv3EDMqRELknEWEgzWruWUiJ1A0B667NS2qb7FZHcyohBjaFMaj5PlatPZCO6ZNWj/CvgR0if4yP//LtcYPLaPCvTX64mMHG2CcwAauCVM1AjSfvFRF94h0zmougCUCE7h01hgHhuF8mm/zx4hYmmqdZZoVSxwBlJWCcMAMrtgTQdua6i8cbi72sPHaI4GX9UvgRNTBqDHAirVgfITr8CgmQUgHs2J6rJlgjrEr5mYcwh3LiFtpEX9CDquveiACJsHxls1Xa4gwYh0+6oA423DQhZvM6mqQsJiBHUJUcK6MPYF9tWLCkvg1riCCh/6WOYlJIDgFfymO4lrgNoscZS2mvULTFkSjKLIqsQYJfmaJXuWG5QazdX4UNTDH8rtCC/hQT8n/MHKWTcL0ZngSoPYGYbF+G8ysTIa+1jr9q5dCb42FCByCd+fQ3Os7npQrqQYfwyHCDFc/xXoVJ+vGF42PhqklIwao9bgmoz7QFe5PfMk41zQG5Yu/+Iuvfu8OiwSWgmr+8T/+x78hcPOetuc973kXz33uc6/+bnMLVhJ41YFhDupdKOFNm0LsHShtcGsosKpsJsim4/Wzg1j3ytay4NaBjABIFo7MDcwZgycMSOGSUrdBiIACw0VEMETCBoFE8Bh/JqFmb8EkHdufCAeLyvqU+YpDnGU4MkdWqme6FchW7EStvt3mikASlNwCjGH0vmqoK9Vveh/XVURMSjmGtWnVtFhVZCP0gvBiPKsdEuRWU1E3RBbV1uZoX5unG4tpJO2tG2y5QMCDPadZCeLc2ivWQdNoz3O/tT9KwQssJfARMGjYnY8KjwQZZf6ZgiNgMtKkLdOCgkFMWbAm4Z+w33vtq/ozrUkcD7iV+i4gUwCzizY3qwxDqX+CIvyQHYOpbwyBjCBxUe0pBg3vlnaIQWFKFzNiHjFqMTJM5lxSmNC66FgiEXUWXfEoXE/wNJghZLI+dhabxbXCJqa2ZnhwzQoMhlnSWDk3lR0tqBE6V4BfYW616GXGlCT7Z04sTOJznB0LoPgqAgEBgpZuTIIAGDcv1hN1RQga1mxurGlo9M6d625j3ygHLKbNq9g0ghyXHVeb87a2mnggLmexgsbtrAmLtQ01WBe177g+f2myUZu3u8H6H0tVsIpvUCDR32gI+kzQEhDMrVe/WwRUqIGYSErJZgNSal2R0bxltwpYVvBUEspaAY+GhWuaZtwCylJIw62cMy1qrSgRk7uLWdEIEMcG+AgT63YQFwK42hxBVjYbo4AAAMHffK1+boyAw1ZNFEBDLoTSwZCU/b4EATFeFxOEYT7rHS6F/ieKH2MSXMvqsq4rRGi1OBpk3yEsTIQsDWsSR0gBO0LBnbDmxhqhBlFsjKT6Cqj1Mb5MGlVv1z+5hGvjUTxjfuJ/VBMNiWPyCGmw0L4nLAkgpYlDShYtBMJ4mLvUz4JXWwci2bMRicZoLRE3wjKLkjXs3MEXv27PFfSrMmoC+Pqwe47gQJvefVoTMMGSpUOGmgvHwF9z3vmt2Rp+cTPU9jnaHmHI2QjaJRwoab8+dCZoQsy6vvwfETsKBa2peSvwteXPxYLY69YaHGytltX8adc1lkkWO+OET8H4CiCsWebLNA+Xlzl5Dj5zWxG2pKB7npZPgIWz4iA2cJQgZ732Dp5iroTJ9lvMDdoId8EJWrRm/+Nn6QicWauSmir2ed2ga70xBvz2O3eMNRzhDa3tb0KadRPIln7rD+xSalnFJRgQoK2pd9xOLC6OIAyPWbxlam5BSfQnvC3DDD71bvxwXcqYOdpNeXngJf0hDLP0EFrBVf8LplqTWJfokjIAFJvGZC0XR0nZorgT4ghF6vVwB/VuffFO1OwTmszKY6/E41Hk7zMCSpNN+/szf+bPnK4tb4KvfOUrT9eN10rh6/CKVbm3DdKSphFtwV6AsI1vU1WopKnxt0sFA8jLoAA+sy3AAUTGU8+EhL0+VtaCGp+vRgtkVUEoj4FXfUerpoEiULRK2tcWPzsi/iKsuBgCG42WKRNCyEgQfwPQzPnYVtCD0ILMYu4FRbeXAT+JffPuEfGdu7UgpogP6xQhlgUiIcg6uNrsDSTZoEmIZN4+iK1U8gTrBAkpoWtxaz6tiYaPICO2BJQNUJSRIj4k4aRP9RQwoc5BVorPxmfYi9V8MYuFPWZyBIM2tOZd/ml+d5ktC0sy0rbGh/8TjHpfjIV4oRWm28eNGdtYgQ0CZH2wV8zGNHkaWv2kQBBAZfJgqjsGIYVVC8wShuyNeg/9zlLaXgogp5hEpMWDwWdroN07i75zZQIhSv2hhXuKEAtpz4JFZ73C0LqJCZTH+LmNP2K91DD1Vcj0ucoO4Wj/rhHwtw9KCtxiDTO3HaO21hp4yfJBCKLAEVAwXzh6d3PdftEOsBWu0fZZE5xDz29QPGslQZXgiEYSep2nvcc70Lp134BHNGIrHv/qpYuR8L1xWp7dzDPwUgM/K7iD89aM1rN44WdbvHDd7Cwu4DgcFDcnJgg+NYc9CxYfY17TGJS//Jf/8sUznvGMk1sn89m3fMu3nBbwFV/xFafN/HN/7s+d3DVSUJ/97GefhJN7m8FTU72xTUDICARM2MZpw5IwlR3vEwETsc30DCFptyRSjJCUS9tRhZT/j2AAIRu7IOCNQnf/DLM2vyJGW3+yQFSu3Iu0mMv7QPrKbeufJstnC/i3QBjCQYI2bsFaCBsm590Cn9Vf2TgNSF+zb0rjZ3WIANRC9KTxd77znVeBoQmnwYn0XqZUZm5ECeGuIXKdnRosXFZSjTv7kLRg085dMamEiy2+t5aZDTjGgFs3S1NzxZw7086ltZRhlWDCF59wtNVOaXjGQHgw8fap+Wd9af7SUlWFrf/2yG2lMUSMbRmi3xGmJTLNS6A1hsVqtsQco+k8Ou8EynX39ZzLzcANS0h99V7nKs5H7R5FwwQYVx9HqfFNaV03bY0CoYongbwz6O/whCtJHAkakJC3lZ8JKNxgbgl3Do0hswKuiZlzHQXrBJeFgl4sAhsHxwrZHtZWMCbMsnAkVK8bWCE5xF1RPEIeHF0XBmZEcAWD6265+eabr2J2qjeEiYLHXTthVDq182EdoHG3D1LGO5Pg1T4RqNaKhdb4EGgIHTVjiDWBd1svpzHC72Das2gD19fGibBubHIEy2jrDzbjW7KH7P9miwlgDi87W1YqVhaw17jBkzuvMG9WFcX5mlvjtg6wKyblly+ZfeOwTKyCje+5WLM5uc9HFpvUZW5BLm71o4KrnlHLZeMZ6yeLsfvoon+KxykhUODtxlURQBq/ffWRbiz9/JoJKBHZhBE50E984hNPKcT9Xvu2b/u200FnQdlCbf83rTEENm2lxa1iKthOgwgRG8FafGeyZJgVCTZbYpjGiEG0rg7a9fBlMMUQWVtEOjPjsUwwIUKsldwRTHcmNI/uLhH9nqsCsNe8y/3Dx06rZ27ln+V2wVgUAHv4wx9+WkNnGDC2DvPkc8QIuMtoZNrGDmDyCQssQxgQTb1nY7j8ubS3NY+vO2w1eK4jl96xABiH1ospJJzsOPo/Zjwtwew7Rf4QRdkSCQ0Ry+o+iPUIptbPj6FzJWz8gnn1tzLd5icrg6Wmfuw/oXznDxa21DxTbufcXiTEBp+IIOKJGXTmER7ltnte8CVG2O9bWAocsd65SG9TiAnUNYK4ImX2mtCw1rsNeOb/r899l4m//8PB3ttrLJYZ8pGLC2CV7B2xEWjK1oPBjJoPYYXWTuMV4AjGpZy7zFStoPYjRticYwj12ZoU1mOVQD/cYEsIZVVgZq/fBH+xOqx/hH34FLyKO+A+oYCBww1mxNj7iZ6KlUBD0FA0oPk/7WlPO/XTnBJWuHnQtg3WBxfwgZsbDBFQ0DKp/vCLJQ38rSUJvcBwN5B9y0Co9dOZCmheN4072VTbXfrXsyx68ESGGqGXRVRhxRg2esYa4p6tBAcXd77vUjgR3yaDToBrc6DUNfdHPOIRJwXTPOorHFdErfMIjoI9VwX0bP8Tr8ZqHpzAX7jQHnML7o3HYnD62XsJLv0/JSRlq3dZzBkIrpmAUoXYD9XazBe96EWnz2+2EUDEEpB2V4oWoLV1BLgDmLUEs60Jfc2YHbbIcVYKWkfPdcAYFKQH/AEO/6wI+KP2IDWMoIK5Ew56N8ThI8fIWAFCAtoUIFvzpvmQuO0VjYCwkGDC575m/k1HbQ8hDEKxPlnEwj5Zy+5f4wiWMrfamp9ZBbY/zxzdecz/qmfWpBQzjbstuYYw2h/jrNa31in+UymIYMUaMJ+1IumHMGK+1mevakysrAWNy3+MQETk7AWYtIYN8OV+BEtgj7VDUJt4A3DBH9/fKi9jGGtBwXwxe7EtYKU5uWZh1851J2MMQ6QQ+BBQ+oA9Wiq4Z3XauCfnJBCfJYJAy3e/KcasHJiVEuHgmlsPbMOXtbyBG/i2QeXHMcTBYfKtw57TrDFHJdlZI1mBuKbQExag6AN4htvWRSikxJg7DX5hiouMEJHgRMhjZQHn9gMcNv+EXG6CTWM9ZtEY17u+X0FGWjmFDaxy6dQI4hu7Y6/UlMEfnC9FEy2UhdXfCSuEL+e1SRGuNXAGnceWOOh7NWXQm/p2fYIzZkUgKLLkuLWZMPJLl5aXPqw2hPINCxCTksWDkAEv4X/9U7pbg3gk1hnCu8Kd6BXBub3JOpyghXZTosBjzx2FbRZu89oQh+v6Lh7aKouI2zYFjNrk2gZNIZ4kawDIrUCjYv3of/3exq8PVOyKQ8DUIFTjBwxbrbTDryGCGB+iq67DMvVlXI3NYgAJWQxoPzWCBEKAyK4vmOncfm0RNppbc/LMpi3zlXIn2S/7ztKkPL1MIYwRcWO+rm0AoCDTTX0Tb2DNLFu+4zLg7hPQ1fdSzZfQi3xHbHb+0tTVo9giZhinoOiQltYmLkifBBlBYwgpSwgrkL2QOYKA8osHF1sXZgOQnadxN57GXhIUlbd2loh7cyHcSaWWwYIxmTf4oq0ynWNumCZmQRPeGiUbjKyfo+8fU0DE4THrJUuSeW2fy+hkUsEfjNt1FcugKQqYerC5gvb2z2xeIxzQSgWlxhRYXOACwUMlYThhruBwBVsuMMyK0FWfYpcW95qzbDYfwhdhDk2Ca4K67Tfh2LuEDLCLRoENONx74IeAc9yzjbuoccU54+P8l/6AOfFT6+Yi6ILZVQzQKd/JDMrSwNqmhL896nlXDLBisLiCzRWSxJpItbYWdU+kiIsZrHH9sgziTx93GXOkj+CoNfa+28IJzODGvUosLaso1Y8+jc2ybg9bf4IL3uR8nYHzwOu27ELjEgiz0KDXm2m1cUvXvYBSOXG+WWYxGxjS1pawSO0DaEmkisoowlNfAUCbWDBn7htZIhWVywdHAHFTI+RtHAGyHTYhgDl5EbP3OtDcDiEIP7fULalcCxgrZNVWulaxlXYYkLkWm1a7gaiEE8KR7xYxl7Dbww2YJExkQeKCQITX8rLjrIAh/mUJPwAWnNa60g4zFWeabAxCjZRfAlbfEVpqvbsEuDUREtsf1xJkehQrAH7Ez7jQyzlgkKw+tA8Esr+zfjiP9t/6EGTEhJbm3N3B4TZbMSa0JnBU/+oGIU61/ofpcnnSOPnEgzV7v3C7Fsg972OgZH29+tWvvmLkrG8Ik2BxQq0Por/CBcZmDMJU5158BIFH0Lt+MBnWno0n8jztsu/aC3cAgX+WLzEbaEbfJcw6DzfgiqkCPxhl5xv8ND+MXGxK5u2t+7RMszN3Z0798uELTG5eKTbBqTL7axUNFvp/7we3lXQQPI02idFpHCmnvdPzjal6MRcFtxR3t1uZP//zP/+KebZ+1xMQsMUoKITZe1xP9kkRSMGV3JIUBbFqhKL6bf/qlzbuMtD2ujEqSV+ffdonbq+1PlBuGkcW3NbKaQ6KhUaL12omDi9XJ34h/dt5iv9j0YtOpbAEb+g4OkjBUUOEcAYuKBgsGQ95yEOu4mGU1sh60cd1HquUExhXCdgaNhorHCFGvZ5+NmelFRqv/jc+sk/XbDhrij5hTJzJFnUUbA7/0efrXkChDQTACtUE5G16zKyNcceG4D2ZIwKd+rvv+x0DA4DLAAFQBef0gcAnyARMPcuHudkC3/iN33i6NKx3y1qSf69eQ4cpo0jGQy1Aj6FglogEEyGmFXK6YHBrIDQGzU3BsTWNKqS1AaqQc90I+lyfNSbXnNb0XcOISeW0qqMLh6aJOa7ZnDC2pthibzIht54Ex85sgzEFBtN4uaIIcQkk7bcYB7EIGHLEpfUQcjorNVnUpCkWSAaKOiBu1+Vzb800Jml4qjjGSEq7FwQt+FY9kc7A/StSGwmBCcd88/0/+BCjoiDY2972titY7vzX/UPT2Qv4mucWfiJsyI5gxkVk16IgAFjRuPoJztw1tIUGj5aNFXpo1htESthiDSLwE35XmO9cpMcTRjFb9zyxHiHiwV/wVGYhBaH+O0c3K/dcJnMX+9UPvJNW3nMux1y61P/b34h877jXitYZfWIl6t3GEkDcPPpdPAsrj7gHAnbvbs0Xrml7W7HM5u1erFpzJQBzG4QXfe9/rDHtNYug+6Rau7iw4CEYdAFg44JHQaN9WgsBtrUJ4NyimUrXt9ae7RwSUhsjOtw5JJDUCLPFU8Hj8KNK5fWHXrb+9jX8IsQ092hH+xKMhpcFur/xjW88jVUcnpu0rbO2dWdKEVasjpBCSK0Vk9YYBLSeS/gpJqP9ioYIuKZw9mxrqABldKf9+Lm5uBHsUXp7rn4kPvQRc7KF1IzBTa4idn1RdqwLX4n/pdxGS+qTEsFN1L66p4yiZq96LnhsD9wZJ+4H3b+mMSi/na3NJR2H8MyiIRofX4fVpsYUXMiGCLfRWWEChne84x1XmhFG3/cC2kIqKWKbMVFfMY7+nyQdUgXATJR9Xxn/GFefgIJftQNltVlkwLy7gTUmEzF2yZ4S3i7gI5xsJcPaMn0SLcHC3BFxAWIh7d6jQxtZk6aAS0xDrAQCChC5kgSJiT1gTbGHAuK41hBwjIi1KmKEGSHmEQXWiJBFVHq/K72MMPVse1nr+QhGH/cOtQ8RwmCinyvYIbAhVmedcMBS0PyDKxYyFRxZrLiOaB+yYqT81mhThDjB37QeAY6CFVkSCEWb0ipeRsVWGS611tBeqK2zReeY/BFe2h3rEc2o8aSb07q5YjSuMRUzuXjU3hCbYBzp4TS95tNcwAvtdC9LWzxat+4KV8EXDZYrZAM0b7nllhPTkFEB1gQf9yHks4I0384HzNQvjdI5u61WYC1Bi1WnPYx4ExDD6+bJxdJaKU4ruArGVxSLRQuMRX/0wyqIRgR3nbdYiPYhJlf2iHGD/cawj9binPrQ2jHsFK/6SKiWsSEzkVu3vXIPllRw7ia1kHovZpgyUP/2iZDZz4SJcKt1KErp5uHmItieq0PsDwG5FgPnVlN9OOGHm6V3Opvm0ofCGBwQdLhCPNP+tJfScFkLnGXz7/+9KxsvmCGkBCPtQYJSwkn8ozN94CUNbD2ypVg9MHmxVtz9wVLnmDDXXrFwCk1oD9/85jefzkwNI+5ZlneximiHgNzm2Q3PzbPM2/ZN4P7GRcW3EhbFwAjIFV92w8SgECg6hADPDbzcLMytpDymLBIr/zGixv2iKWUt+E8dldoGmm5xNpHimKyyzQFowKmwGJ87oiW24BiBzhTZczIOGofZFxFCUBY5XBZH8KGBmj8znDGY3jegmFa6QaTWzUoikFFQ8vqKEXuWLHE5/MiYjvQ8ViSBmTRq2SIRl4j0Xty1gVebvUDzQ+z7WzXbPvZFnAStSjwDpMY4uQnbcwyr/SHAEMpo0IQ46cEsDuBWE9zJL01LdrGf1DxmXL7uhDawYh2YLJjhTnNey3wXP2QK0aR8rw/7IK5HLA9LImFYJgu46Tup/PYL0zFfVrS1uvG7cyUgxNxAvd+7CiXqw7ltwKi5O0dWOTEBmL0gXK4rmUPtPcG8c8Y41QSybhbADXL1XO+ro9FzmBlLRWOLf6ivxkDHaOobTyYGzd8EQtZPSgjmsdY5cLh1Yyg2ivvB5XCV5aNzD/9as7OsCQzVD6FUTRxC0GY2xtjAQG0VoxVe0SNCkzFbq8wTwj5FSeAn4UJsCYaPBnNnqfi8bsz+37NKAAjc9gw4xJh71hUdArxZ3RuDUNS7LBfgkADEHU+Be++lUCLej6V7g5LR6PpgsUo4BkuyAxXG7CwS6vBJblmKeXMmmBDWG1+FbH8nxAliDqbUUCFQCwCvbeycYPz24LoXUByQdL23vvWtV5VNmb56hknZJvOfZ8LC7F3yhsggyqroESSYgjF7wYn1kXa93wsgTcqOScrEYXamORJqWE76mXbPF8viwzLBt0jYgnybeSLwkuYDWDbrxfzEKDD30+jX30+IWYaqn/aSgCcDhGuIgKDYG0KvP0KGPrkHlpH2fRYwdW1okQSQ9r51hHgKtWG+TPGN3bsxS3EyKh6mvYltodHRtHsv4sI1wiITQ3ATrbRbNVPSgASosT6Ij+l9GqUg3bTWXD/9REDbMzVnPJslrz3nrnvta197+lsgd30lqDe3miBjsLZCnXgZ2TdgejNSEElCxAZWC8ZtX9ofzLe5su5teuoGxrJ8CJwVI7H1KuqX1UpQIaLPUrpFq2h6x8Ba+M+MTVCEG2l7fOVqRGTm7yxYXGIe3gk2UjbErfRexJrlCTwprCemIph0ntwoLLBq94ija11oBabTOK4q6OOCRrRMerd6Gq1VEO5m3xHiZHG47mBdhIRvQlOttbpGorUSEMGk2L5wIVxVa6U+wwcxUK07epim37PtnbgW7qreCb57vn1s75onZWqvxOjTWNHL3tsMrd5trlzZ7a3y8CzOLMsKqzX3/k/46D2CYnvXelM4m3vP5Sbse9WfSyfOetCZyBAN9rI4tIbGqd9gSDxK/3e3WFaJ9iYrxZve9KbTnJpDvKh9oLSok0OZ6Kwav73trNtzgdpwPbdNQqlYu/a65/DKvmtsJUEIV/1fxW9xbH3fnFtLcIsWd57Nr3o7BPHbb7/9ylLvPJvLdS+gMDu1+Vwh3BSYOiLdIbUxpEZatmCuNrOfARxGX6sf/m4WANpc40fgmF8bO6DJnykzSApwJr2AO6COiCDCvZeZVLaMarTVicF8EQBMkAmYJtV3AdaLX/zi01hiKOorhiy9LROlvWhdzWfT/WgW3C99L6DYZWLNKYmZybj5Y5KIkpoMtNr1WQNyNSUaZ29qVguAW4glqjNozSGFOCHBv4JZ+aJ7vu/bO7E5zbXfI8B8/TIMejZCXn9vectbrrQkhO7LvuzLriLom5cbmsW5qPXRGDG3TKjBUWvtXF7+8pef/Nriknr+CU94wlUMVMSLObm5EvhcH++Mgq3m0bk1TufAFVM/mYfte3seAZKeWyMA0pZZvWSQSAveALfW0Rm3v30Izs67NTQOAZoWLwBR8TqCCsGBr9vlg5mkmfddLofhsDYJuGa1qNEOBQPWrIMLyj67poClrDGChyc/+cmnsV/60peenotJtc7whXDTGpt/P4NX7ojOv33ozCPOnXeKivuzeqZWXxhWtCrXMg26uAS1KGjHhL/Oi/ttBUyxdzT4hEICJ3rWnvadWkrRnebBRQQn0YjGUZJdenTPYpDhTfQuHGitzTNG1P6qMSRNlYWk/RQ7pxx7iqT0aky0RmFIWL/11luv0qApKf1dn8FF5wcvWIsf+chHXu0312wfLqzOv7kK/oxuhEPtXX2KG+LajYn2e2dDCGm+rVlsRXsVTBBEVYAWSNz/W3ffEy7bj1wt9aEGVzDe/Grt32233XYVbK0wXf0Ud9JZxTNkJjb3zvZJT3rSXcrjh7vKEziX9pZbvfGzwobfqss2Tq5PwmM4HxyxKCZk9WnsziV4aT+FC7TeYLt9Dv6jVev+trf3tH1YCyhSQNV3YN2oBbgdmlRKmoaMCFLzZmh00FKJOwxpUgqmGQ8D652ISgSt78Vr1DzTuyw6G9vRXCNmAS4E5OuWCipw1t0mBC5ETL65NNov//IvvyLKouZFsTPdqlGBEbLKbFEnDEsBoHURNWZjeb51WbeL5rh8ej5gZsqubSps/6cZqyjKzZWQExOgQfZehF/2heBMzLq19r39VVURc26MCEsIF4MIOUOsigjKAquvYKa1i1lojf1PzEkaBzOwPRW0Zw8ag1DZdyFsAoqbgyOI/XTW9nIzpbhbjj5iWmx9xxRorgIhWSC4HFz453N0c6xrg+DhXVYXBdCO1hrFl7ZuBdcl6x+3ECEVPmFGLEZM8dwKGOgx3Rl+s4SsImFdBDHXXajhgKhK6e47t4TXb/Ah26qzDbdiPlwilJvGcgmg7JLOt/46kwQYVrWYjtoZ7WNnHQPYeLYd0/ztv8yihBjxJEztm5Yt62ODhglnzZmmHQxtXJKz5z4NJ8RUMdXHFAmVKnPH6Jw3XOl3ipA9Y4VRpqG/w6Hmp2op5h+tAHNcUYKW7RHrmziJdXGIaxGDwsrMOkshAZ+YtOJj9pPFicK0mZMsXe1JrX2KySuM2R5JbLBu/IDQ3Ho2rVvWlCyaBJLe/WN/7I9dKRHRlc1+U4m5+RYTV/9cNTwFe02J31lUxKB1BY1z5DptDFbj9qyz6h49vI2rWOqwwOmNMWGlbv1dICxza2vK3BACCsbBhL4uCZIkUzwfG00OEaWhq+fQu9s/a8TGdDCvKq7DnYBwESIQab5mVVv7f2MqfkMgclU2v7h6DbRCGi/CxlfY/BKUEDFFtLYI2PrMxVlsuuDGXeib6ZOm0vMuy5MZoTDRrlMfGAcNeomMTJCtl0LoEXMiGh3C1FpTyFVffc9sDmGY9gXhLrFpzxG31lA/rUeaYQFmChtJm2Yt2Ih67qfa/l2f9UODFHybIKpkON+2lGb1DFguZD6BYdYsQpBYGu4eFVCba8IXF8BWSV1Gvntvb2r9zXUAzrnEVhHY2ivgiXCAwDvzDdIzhniDTfvFvJuzIGcCJ2GEkGtNvmMB3DkJsKWgcLOxurHWdN4sM30nKFc2CVjdvWdh6GPe4TCGAe9jsvWJwRHOWCTcp2U96uY4F5YULjL4I6BTXYua2AH1oNo7lgbCfG1jg3qHsgRXWoubhsG3VFNC0yprrAisyiymG6vhPAi6hAfxe4tr4GzplPElPtj/rRQcniUYgBF7Rti1X3v/mjHsbeNsdez65f62Z+IRNyNLPRbCooQK47OMmhfaTnCnmPl+heqfH1fwBrsSFK2jd7aQ4rp+xOlJ/qAQNrd4xqYc15wZWCUog1EVdM0F7dvxFb8Dl9zFzvSGEFDaPIKJOAxMNmCWQhvAyHQRn4Hw1drInuPuIXXScBFefnYH1XNJ0kyRzH6KNWFmiChJPqLfIW4KNIuCbAQmTNr5jokRb4GiWvOHEBEnhGBLj2/QJyEN8iKAywDMjeAgRZWW2h6lMbFIYbZcUc2NELLxARsLo8YLQQtiSOftuxi8FLlagqGgMQw7y4R4FprAkbG7noBfNc1XhlQEjrVpTez8xiovYh7OgIYqAFBZckHACheJR2n/lhCLbUlbFEAL8Zld7RuXZvuBePfpu+YqYNqeIlT2YgMrV3hw3oq1saIggs4FY1KxdQu1+WA+zv0ooIAd+MpSJ84nnFOEESHUNwsG/N2gUGvANDBKOI9hSBknwNW4CQTdslTYd+e9QosiV+2PyylVdM0yQ6gW17aKju9qAqy5ANElQpDYiS0WCObAEHpFuIcHsqMwSEqO83clCesfOkUoJGzVb41FE91wZphrjauN0AMv7Hm4lvuBgNQYFA1rNM/OXIyT2JO1NqFZ7lVCP2v4AoGCNcecozFiUWQQFj/ibPaONZZoZR7aN+MIRCcwE8zhnD3dtGL7gzYRJCgQBJj7TfwXWBT0u4UjKQ36OFo7CEHtU7RT7SCKztIGcCWOUd8C8Amrzpug5cNSgxerbr3W2xtCQAlwI2aiyjcDJDOaGh1tZoDG5Iggq9mA8CFOnmMuxVwROlor4IGse2CIeq6K+oFM5k2j2mqANMHNvVfrpe8IQIg2/zJNWgDqApAr4xun/SA01bgDNi14iT0Nn8XHukjsiImqiQpbbRo1xo1hYVS0P4FzTH+0rS3Axd8uiJWbB6NvXqWJQ3SZNLSOkIZbz8WNLviqyYBo3Vk/MECEVmAsV8C6c3IBIIDtZX5r7jmaGc2CBudyMufduaqfc4yfEsdBCOVeygetsNRWgmTp4prBJMwZbG9/BCIuPH5rGTvOGpyqhyII81jBeONGCCzg3Xwbg3WNlXKLQQmIJoDvOjZgewUUcQCKo4krIrTA1V0PeICf9bflAKQ8G1MNJK6F4CIlhZUlFwmLFqGWRYaARAtVKyYXQU1QNpwLd+HgKlMEO+Z/6evOHO1gsSiWQJ0R1rHgPZdmJRC4JeGjmjM0f6XYFa2rX1kh4UZnJVMHHrRurpNwpH0WON37itOhBxtLQrH0ffvSHgmIBmf1kyCollB4kqBIAVU5Fi1qnVyUaDY3f32ICdlsKa6p8NPdSo9//OOvYnbgnHgegdzOiABfk/kj1oXVmtCCfnHT/OrwKjQXPWS1Anf2hkImzgNdoFhtvRJW5hWE+o6FkzAhVlD/zYXie1TUpEIfBSo8qUbhuu4FFMQyi0TEqN8DyszcbTg/Mv+z1LMApA2MUaxJnaS8vnb1Qbh7Oph3vetdV4Sv8ao/UF8hDG1IUbR8tZADoROBDikBu7ZmyjUzAiyEidTP3aJglrgJvssaE+u6wAQpYoTeJdwIwl3T+moI3ATmwYUC4cx9U7sxgrXKEIxqiAdEJIWr6UF7xODFFK35ldnUFQP6jsjUCA/1t/e8kPpJ+jUuAlplhHhNrvzemLdaDDRUMKOQ1VZD9WlNCRvrw4X0YJzgTKNUQdlZuCMIIREbwMrgfRkJ9tB8nMmmJbO87HmvIM7C5jtElsVps74WtmmwBAsClXMnLPeMdwmaBF7BovZgrZRwyh02xqUROh/MHbxaAwGhd/bSQpZB74G3AreZwuGEGCLuWQSaAOLytc4bLNH+G4+AgiHXCGe0ZDEf4uEECm9pe/EBLLrShgVgipGocRMcrbTquPi/eUZPEmy2krL1reIk5oLgIT4FXNHwnR/FhFBGuCa0bzaYrD/CgPO3R2s9ZV1s7ymaYkxYPJWSIBDUKH7OCuyKw1jhoAb/1mosww3dTmATeA8GMe7OiCD5q5cCC+Vi4f3YKEPStKMpG7+1mYlrAUHb0fy1mKDThBUCqDOXWUQB7J32SYYeV1jNnUUKoV73AgoNmmYFMeW1AzKVR9swmQFtct8BYgfHJMnEDxDXTRFiK8MOmQJipYkhZ/3KSqGJKKblcGsI8tGVpAZDn/oO4PqfQlDMqtxEW4sBwV6LyBJyDRFaiwGpniBTw6C5ZQBx7WhiNxYtb/tfjYbWC5l97OnOH2FiZlwXFa0rwPcOxAIbMkzWGsZfjoAR9oxvLfW5JafNgaa25ngCrTkSnNR8oJUvobEP6vFsAKnAOJkcCHlE1jrAjziDdYNscOymZnK9aSv8mqN6INaCYPkQsJf5skxigiuUmgOivN8fBSXven9N3+a/8TVHoRLuYTLObLVWwYLetz6uOEGc4Rd3skJWBKvOQXClzwYdUhrMuYZJL83RzINll9DE3bVMF1Nds7w1gxt7gUkZg1tbuQH7CxZWIBTDIUNwLWtwbOs4+c65HmOUWBXAKK17FSXrJ/TuPjk/Qie3lsBQShYhznkR8NWpkmmzGV/2Ad6gIxvPRxAiFNkrZ0RwXYGZZV9soJIHPd+8wQhLI1h8/yVdBa/7Wcu3cVhi+50isynmCsmx5KEXYMUcVuBcHOuzhSSlzBNMWLTFYkoSocSiEzeEgLLuHSYmmQht3krHkB2S9L04B2ZpB8Y9QJAgtPT9+rAx603VBKxMsY2d2RHxR1BoTIu8tIYOlZnP3RExvczH/U+Rrky3LAuEJppDbYM6Afu6FjC8JSqQmXCCwCFo9pb2g1HsGGveW6FsTYWYqDnyza+gYu+XAGDsiAWBZucNoaTUEkAFliHiAiFpQZgh4ms+hAduIamu4jy4lNTcgLCIGY3T2sEGt0P7R7tyf1CwaU8w763xwG24fS5hW5PrMnbv+7+1I66YlDlj6uBmmcXGWK1wSwha7YkbiQZWU0sHHq3gisA7yxqGrn/Pe2ffxUSMQXDgLt25L8zZq81SkGHHimrfe1YpcMy6RoNft5o92yxDlo3dJ+sWz8Bcz+22pnp4YR09u6nJK8jASziylgoWR3QDfVjhveacCSpoxgq9GJH9AZOrFBDe7BH6a+8VckOLWWD1bW3rYu/33G8C9uGt/bTfXHYEolU+CPhHS+HGlHAXY7wbJ8hlzuK5FiHBsYrKUaRZ41T3hTf9/32X7qa7OxNC0CqeMpMoGBIu+ltWmUSRpUnr7t3YHwKaPSGkqFLNogg2hRf0XGfhzrQVLsHfDSGgZAERwwEpAzQSXhufq6W4gH6q19BzHZwMC8RJfAPEUjiLNqsQV/1gaEm/+T/zW5fbnkDRT3dg5G7iwqE589Fj2oQsDLh5K1bUfPPxKjCHSIi3AbRqCUgxxUhWYKLpCpZSywABYTIWK0ISVwGyPvJbIza19f/XaKzuC1FeHjID8JWiMUlFfCDPWrfah61wSPurNecENimv9cOq1JkpqlSfSn1DGozIvnHzYFz14XK+0pyXSdTADw2yPV0/+AaQLiMnZLWG1pn/u3c3bZc7hOWnjysYmqvYIAFxa5aVhrqEVYEqGhhTa326m6X9F0SJMZn/UWiFJ9wE/OutgcDQuckU2UDi5iK1VVYYGIG761ZqTTLUNiaHduudJX7tqWwdgd01jNTebFwVQb89bh1cePYYY8GMws21+liDujB9z+plbkz76hyJTyEEcyH2TOeldonvVpHwHQYoQwWtCv8E7veROeSKglWaBJ7vlRXOFTNcV03v11/7TDkkDCgWSPilgLEUgDvCB6tPa1GVmwsMPV8BsjHFn6Af4U9z63e3fzsDsRebialOiyrTa52FH5sZKqC3AF/VkbnujcOFY+8IyXsnTWNFz9sjZRcETqtUXNjABy5pNTq4Qu1eF8JFykW1wdOdqUrWrCbtZ/vT/1THXQFa/Aq6Ye/R9dYPF2rhg2sFuGbVEJKhtzQWXbnuBRTIirkiDjXuGTVK2sAOnfQMWCAvjQSRqUG2GuKMMDeubAqlgAW1dfsn7UuGBi3fnPUJwbiq1r9M+6rPhKyElt4RbIZhN2558ZAfgtgXVgJEzVytFxBiSiwNAajbMvu9dwK8xiYAOIeN5ejZAF+kPamfBaJnxQy1LzFFNwBvOeQaFw3rFTMjYtc7CYfVVhD/U4vwS/+GgM29sQRJ0uS9oz7Lpvf2Tucc8rXHLFoJoRWcqp8EVjEtbol1NmsqX+3dGTXnxmh9LFQxR/USEO6tLNrfMooQjnXV1Wh6hFoE2o28MpqCTYxnCU59y1SgLRmHZWjjO2jBGC4miLm3J4Qc1UddhseaA6/WlUVzBLNq29Snix7FGtFIpaEjxpsdsfEyawXiWpVuSZvuu5h8Z9xln6q+clE1jxjlZjFQNDYugrWid9Afa26+na/+XJ1A4KiP8IMSxurGLQnPg22xDq0p5ss62/cYcWMn0MPbYLffg7dcyTtf58yKoI5Gc9yCkWCh9+ADOtDz0S+W640hIpCuC4Ew0HydW/1SlNDNO+644wrOxKOAQdlQ61ZeF83ebixTrb1ozHXd/PN//s+vYI1bFIzLNgL/60qjSDkrVmrW1gpCtt/NB12Hpz0bnH3spTC1/a/rcy3KzYeCjT+UkSSzrLHQB/VO2mMwb47o7wa1wnsxjXiBirhgzsWZAsDxmnW9bp83hIBCGmPu5UOTWeJmR+a2EB3AsxhsmtdKwYAP0kCMmjx1QYuuc+cHZN1o/BCLRr0mV4BA6FmTNSZd3x2ySoR9n8bJCuHwETQATsuqEUKYeDffngTOGsGa0t9M2gQ4Ka6Cn2i56yPdGBuCBOvNMZ1T0KvUv/bJfQ5r9ob4axHq/6qR1go6Q6ja47Jcmnd91Y/Mgf4nUh2B9FkNvnkS7AQedhalJfMbR6h6J4vJXrYIhvRPw3PWmDYYYB5No+Gy6hkVGPvEfJhs09oJFYRdfXKLrM9903mXGWNe3BcJpoJv4QILkHPEVGuE3xW8xK04e4G64rR2nYIeO/MNKMToa+uOhHeEDAKVYGl3NBEW4QVrAfMz/CKQb6YDuG2unWuMQiBnH6nJ1mG+cG3dTfu7PWNRWVdZc+KaEbfVXBF3DEtcRG3PwvnA9c3UQldYgpozGASj3GuNIZB4x/A7IULfKxAv7hC4xHagDywma0ncmIS1dmCAXBiNxYpUa54EaOtXcmDvaULTnDV3v3MDI1yYW6izj0J39S/rShwJWAE/G99nzc4OTQOXmxgR3qEPLOysHh+4dGtRmOwTgcaY3EdKNLjfzKWALIbCHlg0CEDL56zH+igOeICgfHQiQQ8OuJyTm5NFHu6hFTeEgLLBgGsdYFZUZ6QDA7zucxCRTstfLQ6hB8wbcAWpEfbGdM8DM7V7WPpf35Fot2+Ey7hLkGuC/IyR1rl+2CRXNyHXMFPEHbEwDuDSd22zSfyNWCooB5H6X8AfsslM4C+297So1ag2SAyCOBfCj3ghGkBj0BLWT8rUaW0uYqvftNiIgMBEmpCYEAXHmN9X2PFh2oV4W0JdbEqCUN8RrljJBGhjpnzwYgiY0fVPkF4/95b/RmS5ZNxXw11BwCF8bBXejcVYFx7iQEjcQFznrd5Fe6FK8AY/LiOGEytcgAcxS/qqf+4c8TNrMTmmJhIYdyzEFLH2vLURTtzODa8FZQqgNCdWy2NQYB/B7ZhW83OfCGEooZHwv/NeF4z+VmCBp2u9EUcGF8Q32YfG3GrUcIziRVPfsY+KUHMXmGkOXLe0YPdMreV4hRRnsVYplilKmYv86k+mTP+n4IALZwu3ncXGMK0gtvRCCr1YDfhCaAaL6FFtae3G+ggCVoiQ8obJeo6g4toRLqMVSI1nn7hdXOUhrk11bGuQBdMeusrjoyZGsbk4h2Xwa4WvD3WV8AUKnDMQOwMfKKYEMkrv0qZ1W6qYi/6tK5ByYg9WGcQD8NMbQkBZZMFM9mZhWnMHxnogAFKmAWmZ9WODj0imm23hzgFSqRTmvTND0BAEVcW2JnZlgXkJGWRVpl7tjgQUSBIjjwFzkTCZEoT044I0fdI+IKo4CD+lHSrKJcCQsCG7QZCUuWNiCOKaIwEmv7gg1Y1pWEJdn2ktKgRjfggL4dBaa5Ciks9gQOohXyxEpD0ScpzRmro3MFrwICawd6y4ywiBEB+iCJQCfq5HV3GS4GLdCDJGq55MfXC9mbu4BCn0W5CttbDW2Kfdo81GUymSQLRBmoRNTAfjQ4RXw6KxO9NaP8WGCUjeYmzgn/sK/CwjAT9rIQAzGAjLAMKedWCDoHuueeydXZtlxjy+rtf2keDb3OCdObHKYTL1y5UID+3fWmVXSCe0rvVE0KngbrBIkBB/I3NxhXYM0iWf9rB11AiislY2DZtbluWB9ZcQyL0mkBOzMj4GxGpFkWmsxuca6flVKAhXLEpgdLV4jLIPdwelxXqdQU2sGiWFkqoRpDaRAHM9BoVbX8KpxAQ0f9PHMf5V9AjeFKHoGdhDB1l8VpDdpAFFAj/qMjSABYi1yx5sATZFLK1bRWC8SyYPJRlsUHrXmm9eeBa+p3wGFx63Ntospo8VCK6uIHRv2oe1gGJT+fEyNbn9FNFsQyPkEa4IS4AipQyA1PrJYiA+BcNkLuNzdXMpIUbRoZq4EYfqoDebQfwFItD/ADMhSKGozT5YTb4xjzUzMJGa5wE9BrvvYEAEMxkn6ie0X5BttUNAv4RVXIcbe5X97/m0NsQTYtGOaj1fHEkNI0OsCU8IKbfSWsNYcpq7+yOyqGDUNKyC6MR5uA25eYbYhME1SRPqmt/GHlkvxiW9kaVhCYmAOD5xGiUig5A5Cx/ZYvabz54wZP8Re0HJGB+LAuKRQNv/N1gRI3R2gucIhOJiFv64IGhOBFpzk5VAmAWLNRql818rEHzefalt8PUG7RpXrAQiXlvLJGvDzgEeEi5rBGCMYa2Gew7OVPzaBiNjMtxtGPOmVGMU5kbAw/gIbZ2FrDxC7QYPL+0iuBFWCDassBg75r7WJfsNF2vufek9ioKz6Hf44IwocPBC9VtCJcEE3WUh0jA8zJILjBCDPq01tr4FgK51FXz1fONRFBqTMEkgJnS4TgNtpdi4uDK6gaZzSaJlBA1whVFvogJBeFOVZZviL4Qx8Ves+++7rI0CD5wzYRqMgGNl9sEcJYXVl+JLqLMGtBW/8mkvxatYtzHgacrUPgcf1Nli2SGQwtPrXkBpkwEXE3uMnSDSxtHwaZkJLIoX9X+ZQFKk3PqIgPJj9nyAmmulMRDozLwJRwQOB4JZIYyrSRIG+PMwChlIBU26ebjDbI0F6pnLAgvTLUkageMmqCFmbqwMSGNYrUPZ95Cx32lWTPUyM3on4SbhSkltWvPeE8I03k/ZM5CLFtdYhB7WLzfMIhQbiFjjCkBM+7AaWSdihthi/iR6SNpYGO6WLt9AZdp/8+/G255r7d3sqfYFARAiZj3J59szWxSM71kcgHUw9/de66jxdSvWhAmIz2HxoYmrAIoxERIJtxiU+azVkOCBgLZ/jUODknGz/98A5VrjdZ7BEi3fOsDSVgbedFyanEKL6wcHVywezYsSgNhjdIRF+7kWFHi6cEPQX2tR+0WIQ0gRbaXWe09/zkXwphgrignLRw2hx2D76Ry5/AjihIj2cq1hsiFo9wKg785lZd09w4opO8WeCWAFU+hVZ+EMWFVYXvSxLh4MeN0QG+sD1uBk73BNb8wJLZ61U0A9/FQVd2sUEX6kCbuUUTyYgF//N0/CEaEv+i1mBV1zFvWnivSmJ4NLfW5bAa1n2mMlIVhhuZSWDmxQ+94t94FLF729hJsETPvLc+Bv7m0CCsEaPrCG4W8EPbSFULbw2f9bi/PuO8HqLIMKDKJFYPbour3uBZQ9JLEN/JQIAp8kZGJ66l3mUho1pFaMi9mdhujgN1Kaz5BG1+8KPJGU3V/BR85K0pwcOgGJhgAZ1lXEfyjdjXmYlkAbMneM236sOdIaNh4G0G3k+Fo7lLsmPAiGsgYaD2sJIreCw5pBET33yaxgVCNEWOsyjZ5rDyMuZQ00F+XwCU5cQe1fDLRzKcDUGSCo1o2g1BBM827MELG+ZBitEOTDUuJjHpgzosBdwmWTYCOQFMwRCBpfuq40W7fHrgbMbUIL3X1mWkbkWDnWBeYcEcXVWBFGcCQYeNe2cHM0Wx+tcBvPUrP3iNe6ono24UFsT2NsQDghhbAhKJZVAlMwho/xwRjBfWO5embjKBZnMDsxEaw86+6s2QtWHiZvxcpYLgk5tPGNkVrFg6VAOunG6iz+EuLBMvcRwVA6s9gvQg5hjKa952Rf4TYatZbYvaCQ8EPYJhSsyxCTXFdDa2WFaA7hCLhb66X6JQJw0SO3vFNgmkcCCOFCmnTvuh2ahZQAwCqwwqJyB0IHZA5RcsBc/azljLDHYoFpozebHKCS8UfOOjeekDWP9dF5sKashXeFTYoaCxHhyjNwc63H6BmBsD5S2rhxU0b3vicxN+1T/18+sQkJ10xAKdskYntsf+Ev/IWLF73oRRe33Xbbxatf/eq7/O/rvu7rLr7927/9Xo8FUW0giwmT7l5YVOt/GEAAGxCkMbAcuPJaSXzICeBLUyYkqFGCIDBPy0fnNuhwiiHZIMSsMI3Db4th1XfVYuXy504K6Ag0rqxuPQFBwAVI3KGCAMSQXYRFs+pDk0UQSd00IRHggBbxy5za3PgpMTAIRhOSycHMmg8fYvYMLQGxaf0JDbKcVqt1xvzcG/zJXdJevuc97zn1Eew1XhqvzKNql/QzF9I73/nOq6rCm57H+gZhVwMptTiYSWsoldnZsSw0n/6niuzNN998ut7AmrgawShGunEYzSFByxm2JxXlQ+A26t7vaYeduwsuESaWDYxva6TQ6jDI/V2gLK1u+6ClsxiBWZYgsKuGTQ2MKbm+PykU65ZgoXHGq6HSwrglELmFbUxe3NBmaLjrx9yMs+4fRD+8dScLwUMF4b6TPq9/F/nddNNNJ9wx5saG2EuWEG4jt6yzfIJbQi+G0fzc8kzbJljYS/Nn7bAfXE6EFzdqO0cpyawrvY+Rmxv85l5yVjLN2hOCgYBPpdDrW8Yhpq4/Z7EJBFwr0ZvgySWajVNbzX1jqiQ7uGySRZa12xjNRR0XiiclUIyR8vBcyIReMRXRj87bBYdZQAUxwzmCvtg+VtvWK2sOT0IXN+6DpblGoQZPYEDwLoGKMEZwknG0VrfoYO+xFu19YRubAm6UhDAvVv7OMhpUVmPZbu1X5xS9rQRDSmN75+4tsUIE+GsmoLzpTW+6Ar5atQOe+tSnXvzJP/knr7772q/92otv/dZvvfpb5sC9bVKxBHkJzuIzVZcEgXM/CyIhNVj1wYCZn1ScgxoYmGeHFYAyL8YkXDKIicQoAy5xLo1Dmuzgm4PS56w+pMrm0bsdPHdM7yfkSCVrvhhlyBaANGZrCjBYC/pAIn5vxNydFBFgwoZ6AIg54DoGq67A03xL6YV4JHASvqBS79MgpJyKcahhGIg/IpnA+7mf+7lXTIpg9LCHPey0LyFGwkeCSsSCW6H3+5+CS8FhdXFCrObUnnN/MburYGkdrFQJPhFNbg/CA+GJCZU5Vc0G2jqGx7xc/73XXCLEEbyElM67mhHKcduPBOJ+9mww5+wIOlwiLk2LIPJhEyIIElsJl6l53SWERFaR9U3v3Uo0UKZ1Lkku0xVIjCu2obYEGc3AaFkTKBzw2t9cSBjmBnmDNbQBo9x9AG+0/+AxBaT3EzDBmdRSQkPCqH0VvBkcysChbcOjNf8zgW/WDQG1/3X+RwFdEHQtwQle9P9wHXyymrFiBBsbs8RSWAO/yvCDyY2bQsvWlYNpy8ILFrmX0VQJAgQTlyuuACR2RPrtWonE4rFwsIxjzAJyxaq5egAey6SLBgrsFI/DYt13YmFYBGv2XDwMoSK6srET8Kd3KYKbLUYxofS0luhUtFi2IMGSwsHtw8ol6eJ9l/Fn1uA71s4aq3F9SePu/ZQkGYOEzb4DHyqTE4DASWcMTwlpPRfdAdfiJF/xilecaCMhi4s3ZbZP616vwcbVXBMBxf0y2t/8m3/zpIV+0Rd90dV3TTjC/JttzFXy5QFoh9WmuSUX8WQJYVlxYRQrhTLgUqn4BWuYQAflXp+YBm1qrSgIT8AhXmHrYgA4mm8HjeExazfHmBYkLA5iCXg/28PWGAIrkU6jIWjVAPOa3gH5BtExDSP4Ynusq4bI1/SVUICICkZDlHpv/brG4vJCoBEAv3NRqTfSPodU63qipdTXQx/60Cuzqr1v/Y29vnwEgStkM8Eaw560HgRe0TCpoPYEE+95MRI0Gf1bS2eijknNeSzBiXBHxAgSNB+aJYZBk92L6FhKOouYKGHBuW4A7mZvYVYbm+Bdvu+1WrTGYLF+myvCubEQNCZ9i4FhNSP8879vkDf82BTZ9cFvZpAg4c2wMt4G3K6wg9ERjJwxFw+LhbmzuK7ARujlFhEzs25M+7UxGc7dmjFHsSWUBwL6lgsQlMttLfCUUO+8uBlrm7FjTK4MlgvnZD+Y5515AsQxM2WtTmAJ/USbnNnum3pH/c2yoZpr+GtPWGOtVUC4/pfe22dK1cZSwV14s3BnX1maWMyj9wmK5oFhOyuWWXEp3FfxAnQOzdnAX0oyuAZT5u9ZsMxi8r654JNVrf7wLgpFLV4gzoy1CG4J3Fd4kxteyAOeZM+CSRYY8TusSyrQUqYFCROsKXHNR/VawcVw+z4Rg9LEvvM7v/Piuc997l0id7/ru77r9H0M9hnPeMbFN3/zN39IKwrzk0ZogCA0M9YSmwMBaDvLXDE6/9/ibICD2c2By1ip/w5JOeUNcKPlbgQ/xMZ0EXV/06a3H4wvhtaYKvitJYckT6IVz3B3AXqQ1xi0GftFi9gsjzX/LbO2nwjJankIIEbSHiW1E0w20A0T4UtGfDB7yNnaI2L8oYImuQFYf45Bn6wEzpdWxX2G0G+MBHiCnAi5CH9m4Vr/AysaokIzlxkirglzZNkQI5LgjNE4B8y0efZ/Wg5YXR95BFMqY+dKAMes27eITgIz9wI4s2diKNb/vKnLYrQ2Bgns2LO+48rcc/Y7oWsribLoIfZS+9cFBX7X0gM+MUxMYJnXpkQz0RtnnyWYbXYQwcIZ9bM9rEnhFHelb5qqfTv2B7cWVp3TujC5PMQ9LB3jyslySkhznrvvaCr4bM5rCdgYM2e+5di3nLqCfRvToo9o0XFtK5xn+ZGowPUD71gqnAGhSj8sWAR08Op56xPjwb23FmkuLzi56b5oIX7AbURYpETAN2MeY0E2SLT1cnlQTvENrlDKgL1HS8Asl+IvXOI3uCKUSgjhDkX7ufVbGwsQWth3zQl85u5BwxfOWNEouuB448SUOGAJ14+/jYnusvxzKd4nBJR/9s/+2WmRX/3VX3313Vd+5VeerBuZi97+9rdffMM3fMPJhPbSl770g/bzghe84OL5z3/+3f4PA1RFEjBvANYx8G+1jQWAvd6cP1pKXe+JcXHJYARirRCIiuC3+kgaz0WhJkCfGoLY3wLCIHhzcPiN2V4x59UIWYKe3AexJbJp2QBzBRSCg8ydvadE/7RZwbqyeNIUEBkCnQvTBJJy9whAVvBqtShMAhNM6+eakqK8DDvXhTXUOrP2JkLdWTA/7hrXWtC+ShFXlwSxBR8RWjEj4lE2bkOcBmERIiOQSyjbJ4zdfsmsYu6UVdTHxZfWd3dpsmALzPZxLoJnFaVr3PpdK0Im15QCRfLc/+HMm1d7zySsfoNARLCW2ZYLRLYBnHAm62rBeOw1kzjYqn9WMsIdtyhrCZ/8Wt4IqzVCcQ3cIvLOpD0SR9Lfsp9k4dSv9bCGYIT2kYC02Trtl3u+uHiC59YsRojAIKidWR7DRROMxS1oj+yTrJX66ywFVgqyd/dQHwUkMWVWRmdCQWNZaV/CszIGBdBm/c6FSzlYRdF+cFO68bkP2tC8i0motD73M9rcul2CKvsE3Khd5X6uFML+z2pcQ7NYKBsjCyIcl8hAYIoOg31xIUo+SOunuNVYXdYC1XoSQKIlXEXxn9yDjR0vi+a3h95B81tHrvjHPe5xJ1xBI8GwGMjO1F1sP3dJ25cWElDsMcGxO3Lqo7U0p8YjPFI0w4EEk+bXR4qzeMB+V2248xKHySreuI94xCNONac6C/Eua50k2HTWrSGYQvfg0T1t9/sACvVb0J7+9KefNud7v/d7P+gz3//933/x5Cc/+RSAGDLcUwtKQJ2w00+AxlzpswAAwWhrYjQCtABC3QFChKBHFQARwL7LxRMA9LPN7qBYSgTZuUAwQoVBkWz5ejG8kIBvuu/qGzMJQVdD4qIQUyIwqZgUBJhZWcodH3rzIrCEhJ/5mZ95islgAQnxWWPa4wA0IA7wAzR1UbgKuCeOGRhbA6C5d0YhSx9F7QTStb/vete7TnPDDNYygum3J8yhtHyaSf0lLPZMsIABuM+jubc/nYW4EMIbt1d/h5hMsjTu5tv3fTa4lla/mQz9jEC1Z5g7N0Dz7qzbA5knGwMRgevMBQcqiW1Pew6cduaNsRoO4rOuBjBHkxVE2Jrary/8wi+8isBXK+UNb3jDiZBLueXe0q9sCcykvRZUHkzllix+KtgS61Orf4WeOu8+BFFpiht8+aQnPekqEJD1p/1OcOkc6psLEl5s1p50fZWPMZPGwngStCgWLD/RkT4EOEIjBkGYIKB0zsHwCorcxIQ67lh4kTD98Ic//Aq/CdnrelI0rf47i2iJSsmUA1VfMVZMhFAb7sdMjNPebeJAz8fUi3mKubqvZfGw9/q/woSEBVawcKp1Szbof6ot9300pLNuLNV3e0adkvatPoI5588dz7raPB71qEedmHt9iJ/ABNubhKhgawM9VXytYaDROHyCdVHpgfCv34Ovzarsvc4gnEvYajxKYPNTW6XxW4t4E9es1Nw+L/avOCdzYXnvmfYhetvnFy+z0eBZZ4JGUAbwD00mWrDRWqLvLCydh3ul2o/OAg6E0+7s4cZr/e5lY10l3LRf0ZDOpfWIr4wWvOMd7zi5gVuvGCGlLHquudRHOLkZkb+tAkob3QKyjPzxP/7HP+hzNJnbb7/9JNDck9YmBBRtLiuAlLo2or9DzAIrBenRcNucNu61r33tiZkgvj0DyETbCzwVl8HSQdDgY1NGvec6fALOpqX1PlcGgQWzZz7fgMH6DgkjLu5fAWgBIcGB5klDXX806wyrDEJes6aIJe23dRAeEF1BbIQnKXvcPo3N979WBmMqW7//a23SucXwMPcSrFwqyOcqA8M5tN8CXUnnfKvBRP+zBmZfwXdql/DjE6ZUbt1gYrAgs6Az4d5rTgQ5F2UlPMgYcL76k4J5zFhhPqe9BXfFbAmC7d36LuAcgehc7A1hrr2M8PW+wDRaONdiDcF79KMffWI6gusSdLvErD1z5iySNO7Gba3gQSAdl43YlC7MTMtKa2/v2qfmnSJSIL0bmQnqXHQ18NA7zl5aubT0CPVjH/vY01qlZNIi+4TbrUfQpaBErtD2O0YUvrOC8ueHa7LWCoAVR0Zw7QwoHwm+G/RO2UBv1uqy5nSWgWjYrbfeehLoBHq2nzF1590cWfvW9dSZBc+tP8EQMxHr4BI6NDJcb82sx4LLucwFvnofPawflp8aC1ZNer33m0e0t3fRqOAJo14hTJxL+9E+JqQTDuFi70ZD+r25dxadTXAbjQiOWAMI4BIPxGGIY4sn0fgJnmIkvBtDbw7tQ/vJurvnsO7X5o/WgzNr2OBVFmPW1XC79Qhwbo4sJj3b+A9+8IOveBfBglBCkOOilBkphs14wbDYmwSXaF582aWpG2sZHCeMNhcwQ4DG37jd3Vje/4NdsaC9m2LQ/ynC4igJ8WuB+j8JKL9lLp4Xv/jFJ2D60i/90g/5XDfC1iIK97bx1/IdAwBpbRFLzKQN5KsP4AR/QRjuINYEMQcYvCJjzOxcGszhGBCEpeUA4mV4WxOA2Y4QwyVhXcyDAidlAWEiNIDWiLAbCwBuEKH+pRjTpGiJorEFNHE1mMP6ZlkemOz0tXUzWAj839ohEGZ+jPLuHUKQTBNrWZ+5+AJWIxkIe4+MPemnW2Q9h1gSIKXubUwQ6x3NnEWuZ1jhBFojfvaJ1cf/EnA2aJmA5SwJytIWjaWwnjPbqH/WrGCViX9N7AQ9sQmYnOh9MRT1T2sWb0IAYuHAwGrOiIDkrMQasF40L2cr0FM6Ozg9pj0nyLi48BjQrPBVzI9gEfw3VvvElbBuTv268bg9cSst+CQYY94KeIk9qa/GjtE1v37GOOCy2An1Zlr3MhQwyw+P0Mdk21fKA9cdC5xYDK5KcNlZozvSTTf2gkvROUoNJRQ3triOVQ7ALrdye+zKDrAs0D26zdrBRWj+CmYSAnqmvU34MscaFyTFihWIQij+BnzWn/m44Rpcs4pwiXLxWRM3szisfnLV9bPzrLGQsjrIVNvMQ1YkCohxKaZ70/NeHeLSQ5YKWUe9xzLCDf/+y7NiuWyveADMD6wlgLbv5kjYIVi0V9LQKWhoIqs09zxewU29QfbwzdmoDeTcey/lZONCNxlCwcV70n5LBJQ2NQHlq77qq+5ifkqjeclLXnLxJV/yJSfkKgblOc95zsnUnOZ3b5tgPFlBNLwOLUlQzEitA+v7iI704yQ/AC7jQyrYprohkhuNX9vAUP52CL7BkCwOzNCqhuqbpKniZusSxEmTESi5EeqQjAmNGVsal0AsyCu7gvka0CBuNLIVdASIcfssw0eoagQPgCqQlH+SWwtjJnxsJgsfrFRtiMknzYS/WRf2VNwARkAIWkEAAtFqlbVfAm+vaL0JuPzABNLgyJ4L/BLoqsouM79Mm+bQ/9ISBc9ilLQvAiqfMuaPmYIzVVcxLHBIW2luSloLiuuZCJhgVnEU3ChiNJi/1Tvg3iQEMVubvz3HbDBShLT1h4cE995Tf4g7lYAMJ8SxhNMCPQVtCgBvXmmcBIDOTHwGd27M05kKhERYGzchYxmsmAwxH+5Pst9LQ9AR7gjuJkwSo0hLxqDt99Zpae/ERrFKCPasH3cyCcTcmB43pbNCyD4klBGYWhfL7WbxuamZUta+iJ3YgN3m1bPtt9gh8TWtT5wGRruf1tE5ZoEwRq4M7kdMPYub2D3wL9GBIrQXNhJO1JuSScJCBn659NYK7K4sVgIMv/U1ZwJMz3L7b1wg9w+GzjrGPWbdzrEWnBmzcxOjZp9ZmnsmKxQLw69cKrQs/Rt4XJ9i/tB3ZwrO1SqC31lUKAoqWKuVwq3ceckkInCyOloDl5OEBrEn3H2Fa4CzzVwSYnBNBZRyozPz/Nk/+2fv8n2H2v9e+MIXnjYsbfKZz3zmxTd90zf9X42TgMF8lyn55S9/+VW8wiMf+cjTpnQIHVIbJv0y4hfRiWC/7GUvuwoWyne+ftr8mog7y0U/pTADdIyEC0fGEORP0wpB+zvf8yIVTVhwHfcK4k8K3VoUpF2aRT/bb3tMiifABCgBUpplfbHMtM72SnoajVtQpMhyrozXv/71J4bd/hk/ZNssJQGatM/cCIhtf/Nbb6luqWoYKrM0psaqAZl6LtP7m9/85qssgiR2flBMqjVi4H2Ct0zJUnpdeSBmCWFGCGv5nAkx5rlWNy4EFhlBvlyDe/tnc2l+/LzMnv0/orSWkOauvk7PuoRQxsMP/uAPXmkyiHPEFpNIQL/llluuNJb2P1dCcGgMAgn4E7Tr7qTOgsm8NbV3hPUIZN81H8yu/3UOiBJm3vnUV/DXvoY/mH24l6ISg3r3u999er61NHdVPsVOZTERK9KneXeGrTc85A5AG1rzq171qtN8BFYqbAjuXTGxSopUcsIefz4Lijtegv3mmhWY+6z9Ds5aI1dJe85SJiutfSJU1597kFqTfWsMjDCrQ+vn8q3P+gCDuYNYDJpz8PxH/+gfPb1P449GBCM9w9KUi8ldUZ1f9HBjjnr/y77sy67wl1LV3JpH66TYiAnp03m33s4rZUO2W3v7lKc85aSsiifrufpsfgqmSRBAw2oE3eBQ0Cv61CfBh1WzvlhGuOPDseag8FtjVlhxrydpfWI0FMdkFehsOgMWPe6atSJ3Vq0tGGBhaY8T5NQJifaow4Ke109XZPR94QfcVz97KYCGk42hxlBnT0it9b/6Rp9aA29CjcAkHqu1R0Nzt25Cxh133HGaa2OKr2KpCQee+MQnnubHlShFuTWIKcvFVz+Ur86CW5Cr+JoKKE972tOuzJXbOrRjFdnfTIvQhCDSiqtWu5qGqo8BZAjV3ywIAnaKj5GxsKZ7mkJAJTZDKpdqi2uyEgcinVTgWn934Ey4mMqmRNKOVRGN+QSsctGbJ6HFeLRnjBMjqJHsNyUPEIUcBIH2D1Ps0zwAFYLVvvVd660KcE1QJo2RRgfhVET1vd8RJFoAAYWPVGCwLIwNDNa3oNjez+rG2rGZCUc3Uv0oDvX4xz/+qv/2a2sosMpg6BGWO++883Qm7mNhHdn7iWirClXFdKUSsoLJLIuIRMDWBNq6ErBZadrr4IlAydyu5ktzYImxdxHn9qpxg1cCXX0RQBu7s2GFQtS29D+Lk6q4Ypz6vwJx/PA04i3a5YI1WlXvB5tM5GCGJUjWRmdV3xuUHNONQYRDKRxM4MHJWijFSCh0Rshqv1oDIZd7jpm9ucT4e6+9COcSaDoLVZn7hCssbAkGaIS97TsCjGySiLQYiIRFfn9BxSkqrB7NrbNm5en32lpIi6cD6yxCKgq7sdmZoIfBCAtkc5MQgHH1fUy7ftXuKTi5/Vha0z61781dMUMui9bY2p1Tbd0qzZ1gBY4FgivjwJWhbocq340hBmItr/BPBVvF31hcWRQTYHqG9TuhtDGznLmVN/xWvbt5RKtbv1RhcSuEpPaw81VUsfHqt/MVp5EiwGLJwkvo6ndZLT3DatTPxmTxEk7wcZd3k7V/r3vd665iiTozsS6tg2Irvo4rWNkHruZgK2UdTU6ItZZ4W3sh3k+sz3oNwudghhuLK5fVSsxO61a3qmcTUvteGvQNcRcP5iwGQ1VUploWD/54MQdMvYJdESKuFOZYcSdcI7RNNUhontKQuRdqfOsd8gLI1ifZGA3uoxAuwiKTg/UE04WkYlIIIFl/uJikynIZiH+AaNIQmbdlBm08BylXcGuNNr+VGa1XP86E5YIgdXRzcQk0t75XEKvG3bMMnhvHXJwHZrfnV9t0cm4KwdQYg7gl8Q01QW0EnpBZeqiAtg1O5fPnOuk71pyeCX5YabjvEnwwDenMCD2Y4K/nohB706c9jXCwWvU8q0KEh5uJkCo+wDl5B5xuKu0WEFP3h3De98E+nz8hHcP0AefceGB/zdRbxVYKZE2sVPCwl731vcqXGwBJ2FyXGI1WzA9hOCYkkJDlr3HEEfRcz4vjYaHh3uQWFJ/G1J9AAz/gXXgvvTjmBVfFs+y5cyGqqSTY2H7J9Fg4FSSuBkVMo/kTYClgNRbTDZ50Hq7c6NngICGNEMWKi2503n23adhoq37FwYArlgYu5c6O69ydYtyBCQdcE+0fIRJd83xjrxtdETAl7F0WSOAQFE7hsYZa82ksFk40BB21Fi4Qrv/wTJxQYznv9uKYAQZ+7A3hD+1AR4Pz+nKB6yd90iddWfb6v1IaSztqGyeG3+GDG9djr2R7bZVkymxzovBt0oF54nfqsrAAwXmWlIQo3gExWMHP8sjrXkBhqt4S2hjIpqNyv9jANl9Fz2OEP6lWHQmMUUCVglpah4FoEHQAn7Q2QgIXCrcLRhnAy2bof2lXNM3aZv1gYAHaXhIo6JAAAckA69ZhUAcAASU9b6yBdUhXxHC3zDcNC6LZK1k9hBTxLfpTdGmRxj0umJV4E8IZogI5nQezYS1JnsCHOCCU9RPDs88Ehi0QJpBwY3dyFWA6NfO2Xue6WlYCCtMnKwOGKSXdd8uoFMvrPBBlsSb2Q6xKmo4gRPsunVQqJiLG0iB2g9Bj/61FoOsGQbIGii9i0SNs8U1vLAwtFgPbT01M0taowXg2CDSiLyCytjDbvNw6Dk4QPvjZOUrr9nH21p8wouZILeVgmTuCvLEjzkQF0t4hLLbvamyIdZKpV8PwKQ87Bnx1xgRHzE5ae/+Xru891totbEZYkxyANm6NnWAIQ+x/LGHtbfsu5gLuweHaMj79yjqh5FAQWGSdLSvMuqViap35xv/VltZseQAwJdund+FujZuYux0OqiGDeVI2W0NuFf3uedTAZPPsI0UeLaHAqdtDkCOUszyjSWj5xsyZN1fOz15a97P4sCrtvvhswP8qZntO9ozFf4sOaoKmBewThNGQDTVYZXZ/r+/oZmsQzJ31ZO8WuiEEFARNlD5kocnTFDA9goM6CCvlr4Qs914RH6ZVBamYVzOXIdBb7XABr0YTqAnC67AFQdHGEM9N6evZxpGXzhSPKAjiU7Vvy7orkSygE/NlTQmAZDsI9pPxtAIdhkIzkbLaOALJCAWiz7d4XSZNFRBpUQAdYa+/3ec+1tEnAEcoPcPq0l5nHmWdsg71YlajFwSqCjA3nniUZey7FoJWMSk1jHLPop9ZpXqWoKjQVj9pXmILCCdb/ZIgRssC56wbLCgI/AaNsvghOLRi70hnB7PHQMXWGcFl+aCNioPQ1xZD5HbbYGlZbgQvAoVYna0pYm0YiPlw1WxA3fqwg1ua9DJ7gg54RBcwG3te629uK8LA1t/oXOCV59ELlkBBwxhPjSVNRgTct077ySIgdmqtfuiWc/HTOdhzeCOge4WHo2C12q71ytZCD1hlvIfhorNg3VnZ69wENTFuxm6+WXcIu6wBLEOKNqpCSuhn7UHvNhibVQYdd+7hGeXI2cMPcxKkSdlbWqdODVwnaIm16DtKYXstiBd82K91YfeOpIblN4SF2vKtziIhibv+oy+vQqj1jPUJnl+LGDez/fTOfjb4Fb2CE/0UqwVe1S9aOAL7lKbjOH3HbWodaP5afu4Rj7/4MG42llRP6oOcTIuyfdTxEOW/hINkuVkVTIYsGy78w3xUxORuEJC2MRwQiy9Q0SnR5lIRZfDwu/Lfiz2R289E5nuAv6maCMymDotvsQ/9lPJoLszQCJIURYWVjAURAJpURwIESwgkX6KIoKx1pTFypWyqpHgLwiChJSJGaNBWS9tMK4yx79uvYlYgEG16LW4uQtvy/zKn5Pi35+pmyISR8o2xs+6AhfY9DdYZmhtCJfbAWTHzYwLqp0RUEAomc24Spl1wigCvxtx81p3XT9YCFUFlKPV/Aqg9FbtCYKutC0ezDvMh0NQ2iJN/3dyNu1YK++I9nxpGt6X3BfsamxXHfMyXtr/1OVZ4omAYA35RdtbNB84wPP0xkxvX3OHCjkEAMD5cM4YMH3CD7sFxpvq17qFJhAIWF1aL4F1RsvrFXMGUYE4Vts0DHeQCqHZOrX6KNUjoK85DVdfGqXoq67QLWFdgAoNrdZOs0O+CRhs7nOTyoXQkBKEFBAFrkA6bErN4w9rqPRaUDU4Gs1wvQgWcl7gccU5oF+v9Kh3cS1lD1s1tjc6yvopz+cRLvrBjbeE5Lk1riq9IQKgP9Vy4cCQmKGQp9RiOU2wIMmANn+OeDGeKDxMGgRYrk98ZNX5CSnuzVcXtzQ0hoJB4t0YGU12BWTWZDx2UglG90+aVOUByBdQIc33wRZPGASCg3iJQOz5tl8S5lhma0hK9LepDS6nR/FZjQfhqEWNBib1LkicNr8l8fea9z1xPIKuZi/lvdoPALb9vELRxVuioId5cVOax1UWV2hZs2fgYqGYs2vUyA3u+5t/6SDNgVrX3BD2a59H1QGjdNOxdJ+a5KZwYL012r5NnMSLAMQUfmWDPCTjEPAX3GsPtxIhZz5gHQke7wcCc9bphBCPKOhG9T3iJwKktsnV0rB+hAmPHPaqxyumfS1EWg+BGsTLOn+CPiBGEjAOm1ty8fvIIb/1jSOLHCAhgl2DPRUPAgHuUHQIneCB4KpLXHkRX9twwJO49OL4WXjDN5ctFiEHbE0qNoPx1raJ96Bdc4+ru9/akIE/nlQAaTWv+Mqq4V9W+kcmCgdsPfYBxdKKzdj0CJW+tVaxyjZfgwk1xvFhwYXYtmIR1VwewQsrWYfnsk2uVRVbwu722T+iIceBl7xQAW2sMQr4Mp9rCMTq7FisCKMsCocON8puhyfLNOsPt33xUHf6lSxqFhm89HXAFvsXhOAs8IVewvUgwan96J6vhJi3gAct7nDmrN2VCP/2tIjkhllW6DCE0Y8sRgNEbSkABDBCLCQtCtbmbEaOqHu1ofXaYEIbKKkGyB5CIBAJHoxbohpCI7VipHTJuKt/GbNQQvY1VWA0Y44GMAS+mQAvSD4JrrT41DJzVRKCm1L/WIZ9fKXySe82ebJ/Gt68bvEirlHq8sR0bG7GCw9393jOrudoTWtnR71prTP5/cQ+ICvjBDNf6tcGA1rExLIios+pvLkX7sO4L54D5Q1xn611aDddaRB6MrODATL2+YON5btfsebE86qdg+Mag0SNa9rbGJSOew1nDnRqtTm0hggmNnlBAEIF7BJC15nG91JxvjcDbGLRsrs21woBleLUWTeeO2C/ecI9yf6xwTVhlvSAEEWxYd4y/jeUQ7BGyesfcjxbLDUCmQS9uiDNj/UMj0AXWj03BVyzM+OJ6rGddWnAEztaPi+AIr9Hd+tkrBTBPNJj19khDnAOaLWBdUOZa0NBJ+CPovY+g3d0jazLOKiNrHfQcvHdWLFOUPAIpWFyLGOHHXqEBiq2xIIrRACfOWgXb2rr0KN/ohVRfLh1WYGu2HoIzeBa72ThqZ208Sw2NWsshmHDlAuF1EzLEW4nVpKRbh75vCAElRGa2pHERTpKGAQZzH422zXJpUpKkQ97MFJYOwIcxxeASbmhj3DLugIFM/OjFXyiPTnJsLAiPEK6Uz2QvjYuvVtpaayT4qIESsPH/kviPPnOAi+ArA99cpfrxp0Oa1iwORk0M/UEWyAlBMURnhMiLcoc0EE8NBeZAzHrdBjXElmBpn2h+vSOgrHFbn6J4G3OCqe7815xOS6ltnImy/uoGiLLf2igR5jJslsHQRJcA0N43hsJ5bpaMkuu1mC+mzhKz57vuNPtPIKohuH5nKamvmIdxNyAWkWfN25LrzpnViEVgLSTNX42XYLYUbGeDAbmxmyIAvpubTCKCE9dEOE4ASuNU2C+chjey+PbuFe5W8R/iRYxFCGAB7X9qJvVpbpXRVyMjmGD9YCURLIkRgKMNXpWhxV0QLLn1uzlyDwrEZAF2BmIrCA3wgTW2tVTGPlxQm6n9UEIeTtR/1uR+z826AbLwA3Mj0HMNSGddVwh3QOfc+l342PzUFJEmvlYHzJyAgvkqoCbtV0mG/icDSaB/9VEEZzaHnl1lbRUMbtrgJ16h/HrPN1573nvqRdWflOUyJtW0WeGdwIJeO/usPwRS9a9qeEetfqWciyf6qct7ndYtudYTFsPmpfbSwoc4E3Fw0pbFygTPvUPI5D5mnW0c7qDof3u88TViHiubINECnW5c5fpVLBZesdbx61pAaSNIxSRUn4BLPnsb2KeaB22q6G2EkJl+zYD+FnPAwkETFPTYHBQlClkUn9p6EI3RmIgHhIf8JFyIFALpk580n27A2HuNEVC5dbO5qL1Bc16XEuFEyp74EOZA8TR93JFCQu4d6WHrOzZn89+0SERYnINCXpiv4nliX9wXAeBpsiT2o8CFgdJ6xPtEMFyuqBASc/mmRoObTY8kDFkTbUAWCQTunepadPYxLkIQBqVKI6YBWdeNQcjbLJvOhBWJYFBrH9VLkWVDyNrYBkHR1snisGZoxGW1LfcVKXSWazSBeuNYvIvIEPSZpa1ZRpQ9BFf84ltZ014oVreVL1XvxNBb++6/ceBi8NQz4Xp/b/C2uCSCyJZIV1UUk9C3G2vVBlnLI4GJ4MllvIX4Vkkh/K2FyX6tNi2IvfGa41Ynbd1qvRBgzJdLBkxwL8nc2dTfArwJh+qZsDA132qCJExuTFAf8RUqDLOOUPxcWAhH+8RgCQKsYIRdDBt9AousDf3sfDoDdKL+wEACBLwgvLq4tTW672sZe7+LzXCmPV9xQHAp64vC0//DhdZDCG390WL0bq1ZBPmek0G09Vr023Mu9EPPCaX97J0U50/7tE87zVm1VkHbyis07wQHSlj7ykVqLVzPzTeeQYlo7GAqwZ7AgC4S6uCfW+ZlYspQrLXO4mXwLvEonVFzkILd31yUXGQ3jICyGqQUqhBewaqAIyBoszCBgLRNt7FMfhgjBKph+h08Qry1EWSBMG8x1QaIm/oM6CHlxr2sYCSQbAOuAhTFr3o2BLR22jcLyQLaxtgsY2cBQgh7R1pnzTO1JdArNKzpDjEV77DBgJirkuTNd+81opHT0mSc7DqOnzXd8tsLwiX595xy9jJraAgb38N8u5agDWhEhMyLhaTGcqWPnSPCuIGk9mvN2+ve2D1VDhshihHTnMzVPBG/fd/H2SHE/S4AEXMLP9ybwmUVYWIVMDeWKoLDUdBmkQPnxUCEMxFZ6dNS+jE6/ddWYFSJlLUJIwC7TO3u3pGxhZELiiRsHuM4MHOpm4TqTafse7fkuhCyuXKD0VwxWG5euE5r3KzBDUx3RllBuS1bC229xoqK3ghYZ+WQzbQlBggumETnbc+4cQW0w53ea8/ghnNg7dlxnEm/c485K1a4dcGDi5r4nI3ZMSZcI4zaM1lG3CfwDf5QUOEdwQzM6ht8UQisjeU3KxYhFF+RcEBZ3aJ6K4gLGhVGsGXy3fFkvo2D5mcBDMb05Rb2T720cDjPdYWxSFLIWQU3OJpVnHuRpVcFXPRfeAK3EiERzhFoKWrNk5Ak8NWa0dvmT0FL0FoL5tEyft0KKMuAaXgCO+Vfk5Zp4dLTaD8QjRByZFR3F3ey2i1fJcDhkwb0/c1Uyry8mRUrEK3VAHHkiuCiMi4kXqEBwfP7MSjPnMy1tv79rSuC8TMjy/iRubICylo2CFVLRGg6G0fTM/XDKlVDrHqXIGmvVoCzLvtnTGdN2LQXrGzNOfhgMSM0HPdozwHT0n+fTYdkpeBTR5QJgisEHYUKcFXbFGDumfqIqMW8EqbtTf0iBDvOpjIi1OsCUsOGgMG1xAVA8zIft2GDA+P4/8b9OHtzBKdrlu9vadzwFZwrgAZ2KRz2c9NJ+55Wvm6h3metAF/iP6RXOm94g8DT3lksZBLZb1osN5+9Q9QFqdZo0vonLMBbTN+e91GBE43aAGzKEJhc+LXf5rvrg98bMA+uVrh3Tn0XM4JjYApDR4cWZwRXwgOWxFWWfJzV4j2B076hxawCYAtdDffE/IAFlhiB35tpQ1hhEZYRKKZiy0Js3Jfg76PQo38Wbwx/Xf7WuJa+TRRoLcGp+XK369u1JB93aVHbOkzLpwioK5BtirWz546NvhPQXcGR0E1YAtMb87JxVeANHSTYCMoF99arOjsFgNCztPy6FlA2eMvBMrmT7hxWG5m2s+mzBBmbt/1tnMQCKPMX14dsAenI4hAwGkCu7O/R3WCcjd+o0cZoetIyaSd8pLQTzASiLvPFyPS1bgSBhHzkXAf1Yz2EESl9R7/ongdNm0ndWJvOR0iprXlRmlqNCREh2qDQ3Sv/9zdijBgQ8Jwf0z6J/yg07NmvkLoZDDUWBHtqbczr5rnWnp27/mvtzd4ejTAJMOTuM29uRYRWf4jIUYvEaAjnNYGt3BBq7Ow9JIjTVvTFVDEWWj7i1fdgSzAx96I1WSfir55E/1u37VrrEDZwjRHItgJnnmcdYZHb2BJaLGsAjV4WjzpFhBZ40LtuWNYXmN2CbMbAEMEyS6f9pd2KC3P5YM/ENOw15qdgnj22h/YBrXGm4BDtkO5JcJdRQpDrf1xT9vr/Ie9OY25Py3rPPyjH47E5aqfj8NbEqFEUEGWmZCigQGUURSGiGCTEEaIiBqKACUaIcUogcQTjjKLMMglVQDEYcX7Vib4ydr+wQx9FWxw635Xns/KrPxtPVTclsvedrOz9rPUf7uG6r/F3Xbe1sjfwClY1hVX4K6OwfprDpbfFWtXQFy/qemxXyTMGDS9Y7/CGevEEdIsWeFms7YZG8XXesVUOGTkMtVXANsy3ckS4lTKwoGlYJzwD4NV7MkYoCZ/92Z995vsLfEe75mexaYyPxfbUZ9VvV0kppMs4dV3P3OQFa2Hu1WJZIxeur9/rP3mMFxVKwo/XMLuqFZR1n3NB7eTmZsIEpNdhirS5tazXk1HD/C3oMQzUM1RaXJQ+17cNGtPv3wikfhAUrO6ja7nnOeeB9cCVxnIR//cc5x8cs0EIitoCrXpX7mohGcqJ/iBWVgqrpPdsyrWaHEdlg6WOiS0Q8VgHBBELn/l7lQWNQsGNbv1Z/5g2YQgvZEM7DZUlTwiwtjA+zMI8mgNzjwFs3RlehYCa3MQrrDYMxno6jmVj6xhxwqp/FaPDNOGn1vOwHobjHuHSpxyh79qGASlcBL69wZu2ysNmowkjYVjScikeXN71PwWr+4G/AWAx9fX8mGe4kvZT17af9Lt+ACGKsRdeqnR7peZhXNbrZ9xoUOgL1orREa3wMsIPCFvFU1of4MwFKVNs4dWst33ac83dnv3DgyDWzxIvZM1jtQqjdaQ4dW+YtG39Vj/Ng3AnPoeG1nOqDwsyVgOl97UOHSBKYeLloFhTWFncKXcOcmV5C0NFF+ulbI7CxAiR8MACAPM6MUpgeDakxzMHNIoPek7v7aDHzodT76l1RP/e235m2DlrR5bKnia8XiqhvZoxCqdYQ4py36eIoF/r85d/+Zen5zjXa2tM4bFbEkDIRwFQHvwFUe+xJbCVgYujewkjPIcgDeTceqq8g1fNAYSUrfrNG88xsErNNaGgsCYAVNtIMaYmvIkNOBXzU26+32NaCdmEc/eEyGaZ8nxYCO/ggaj1XMoDq4MwrNlkmgVlzdQ2HLOpbOtSld/POgO8lFkk3k4gdY/TaQn/o2BfXEjj6pmYKCXtSiBhChVlR14/Tdi/+1xMf5UT1hptG/ZhgWwEBoXM341tXZ0EZPOk3+umpMxh5OZS0T6CgYKyHjTMg+KwFkS0ArvkXcBnxgCsux4OyvAqVK4XC+b2du2OiXWobxRUjMpz1ntCkeD9ESqiBPBC7BzJyui3sDYyPXhneB3RE8Yn0+ud73znOe1XDZSuU6COoKkf7csElgKBBLFMnZ5rj6Npa9qcS/UmnHpe+7pPz0oxca5V4+SqBoTl9maYsGqbJyefZ/ktsLKxwVlYo+Ypwc0rY8/gOdbAPdFHwELGB3f/evJ4X2SXxMuc6WM/8A4RBHskRfuqk2oZIIwcRgf8l/WI/lqzDiU0D+iG0LfP9TeBngIok4m3mhcWIFlor4+aVI2Bpw0OSohIyjivUnTV2FMenJvjvhSx5qhQRf/vuoC+rUnvjZ7RDg8wxV/mVGOgMAvH2YN4eP3tOa0DRY+R4NRr129YTLYdXJE1xus2JL0eGN/93aX3pffisZQ/vDf6lF5PYWEkr2yRKWld0XKt31cZxJtghyR7hF3hcaVwCBFKOmGkyPDrfc5Ww0evCQVlrVGuWFYPgmCZKErGwmriEyJ7NseGMlYxWVDlAtxWy6Ro2AjbtwXd0bLXql7GxMV9TN9rHBSU3tnmanwsUh4bLlibcHPhvctG5BniQXA65grHCN9962akCdtQG9c3bvMplMBCxKh5ZSgomKW514+eHUN29EDN+Hh6eArEeIUWPJ8AYukc8Ty9s7XtHRvqgb3xDFgJa1HDRFj+AKj6iRHxzghZsab7jcucdwRoeF3Yq7Ry168XafFNYv4s8hrhSRiu52hDQ5RWQnnDg/WTy5mCjCnymthjzTOPGYWs8bVf1GFovjdUh/miH3gFe6F3OG7BmFnHwmSsuvbIenAos045r28bHkDzWwVYX3k9GBtCNPXF4X89a49PkC5rbtfbtOE4womhA8AvRb/fFk/He9m6M64o2fohjKDfLPdVfgk5obj1eOFVjC10JHRS67lZ3TwX+AMAMaNRWNd1vUvIZRUkDS2hDzTAM2zv8sLg1801RQggeg1HNYvW4GRwwY2gbXNFYRIyJjPM8/ICPBwt4QEOXvQdhXEbXsxDjhb+dZQLHkt0up4Ye42Bas/z+noWDwxl0noda1EtDm4NUcbAyiI8CX0vWBqPXrzQbVFSPq4VFIx5M0Ei6rTNGCkNXoVSqX0RkIp94v0ImPAmPAgqhMKNth4CDN2CLWqcgERYcu9rmP5iEryfEuQ9MVuE07McqkVBkXK8AqlrFTjCKAljStTOXZuvtDqKRt8DOtGGac82JGGP6GywjS/beNyZNd/x0uxpnTbnYoJY/guyZaGy4AGymovoQC0Az2BhEoiEtFh7Y412KF+UF+tIeeXyX/CoNVe/hDBZUBhaWi8Jd3RWouqePa9nYCroEZi1d3QismwOytke5EhRwSQA+AA8KZRizgSRuXWGDNe2cF59VAGT14PrOWFdNc88mBrlpd8pCP2bYGv/OYhMRoWPPYARShtvDOpoqPLZ2jcG9YmEs9RXoUhJqW6d9WGBtLBT7QGK/jJ44G202LNdawyUH97M9u2Cc7m6KXL2kbWRrVL6K0Buv+UZ2NAqz96Wbuep4oHsHh4vgksYt3GpkwGf0rqq5SRMuB5DvE3oz55aHmr/GycPFcFsXy2uo8biX4GrtLzw2GahUWrgHepDHhZnKylcucBM4Rj8h3JPQaxR9ghbBqwxmGv8g8Kz3ksCGyYveuP1pFCu4m/vwmwIG3/ipTLbnGzNFcqNsFz9cXYbLBLZyJPDcHNcCuWLt4ZMgBfTP+PYuRBKN1b8jHyKfhk4i99jcMAtXfUKCqER4UZ8CW31G7YQUwsv7NCkRfg1J8tScuAVWGEmnhULjLro7DbCl33Zl50tnL6LgcYsq5dRHDXCWu+EDR6zzB3dphJLtpBdD8BXn2L6bTxgv+6L8LnT1CIggHkMMPEE2gLAEBSrs/FUQ0Bc2AZW1ptLkFeGEkQAaL3XJtGX3IL97WjzxiEzIteqtD3n7KwHp2aNGm/vazNuSKhNsSDk3td8+a1xprCoP0JYsCCtay7iz/u8z7uFkgdcRiioiFkf6m90xcvEwlrvCAtWWIFAZJ1SxBJ0zY9aDeiEArWVRzcsgKF3T+HL3M+wCiy8Ws+J3hPamMuGFNGf9GzKF69O44ymo7uer7WGLMrG4mA4ZflhEPa4BKDyxsGTp2BY9JDQ2ZBrY1D3h3UbPadMrqet50df6B9DBAjs+dEGd3hzqER3fe+9FMOeo7Iqa1N4pHejEVlQPaNrwytER61Fc9lz6psyBITrXe9611NfeEoKKW12SWOv39EsvBQalOXRnBDUfTYdtrFHt3Auwk81wmqVfXyuMTKqzC1ly281gpHHWphOY3XzKCsUBr8gi2nxXgS9kDJFs73By43ehbR4N9DsKkn4NyVAzRBYCTgKymfjU+3Ws44ZdmiaYKYMwD+u8SQsHr0IaQFSryEMdyYMWoOzueOAVXm7awze9c4xPjcUup76XRveqL5ncDBCeIes/wK/F7eG3+uT9a6tcQ20DVMFm3PVKyiycTAg1gTXIzQ0F6GJWauOR0UFTBbsWp4IxTkxrJ+Ef9dWsdEhc12fYuJ54swsofViYJpih7RxFtmmrInPbhooAcSyBOpcSwRILGYYs1zQZk3snMs3RskzhNgbmzM+MP4FrzZO51RsyIr1G6Nk2RIQhCSBi9HVMKnV4FnrspeszQLiYi6YFe/OCpINZWCMvCdqzBDA1tJG5bK0sVntcESsSMrZeh0ozIorCWNtGFEhqJRnc4sxCt2xRq2VDQ//ofgTkCfX7eIH9FfGCuW896Ev3pet95PiACzYOygKFBQ4he6N4TkVlfeja52DVMPcKVn1PWXBJ0WHcs2SF4rgRWRJAlgL8xobA4bx0XOduqtGUt+Zo0299vyuI2QVmKIw9A6CqX+blz5AvL03JQKA137wHifi8twQRo0nRXKFCmXae1oPdWp4ZKRy4wGUQKFNjeCxBwhMY7RXCcD4Wf00r/ro31WiKUy8p33PMKP02z+L99s0c3t/Afx7ECl6XmVscWL2nbojQm/NV/Nmja2h9aeYeA5jTB/6OzoStlxvd7SKTy2QeZUW71rja5vfKQX/chm2Eq6GH9H3xZ7tM1zDQ+eZFAzy54i5YZSbdx5u71hIAnoy78a43iR7j4KDrq4ZD8qGASLArGYLGcE4GTjBiagw5K7J0olh8bCoNcCiiCErbAR8BmiHOBy0xdW5C8JioOwQxOLh/dvfKQUWdgFZzkjp4KX+D5wKC1B/YrCyCQhlm4SiAUwG1b14GRZKBydC6y+QsOq7hBScBM2c68/8xszNw8Yot+jcbq7Vslf49D4nOQvLcb3KfmguZB5RPjfzghLAfapUc8/A5GV1YaStIw+azVazgaOFu9zlLuc4PebHu6NYGC/bsYYEbADBR4BgHOhOLHlTY6VFo11WJoXW/Kt02fwk5LhZCXGuWs8/Knn2jqqdLKSud/KtfsuekKnCq2U/bHGmxdM4/ZkSy2vWs1QMVQDNWUQYKEuXx5CHiKBE986z2TAgsCYrTohk3e48BNzs9lxtww+wKJizkJiD2KI3CvV6E2rKh7tecTfPEnJSCsEhcELWzZ+Q4GKDtuZFH1gMcyVsQPDIxHE0hAQAmAm8UAlzcy3bQ02g/t6xUMTRvD7yxrX31MbBS3pPhks0wyDiQbGnYUwWA5Viy9Orci46EN7l9ejZrUe/4eFLS611z1/jDF9WVLBPIGohSQpdcgS8gOLPqFA9nKK9npJtwuIKtf3r5d7Dw+A7+lca8/bTv72zuQogDqSL/npu8gZGk1LMY2r+KIqwY2iX1wwNU47Xi9k650FMGewdi+HjfbrVMv7i47ghZJp9m4sF1iIneCM4J2AKFXAxlsbVRKoCGNEDaLUQak0suppHhnBokcRu60/vbfFr3PuwDzwpmBcviSqCtNcWmQXfM8skSBEiDMSHG2+bsv73TlYzoquf9UvtEum3rsGEI+QEb7jZ8hAAAQAASURBVCEArmJMEe6Ad0kYbK0DQrs+5s4sZMXSYT1SToQntk4CooXb6PqsthTEWn+L0Xdvzy++ropr7wBmdCZS/aFk1f/OT2k9e0djqPFA2DwwCzYdRYe3ILq4733vexqjjAietBS5PtEUxVSIhMVQP6O3/hZisLlZpMCdfRZQ3bukfVofIQO4pphj19QHQoaiZh1hiZoj680irQ/NUfRoT2DcXS/U5cwe82QuKWX9Zn6Uk2cVygiiCLDw4TUolW94wxvO/VR7hALEa9D3FCVxcbF8mV2uhZGJJzS+mHT01XcOplPfQijUGCnglD0Ktz1ASYdr6/uEWMdrRHeL+xIaoTg0t42b0lZb5RduJ+HdfqRAwMIAbjcWCpl6JPgHIQWbRWGwl51fRcgbH4FHkQUObv85PJElDW8ilGqsShMQunhz72RRmw9hwT3Acj1x9mPv7bee1bz0rPiF0B3lc5VN62jM5lH1bCFm4ecFsDvbDb9NGYE14sEXOgIpgG3p2a1v+8M+jQZ53NfI7pk9Ox6xCtGHLmXWAnjxlQXpwjoJgxeu3vOdGlPe/p7deKIBnnfhQ3zI2i1kgFJrf0cHzpnjIaoPFF6ZZoDo9hQD+apXUKQQCy+0GCYxj4F4NiZSY5HYiE3u53/+55+IKOIR222CpcQBb7YIXc9i77qux9y5KmmOLe5XfuVXnpiFrASWXgvMsqeNsjzVKGGJt8jSJRFnm96GrG8PeMADTsSCmGOQfepD7094hZXpGkKcJwNhij9yE9bHRzziEedN0felR7aBenfP729xW4xPtgnke5icxfEA8mF+zemGfGISfUp5dAjYTTfddBp/a57ClpLQNVyQwK28UAvW657SDuFuuHxjmH/+539+UiwaU/d+yZd8ySm8IJ2wd4i7UnjWM8Xi7fnNazUSosnWro0a4/zTP/3T09/mdYU85bf5VJW05zS+xXaw3NYTpIQ0QN/G4DFo8WnhGyEazLYD4oDkopsEKiFKOV5wJi9dzXovI9LPaCAaa80oUzwjzbt56xnt1X7neVNKneVH6PIUtr8waMIFfsf+VVa/NdxnUeqE5Y7uduN0Zo1zYCgx3Vt/GzNgdvNkrmF/NJ648F2UqmitvkZjDlOLftr7vLQpHH/yJ39yop/2OoAvLE/Xuj7aqr+AoYt/Iuh7T7T9yEc+8jSfvfMtb3nLxdve9razsiDc2u8UxeZXvRTjUSadl8Y6N9cZDg9/+MNPv9fvxvDGN77xNGa8zDroY9c2nzwzjYXHiOe5fjRHjSGPcjz7Pe95z8XNN998mtv2j6wd2Uj1TVIDb3XjNoeUEutAWWxPNJbmrnXoPfGJFH8n+eLlNTTIYMmDSSno/zVe0N7Xvg2DlDK7IeHG0Xuas2jsv1563NcQAkJtHeq3wxj7O1oR+m2cvI7ov9/ipc11rX60XquA/tmf/dmJNuMVog/O9IETUyV2PSIL6Ccf+o3hGg+G0WxsgcCvegWFFY4x8Gq0IJgK7U0pYV6APtddd92JSNY64x6E+Aa45FoXemFRsk645/rEgKXJ9f2rXvWqsysQwFZcuMUj3FjU3dMGJABiuhFGBNAiU1AiopSOhBl8DeWgzRYRNQ+ylRoj8B3lRxGg+tO7HK5XQ1yrWBHgPbvN2/NhV+pnCkuMr7lrXF/zNV9zDsNgRkJhPDHNg3numT2nee3ZcEIxjFoMor/f//73n2tNNG/NQ8KUsIGH2HCN+je9c92tsgWEjBbTwOKv/xRI3i6MvGf3G9yALJz6HLOLGcXcGl8MC91SkilZQggU3NYVIr550XeWmHoQm47O2gE45SEirO2Pxt881+fe0TX1jcILENp69p3+KazWc5zfIwQiBEfBZonHBI3XuTbWSGwb9osyBUjuvsZP+eoeh6jBcagU3ZgokauUwPmojMr9Dqjbu9q35rfWMxp/z+s9AJkpYPgOpbM5EmePRvCL5kEYoesUkIt+hS0SFHnmKmDW/KUwv+IVrzjXcyJkWN1qHgE8N77+r/bHKliwN/WnceXVqd89+x3veMe5PgWjgAJnLLwEjT36EQKh4DqMtXmP3urbF3/xF5/WJmu9Qm6NR2jAvthKuD1LSBB2yD7CM43Zycv1OYFO2Wv/1Udn1wiZRauwed3bXm++m0+hZB7v1qm+3fOe9zzVx4pvNkdvetObzqGk1ofXrXlS/FHaf3/z8KziEt07rZhXqX7Kqqu/0RUlJO/HZ3/2Z5+NgejTIYXwkJIbhHjJBjKgd7U3GFg8ekKSlM3lPeSaPc0os1+EGRn+gPV+63kO5RUC6l1qh2246KpXUNLEDLYJYy1x0com4CXAVFnxEU+CY1N6N3Zqc27Z4qx6WBWV+YCX+gAtIt4YnDg06wp6Hmoc2BCoFhAX0SsKtBkJXRvjj7AiPCGYI3AKOJfQaM54kGIkXRtjUrafguR9cC7dF3FjhixNwFYYDdYs5DYmJz1vvU0bColhAnreeOONJ0aSpdTY28yQ8LWeUz+58cVkd9wwQAB3fR8DrXJk7+m31pIgEcJxvZNxawknad3q6RBMmCHLUyYHGpH9UYOzYYUTxIrQYbw1IEvKQtfv2HpPFhMcB8wCYHVjIhQpuo0B6I9Cz50tDBQ9UvjrT/RLuW+M9TVBSHjABzgrSIE2z5CGLIRBsUM7PTO6zOLiTeLdEAevz/3NcySskGBZPA3l1V6XCUQZFvtf4Hv3S++M5nhP1WlheFCkhc4oU8JjMWb73L9SZBkBgM/6EJ3VX97QBFKtfebEXxaykC9aZkxYS1kpCxitAFnPhd3pO4cBOmE9HgLP0b6orTey9RRalubeWhM0QN08HfUrWu3a5rJ573nWjMcHvoriCEyrNED9RWdCP+YNjoWnrT4KXzVeSn9KRnsEn+1dUmu3WJ8wMeW6/sGA2HfRtFReHlTGQPxQGBEmDI0Ik2xIUNXVxUbFM+q7PSXc+omXnn+8h1cjGm1s+HCfvOO86Iutg4mJRqWxy87Kk9E88WwIP8EMNZfdJ1QK6A7XsxEKqet9r8J6/UtRJR+AuG83BSXh8aIXveiUPhtjeeUrX3nx6Ec/+vx7HfrBH/zBi5/5mZ85LXSWwUte8pJTjrrWoL7jO77j4tWvfvVpkR/3uMdd/MRP/MRHBA99pEYjbfBchNK+VDe0mU2KmKEU0RjBMjE59wTPAhIJRi4+LsUVWEI5GAevB42bt0KlTC5UGwYINWYVUQGdqvHQM/Wr1hhUzlzGQRmAAWiMFIIILm09oa/WAnDs5s+zdBMMXV9lyogzxsez0TsWINjn7ne/+zmrRjEs6wQTwWO1mSoAjWKU1k55ekpgz9gD23o/JsvTQwFasJ+NLPsLFkn2QX0VOqhve3KtE2v1uda6rrXW+GIq3PJA1DEwlX8BUr0Xw1aIjxW59XGkskqlBszNeux+wDmWFQ/JZnHUl+7nrt9MAe+hPC/guIa20d5WSjZv0QiFrLFsxpQQEYApvAHFgtKtIFp/U9zNt7R7ewm9WnN98w7eHqm8zTHGTOnzf7WChMukp6qlg6a2ONdmSVFaZTSpJSHtvH704TkDMoQL415PoPf/+lzjEbB+FJQaI4BwVZLAXuq6wsLCg/X/eJRE9yaQHK3huAwZb40jpVYla8om5Trajq9TCOxZ+wpAPEUjOqRsKJlAQZF6iy55pno+kH19ErbDF/oXkFo4vjHITGn9subNU+vFG0DRiTd2L/4BvM9owR/x6saTJ8N+gCPkxej/fScEQonZwnmSJOzxxoaH87bJ1PqUy/sS/MkEeLCa+VUFPGWz3xWK4/m2lkpxwPUwUIQo6+d68clE9FS/1kvNGySkLryPJ1PwGwu8WO12VVDaBIEin/KUp1w89rGP/bDff/RHf/TiJ3/yJy9e9rKXnUIBz33ucy8e9rCHnbQortMnPvGJpwXJddZiffM3f/PFt37rt178yq/8ym3qC+ArYBWil17lZGMT1297yF7xvha0T9ZDLsN73/veJ8JIm43gG0MNYKyGYG2aBUISblxsaafuUUmRO9QGTfhzqUZICsv5W5E5AppHx3kbjS/ibfwycOqXGg6NA1KdgoCJOlOCsrfKw+bE95wsIUqc8sqNpzmSJtuapJTK0+ey3fRtStCmNuYtQeSFRPr/ZkGI3wPLNqbCOgSaMIGsFAKSkhUzybW7KPveKxRBKVQOu7HUj00zJIi6d+fRhmvMvA0yMGSGoMNac8Z9y2PQ2jV3Qm3raud9gxsCFI2OMPjGDpQNF2DcvAz2BeUVo8YoKVxSpvstV3NjQquAgFuZlFLSJwbG40fxBv5USDFGGv3bu80F791iUCiWsp8oFOodNadbLp1Fb49El0KaQIuscx4JJd5lLySsuK2jFXtpsSVqGhHcisJZW9lBlOq8tLx1wqKFEVjqFFweij6FBlXBbpwZhBXBE/e3ps01a9v+kFZNmLCi428L+IZ7S5EBaoQBs+aUo1rPftCDHnR6TjSWoVIItxC2zBj4BnThyAQ8urEkC6Ir2W8JfOFKfColzVowfGQdsuZ52tB8ylLzIANI9h+Ln3IVT/aOaO8e97jHiSZap/pvT6Lv6ABwNy991xU6EjKj2KP/eErrTCakkMUTm+eekwHDy8VoaR4ab8/oPfXzb/7mb07v6f2vf/3rz1lC6vPwplCU+43xDJPGE8JTLdSPju91r3ud+9FcgC0oRCjk07x0bxi71osSSiFmXG9iBg9udNI4eKcY17eLghIAqs+VWgT04z/+4xfPec5zLh71qEedvnv5y19+2pC/8zu/c/GEJzzhpNGG0M8aT8DUfuqnfuoExnzxi198GsixrTVfU48gImehtPCAazQ+gB7aJFc24d77uYNbnBaY+y3LIiZB8LK4eiamKQeeVbVps9KtIrJCKSweGnMbSsaBszy8p40KZMsqh7egMNCa2zDhVWxSyljCK2bMuwH0JbtiLRGCBIiS4tA8RZz1L6Fyv/vd75zFEAPLA9O/0ovFyGVD1dQfEK/s2YtQl8KX8gDV3nN5FmRjtV6YwBb6YnHBD1CyWCisx8YC8ColzrOiG2l88Dpr8cA+9HwplxQg48AAEyIxovvf//5numv9WouYVptbDQ4eFEy3triG9dTIhtq+pUyz+nhohPQwfMJbCi+F0DictMsqkm3AYpQWjx5gegD4CHkWEjC5UAt6YWn1LIo1az3abN7NZdc2Z1s7qPHnmZNdBeBtLWAsKHOtq4P8eCu6jhIoLNOzeaYoOGgLvdrrjBzvtd+b49Ydo+fJkSYPG1C/E459WO+N0X6glMq0Yy0redA+j8437GC+8QAeLR4o58zkbVNMDT3Ux2gxwRjf7bs//uM/PqfkxrfWe9PYAqs31q7vvhSn+CjsmHmjRBCeGSDCCve5z33ONNizUyQVoZS+HB6H8lE/u28zzoC4KbPJgq5P4NYPIM14+JYMSIEQ5off4/1pXBmtFJT1kiUb4lHNQffhTRIoKEvxKp4KMIDWhtdQDSGeCZgoWBLZqF1zl7vc5exRi//iTa1j/cZ/hNPhVcgRe5knlDeKAsHr03XorOcy4BlgsIjwUdEg2WQf+7890e+qlDd+vNkZZdHNfzgGJc2yybz++uvP37UwWQuhrVNQ+heoUev6JiW09GMe85gPe+4LX/jCi+c973kf9r2QAWtrszQWeQ5YxzrhFo4QIiSlfVt89ReAfGjvLOZ+4wGgIVNIEHqNZe+AJcAq8VCWrE28J4Zy3VFEuOwIeeMRForA2jxbsplCp+9iqIiXW/VKJysTSLxRwlLSubm4ue6l0xGcW3CK0LEeMBY8PTYmq1B4wpzCCjgRc1PBKQ4LVKzt+Hg3vHcLPVESuM65Oymlm9Eg/GUNCEUuejQlrdM6ba0SXrBlKDwcMArc/pQX46sBs7H6ZQRZo2jN+tcwpi1C1pxQtjzXu4RHCXuePDQhTd36W/eaLKE+jnRHUzvH5o5Cg0nuHEtVZOmz+ilM3bceKQzeGgpPuZ8XYTPp1orTd7zE+qmptIoIZQn/ARDkwUFz0l2bPxa7dUhICgVIubU+ta7tu5QrWYMZB2L7MkRYyfUfVgReBR0K+wjpULgJ3/ZVwrd+9j44vA291qR62+cpFNKM7dXalmXA25oPOA2ZR7JprEd9sDfwSAKbMeaZlHlrvAotftS8bfhBTRF1bXh3ZEZGdwDfvIM16cyKU/YOXgwGkH2jMrTEAXOHZvEI6+5dDBDKlpD1f7s0GCnWkgZ6h2ro6F7ou3WSRowvysiqNY/H1HqeDiHi5glgurHD1/BMp4SpT4Wn2qOUIHIV/+SNR3u3tn1UFRSx0zq3rb/91r9bKvvUicvjxl1zbM9+9rMvnvnMZ57/ZlXXCAGM9Zhmhzj9H6Pp7xh6BGtTWACYhAUoYU6eod8s+I0P09Zd62TOGsGEOLeImwWkBByFyDL6BcthhhQGDHrTBgl1AoYVsp6g2go9bsFVFGqbGueMD+EK1scqbNx/C+izXuKuG9dcS3KLifF+mHtMp8YzsGvCmq3xYG0fAZVtwJr/+3intYfkdz+h6lm8CwQWC5CnRH8xFF6HPhTfpVX4B0L2iOchLAlH80iRwowxde9HP5QV9209Hn0gCNHsEaxs7JsS7Rk8iz72niyqrYIsDXHXFki8tgXVKDKrQJorqdDwCbACiylbA2bHtscPbPiLsr2YF3sBI16lgReCt09YTF0MeAhruwWzNqwCb1X4Qube4rdgchI6QPXrvRBatReBewk1gsY8Ea68ZVn8q/j4NC7em4ShsAGl3z5TksE+V/CPsuw3tTRWSTGPPuYWfeOXzYWQtrWB3cOb0cam7ptbewvGD/+h7BCwgMUMzTV48fjug8GiIFkT9KTkgHdRGrte9o85/9Ck9juGgbc2hRLdu6ZnUTDRMCweWWmd7KdVyOz3NSDsD3xdYshiiFauMqgZH7UNxa4RdVVk8awAOTZaLJcZ5rma/TJtxMANrRpjGxzzXka8is/WlUAwKrhaHJtshVIExD3M2iUs1/1IuZIm6XkAXIinxgMjdp2LtY0hxKL/69HYvtnIrHYVFgkJhaDUGkGABB5cCialUXowwPrjKHNx880ssekpAwTZAhExJhvuODf9X+0LmTA2jWwapbKvtDkoXzYb4Y+5Wtueo0KxNWdl28w24YbRrG3XoEWuWUqN5+27jnQBz6PapHspQrsOmDIFlYK8CqprastcNotLJtMqNq63Dp4JN7SZZLLZNq2cl7OGQdtTBKn3rBcFk4QvqK/2uT1aQ3+sRO+oLYDdHiXwKXEEj3FYL9gvzJ9ytgregjwVbpMSTonre+maBJv5o5T1zMIU9ptUaspD9+ZqjxZ7fu9JqFhHfAx9WFsgWZ69vus5/V/ICc/ifeRhIjiF0fAqeLpV2u1P/KTQQF7eDMLGn3BdLw1Pkfmn9ONPCzjdgnfmu340X8LM9rv9syEGc83LLCuSEbV8Bk3AwrVuWy0bb14DRRhDmATOhFHsOJGlPfMGrG0tPmlONcZb8PFogoHBiHOoIGiDEKWTsdEC+kA/fSft2lr3vVT2lVOyXin5PVcRScqS/hgDHlHjefkPV1CkySX01a3wd4BD10TQ2xpUwtD9t7YRTmJd6lr0b96YrUzIytk0xBbYBm2yAY7WTblu4XWn9jvChlru+5qce+8ptmmT1Li+Mco27FoKjUW54u4pLiwEpU6J8224jGvcsxjFppGyOAkC7tL6CRjWM2MiUkKVg+cCttnWKiEweBYoE4RxG7KYufTTFJ4wLdD2rVO4jEBk5t3GXSVgQx3GZ30AnG2s5k5FT5ZqQOTCis4eWi+AjcfaX4uTYtw4CmGqU4CeatJfu6eY/3rCrDnLb//mRajPe0yCGDnvFBoRv2YJCgFaZ89eMPfiSfpXldUYERCkNas/vFDCOwTMZkSxQFlrNQB4FuUCbymdhBFB5HpMeuPeGDjXu3L3rF3r5LmUFHvLgZIAqKvgrSdk0z8ZH5gxRt88rEGgHIBsIFgVOB3KzYJt0VHPJHQof8ZjvSlbDkFFH81B6yKU6FwnfRZy2bCa/SElX7ZY1zCwjCXPTu/YezN8gGnNg3UFYHUYqDkgwOxb+B+eWnvU2V19b2yEvGyaaL7+KiaHn9eEUNAhLIuzoGRVrvBsjDIA8bP4vxCL1N7FmKHPrle8kDdDjS37lbJdHyg6jEFKKfwX48Ze2X3BuPvvl+FmlaCFINHEhpKXJ1sjNEf5lc2XQkhhXiPB+nh+v1Eo7AvjZXQy3FdBoUwZk5pDePvHREGJQBIMFeqikMRcwpY8/elPP/0dsK9NF0gm0FvtrW9962lAYVVuS6PhLqgNtiRQGHdcWmAgowhRvLI+9L4lIriLtSYpJVz3BIOTiCkOEX5hJwxGXQ6HUymjzgKyiIi/xjXL7UhY0doDpqlTYSyYfiC0BW0ilLUGCGXKVxsFUfW3+ijqKdQPQDYCjJWq0f73+YRVz26OtkKmGgiOSSc0WTMYueeyxI5hO4opsJ3nNxcKVCm5zEPSb9yahA3BtaG0bZQsh7MR+MruE2pqKqi3gXGsZ41wNU9oTr0OqYXwEQp59bs0XkIrWuO9ItR3fjB5Y+ijNLjKr2gXVkWWD3e2omMsH0zbfjGOY9iKQr80LX3eoYwEBQZ2TG8XUj16JygKrDeKNiWBYFMATVvM02aRUZA23KU/GC9LUy0W2DLZVzF7xgaFmkeB15FibByyxfoOUB6P2HBX9ycsuNwJGfOpr/qP1hkOG96or4FJVbFu7/DErXfTPBgHGneNdee5SxkoU0V9qWSANVPVtMb4cyxAbfcDxd/+glOJ163i3PMVC7RGPL7JIOGnrYvEMMPHAfJ5gHjTa47TkI6rHw789PwNq5r39TStR4m8otT4XbNezVF0ADj/X0YBRQ+7p7dRBr3PPHtWc2p/8ABSNBdTeTxv6wg3gEWkbK8HFA90hhaFd72s6+n9qCsoLajyvbWsyopftZghgL/7u7/74od/+IdPMVNpxi22Wil5E2644YaLpz71qRcvfelLT5Py7d/+7ScA7ZUyeP7dzl8ShMGrU4EZrWW0TM4E9T1N18Ji8AQLSxmOA2MAMF1QKWLtWSz8taYsPK2ZFmrjLtDImSsLwhTHxQRpvn3f81V59OwF1x4JWkx+XXIsQ3FprnjX8DCsYF/XrvldrwpwW8+giTcmRZxo+oSFdd2sq8Vk7GczgXjTaj2HxVUTHiCUeK8WGyEcYZ7WLS5lmKtWYbauN2f6p9+8EqxZz9N3CoKYOze19V46RKuUka1GvM89Xk9BYWF5PqHvsziWFbIA1Es3248V6pi/ezFjtO08Jl6M5m2ZoH4SqFdSHFiH9rg9tpgfoQmKPWbqN89frM16BDHvpYvlB343vzKrGEf6uusAH8A7sPPHuk6YxP/QsWJdXctzij7NlTnhFVp81Ao0tKQI5e5N675rz4hCZzuexYuZl01Bl4oLPyaLSeq8EOyVxuIdBKIiffq4mKTewQACsl9vhH4Zi32/ChE+u3grYWP1UVLqez554lmwNhu+VFV8sTRoYJXFxgK2sDgQe637Fxz+b8M3yBn8a73Mxm4OhZXRpzGTV/iM/qGhNQQYHfgqxdXe009FLnl7hOR4cXaP364elD/4gz+4eOADH3j+G3j1yU9+8sUv/uIvXnzf933fqaPVNYlJhD4vrZhVXfvlX/7lk1Ly4Ac/+Fyordopt7WxMHu21NcVxJuavKld3IRp5llZ6nqosujTAhwxDVXW5EWx+Xs3F2cLosAXjbJ+CT05YXaLw9l0XJfO4cFAe4YYaH2sKVENS5NAzku0NQMI6MUZ+FdsFzH2HW8EYayAkesxuqOLHRGutwOxb9YIJUvaLTemsBWLzTttmuNGstkx4M3aIAQIDgJYQTBKJDDnhkgwlFWInPJKIcS0neWjXsQCAjGQtUYXG4Bx7nza/CxxSjZlr/9TAhRdkkq89y/tbsx+PYKUYELAuKNFoRsCTQhzBap7NyRTs0fW0mN5y1gifGSu8OIclbgNw3gHw2IrZLJchb4oCkqYbwoxZm4cC4DlySQEV6BY757jX31xbgy601/jWMEhNMZ7hx+pxqsEfM+UgQMbQmnfbKRVhoUP1krdQ/96f+GaDErZO/1f9Vdhsq7rPoDiPotLYqgs8Lg9wFtNechgrc+FcvsOIFiJdXtuQeabJcabyNNEwFEieDE2PNkYpMDi/8vPFMjEN7s3j6KaH+q0bN0eewgNOX+t9+PD9bWPTJ0N56+Hk9FJqa4fwlq9e/ky3nuHuf+IJdnfee0ZC/1WX9cAYbBQThk4aEs9kw23Lv5F33iseUdlFaqzAqvVPNifjNTlF7eLgtKhdEfX0rY69PznP//0+Ugt4r2tRdmu1DC4JqOQDnS/c29oi1z+JoZWKFTTQuWmbVwEDkbFFdfzcmPalJg+C8HJuOvuItSd9YCxtJh7LggNmpchBQXjYL1LxfSOCFgYqWdW/Kf/e/amHLOgKQm+63k9ZwF9mJnzfjAa71lNe0GEq7BA3/d8GQwxLeWPMQTMTfotBrnu/k1XJWT8TiA1/8JrFEEetRgHsN8KIc/xDngewsrzF7fDAuzv7onJs1IWsLsF0fSfQsLC2D407gWzKqiHwcJ5rJt665dg9JgXBUT/Cf5VBvUrZhtGiOCDj6jtMQXrVVgPALAvpUz4UGo5hgTnVV95C3uWGimUG/QFTI4OKDabqqhycuvQv/292Wo9p71nPhZPhhaMq+/1yZ5nHTq51prwUvCKEt7o075Ybw7go2wGB7L1XbU3YOPqa+XH42dSWYU3KA1SkwmKngdHwbq3l5who8hg9afsJbiyfpeJs5Wt1e2IN0qLlXnFIGtsStX3jGgJlrAiZh2USZjaB/3fWBQxJPzg0JyppB+eH78odOvojf6lyOXB7zcKU/OHDnu3sI+xCAsRzOa6A/PiwSm3vUN2jyMdGpP9yDiGXWld8H2GFsUEP4znOklbCKT7eDrwrf92GR2wF+GR8BpKov3P+23Pp4DiE42tdxRabW7xKuEm8sB86ztea+/0f1in6K9n3e1udzvX11qjGuh2w4KbMXrVZPF8pIYREkKsTlYhQJFYowqJrHrAIxptE79MDKPuXoIUVsPmUT11iaVnAWb1HdCpmC9ALYVpkegx2whH8bD6EwF1PasUg6GAGUfvbqM05sZ6RE+vZk8IA4xhoJjcZv5gtFypm+VB+K1iQWns9+YixgF0BTGOGXALr5uSYF0XNi3eHGACq3Rs2u0yEBuRIrR4EPMg1OR5wkIsDPUn/J9AJYB4kghtfVlLEZ5gLdD1TGA6rZ+D2WSpxNCcpNp9mMh6M1jnBPIxPGPP1M8YFTwAoQoHs5kr62K3vpR762tOZdzsQWa1GJlQBQ8H0O7R5Ww91utmfNZtw5mrjDiUkHDixWC56f/Gwe29pQHj7++ECFyBtM91j7f+C0xdj59rZckAtZobSoY6KoXOrR23eXu773lRCFNeDnsiHlM/9vDJ+uE0377DE9Cu82yiKzyk9zpLSbFD+9S8OSeJIkax4kEIc2j8QtrNoTL3qpnikVKaVYLe0PO+BzC1v526DR/I2Gy+4cSckm2f8Qb0vX2+xlsfVcIZq62/PdGzU4AcaVBzbpPKrgsxOIZkebr7ZPxRyHpX+1uWlj59+qd/+rmgmj2682xe6meeIMU5+7cPgDgDo345+ZkM6lOdHnVuKKzCNMJb682Et+vvFLlOq+b1Ik/Xw88becSy3CoZf/Fx3CykhWAVslRp++J4rJ0awoESb8KdbIxJYMpqJxCsW75bOhhXvPihxhXrnTUEu4xSBgCrE1FwPbJSuBttNsxOIRwWaH11NhEhhWHX1oVHkWGNLb4HcVFMFrdxjCW6f93/NpS12Fgkzd3GoPgYx36s0b6H9SWWbtNae6d66gu35lofi8/x3A3xWJ/mA6iMh6PGO0NZW2ZnE/tYO8WQMEleiN5HwSBknR/D00CREx7kUdE/yo/nb8onIco72PNThCj6MRvWkrXe+jies2tgnvxOKRFbB6ykUPZRFZlioF9LNzx99g269e9mumHyrYmwBrDekWYoOLw+XbuYCO82NuFDhc+42Vc4Uw4XV4G+8A7gcyG5zS5RC2bxBzwtXZNA8R0+w6uA5rY43AqBxQsARJqT1ge94kmMAyBr/I+3uufwHOI1/S28Tbijya1n4mA5oFzzx5sCgGxc6IJXUMo1T3nPQM8UMt5tPMVaCJtGHzwBPLDoQ4jYPrJWqwT1t7AXoU+BWCWYElt/Uj5a+97dXOUdM2eeTakB/E/Qf+qnfurJewU0u54/tFt2YvTRO9AYbxD8ydK6exVzc05bHugwUOihfzf0zyiXeZl3JsUb722+hX+6Jy9g/XGQowSPaGL39lWtoGBm68KvsT42bZW7DM6D4sDiwKhqW8iL65xGjHkTrBjkgsgA82o9Z91uhBYA3/aH92YZtywlDN0zvWeJjqucqzGtGMNccN4CBhczcmQKhBGCXSXF/fvsozVq01MIakucXMbrCemDcfrwTiz6m8W0jF9cVGyX5apxa7O6CSTrsorcKnPLJPVjvQbGQPBwaRrXcb62Omv/ypRaGhJTR8OrSJkrHkKAu3X91tb6xGzQt3ESjj2zfsBfeAccDMFgPy2trGK7noj6FA3GYAmFFR4UgVVaPZuicyX8iH8VQlN1lNFASFGE9But+puXjwdjlbpVsNdzuQKNdw8t797X73Xv4zmUJ3tE9dBtQnF4R/esRxjeoGb/yjShHK83bZVAY7A30TolG6bKPqNEMYrsN1a92hsA0ehwMWISB6Q7RxcEO0+x3/C6HYP55VFYz9jSDRqrCdmugrGhCnS3wOLlrf0/Puo6e1Z4W9/QGGURHcoQKolEJlJjVHPKnK4ikOKSd6WQ/ad8yqecjxkp4WT3Jdp6//vff/JKqUXDy9Kzo6k8pejE3DJuWsfGV9+cw8Q4tA+E/1KCutb5ZbA71qX3rUzteSlNjlfp+I886bxM14SCssBKhbK44deLYcPUCCjeE0TVYlVvJELgtdhFomBwNSMAzG0tO54JigsLRxzU9Z4FcY2Q2oQRMgUCsJRlscJ+gXyEJwHM83CsjbCgKwcqOuUzguLdAeitsbK9E1NYzwZGaSMTwATRuoM3/CA7ClPD1FcZWkWG4tgGaCNnRUgRVCOgZwKJEZRt9D2+AMPecRwZOeuhv3fdWJS8ab536B08CXrwwbBhTqKfXM65Xs1NIUNnrrD8WMysqBrvhDWq2QeUKYrvnodjfzg4E+hbCrI9pb/CXfaXc4t4DdAigYERbuohGux36+wd5sq1XSdevkouzBWlj5Bg5dpj6Ax2hcHiHfYpjI9zawjM5sB86YtaSgSEZ6ATIUx8Z/eouP6GyCih9j8QtHuEUSgC+BX6tUZAzRsiA3g1l+aL0PWxnuhpsw6tL8ueZ6R9xtNSY8gYE0t6DQZhSt7OntucZl0LIfQMuDtW+dGzxePQdXmH49e7n+wNvK17hbW6X9jBgY7Np3Nv9J83BtC2fchYAB/o/z1XbRjZStaOt6FDEetjY12cUu/PW189FeGhhP7iSfrujne842lPFs667rrrzgY0+n7HO95x8sasl1N6r7R071TqwnMptPh046yYXv2y3kDHJbnwlsh6Qi+NvX2Kv8HppWjFv+p/16WkpWx1NlKp7teEgiIcwhJv8mhvYv77wahYnDRr3hYH22055A2rIHRKS4ucu4uAYmXTphEbl+meB7Obj3sUg+6+hMcCKylD6+FgAXa9A514ipxsjAESHnAREdyf/MmfnIBsCt1tPB8jpb0r1rbvX4/D/m3MYuVp+DawcJVTZdtIPZ8icQy7HBtmVV/VuQAyE0Ziga2A7po2B2ZEgNTWut4QWH0ua8shlDa0Imbi3Dxz5m/DWRj5Ivk33luLURdqUaq7+13TWFR0FFtWj4V12O8ElrWwJxQjbAwpcj1PSLLxBZpc5bj/UxCjra2C2hhhEuBAKDgwEdzUvH/RGbzIKleUk5pwk/lqDICahLBU5cYB+GmMUpW5ync80Rosj+rKlJ6ub581t11jb1J6uPLda323nkrPgEHDN3gs0KYQnvAcZRPN1Sg2lLmjUrteEF7T9YAaU3TE4Er4qp+DxtdTIAQF+6HWi7o4m9lDkFmXVUg25Nu7eVH0z+nW9u8xdASTBFwLdBpvVftEeXw8Qn0lRqrECJ7w1rPfC10IsaETh3XGg9Qdag07HDHAJ+MB3xSmyYh417vedaKXxtQerc8Ov+zdQO3V+er76Gu9ZPCE8G6qhuddkPnSeGR51pqrcEjxd0prfLsP+qtPKTwUX3xhvT7k4yr4AX7RlMKmvNLNTUoQ4C9a2DOottYJzJOMLTTAA9hzeOGuCQVlPQrAY4Sy2FvNhPjXRGLwCHILSsExUDh4CVpE2QgsP4ctaQt8pCDAdFBSlEtHoBtCiAidVMpCgKXZ8AvrsMalvES0ioR3uBbDxayO4QuKDI15wyCrPMi+WY8Kay9XZbHKtGhhBvO6B021kdtcmDwhsa79Nism7j0EefFNTL/NSpGDYu9ZfR8zkdZHgUQXAGE7Fowdw8Rs+tt6SJdeayIGtOEvz6QoFFc255RfQo5XAB0TugROv1PsjpUiCSrKAUtXaKB58T6WP6UdbciM2fDLeiEoMATLZjj1bkppTaYEhYWFKOQBpyDFfrPrWNwUOsBtdMs7tx4qXkP0Kn13648sTqTnqawrNIfOgX15ZHmL1tPC6FDqgIfNHGv9LZut653FcvRooRe8bevQOO18Qy/7LoKAcrwYM0ZMa5YxALPDU7Tp3sZHUK6BJ1RO6WJE4Rn4IUHHGKDU2BPrKVvskXk3v+ZBhmGn4kYLe+ghozJhLXVdqXsHFALdbljPeGHeankj2rtZ+vrRbykn8TKnSPfsPUjT/NrfGWRAsADpKUUM4+7bYo4MF+tNefirv/qrW4CdeXT7rr7wxsRPqjsmI9NHwUfzC6fFqGisDB5Zicpt1BdYGWvAkLc3zLP1ohC1n/GQxgZvw9PX39eEgrJxSotbE5umoBB0LI9jHBKxb00AbjFMAWNYLAnXLtAkYbSWR23dkIQgC1q/MEDub1rpEXS332Hom0Gkbxse6WOcFCEE2sbZOgDGaH5sVEKIEFwhbi0826ZrU2W1R/AAc8t4WdExutar/gA4rvARp2ZdEg68Ac4LavMm6K09xth7Y3BtZNkQK4S5X4Xk0IOMGpYUy5EbXAyeVSMTqna0oikabU6WEaFeo1SxotCPue4+52s05sa5qYDL5GsLzJW6DAuif1zCaLfniEUTvoT0gndlr9kLhCT6wIz0n/KgX44GoPSsl8A7KIIYMkHIm0hJRv+USXue5Q2jYx1W6d3jKniKKE4AqRs+0z+/1aTO4wfG7H32pf2/KZc77vW69Y48BAvmxJ/Q4ipiNXzNesJrCGfbB1Jbe7f0WR4yGW+LSzvud0qMcgxqQAklU36sgznmpelvytZ6mu1BQrD1kPGEz7fP85oShEJFvTe6tW4MQeNcXsOLYM55sutjigjeE6+gwKT85Ent99rOLewfftD9XS81vD7kua3faMa+QwPC85R+8uJ/XKZ587rhCZIDKDy9I/7WM3lKAI/XqLSu9on9LTtQCMvxJylIjHXHBzT3lH7vx2vwP2Fv3rLG4jgEcuGaUFBsBJuUBlmT6mgzi3Pa6E5U3hjpMkzCfUND/d07ast4aot+5vpFFOLEC2I6ujzX9Uqx8d22FXwbmtishfrvuO02ipROwsL1TlXlJWFxOBm065XyZi3s3BA2EeV6jdooNiShrgaHzCAYgeZhLRJFvTaUVEvRqVF01iIgXLiNzUPhKcqlcEBtXZzCXTGArLO1lJ0VEsCLogq4RpGMaTXX/d0G7iye3MqqSm5stuuVzFeIyZjEbtW72XnmtqYoNP7NHNuURuuyljgFoTXZQkzCGAR4TIk7l4u4OUHfLGouXL8TIj3HeVToF1NmuVEq+5sluWE5QrePoltOurVfvGfTfVlx5kmNkQ1nYJboiiIfQ+46YTV0hXa2MJyxUHzWC2kvL36ttXH664Z34b14IqKHYvPCYcX9hb1gJvAplilwKqGMl1GghKIJvP4uBXiVWP0HuoyGCV3v6Ds8Fu5JWYb2QoJM1kjX9tnUWFg/gGzKg/niYeOhlNLfdfW1uXv7299+qk/SXkwYU1rykqp9Es+KximN9SEPgfCPkg3rdaYg4pEpF/Wh50R36lJJppBVxzhw5hvDwzzylLSuHUPS39Kpm49CNmiKjNg9QiH44Ac/eBr/1i5Bv/ZMv9ePvNCM9Tw4sFMwaZTMnt3ad41Uc3u7PqaMeW/3F35q3psP+wcf5vnEV/CU1pJB3n1ve9vbzrhC/OaqV1AIcopEbWP+tdUeMZKaSd7YacQE8AShvIoDz8oSis29cTVWIIJAzFzgsmyAY9f7QfNc7xDPwSL3j+MidIy9DeMkYe5NBAM411htdoTV/2PUjgAgFBe9DtcBWNwhfAs6pVzEJO585zufCFR9gpSivo+xsAraiMWYZWPwChCufYrp1mxgcW4Kp/BFfbf2Gw6zjqxSFkau0nAYMaEsnXXTszQAzpqrxkxwsMiaK0pWCh0mSCmlDAi95DrtXsyDZWyeN3xoTrlN0fjiKLj3E+i8Xo6NMHa0zC2Mhhbc2jvDMPi/ujg1yl8NHfRM19uHva99ZP1gLfwmZi6UR3kXKycIWb6tS9/d5S53OQNtWfqUPvvfbyy75Qf2O08DK5qCHrPu75RaXgjzhibXY+NjnbWugx9oD0Yv1te4KJWLlYkm+mz4lLek51GuhQP6nvegloA23vUaLa+yrkfvGk8J5Zw13Riaf5gJ87GHJ3Zvwnwznxym1xynwPdd13gGD+IqW30vOwjN2of1K+UNXqTxJPQbP5B/vwFV1xZT6KTiDT3ZQ2uQ9m/7pvEHvk/x4uGtH7xDwKfeq+qtPYF3w8aUchtd4b2wKfb/7i98JCXh/7hUrjazEx/rs8VIm7v+LdSTMtH7VvHjiWy8FJrGp0bX0l0heaE+IaT2NOWsNRV+ldbPqFsPoz3U7xs2xEeuegVl6wUor8ySYAHZmBgM4Y+x7RHqFhERsspt3hYd0+AicyDTCpia50Xo3ObceWLwNGwaPZdbgtpGZa157+JpLLi44Z5FxMXYu1gYaz2Yj4QvoBNBi6F1f8S4QNHaxk7zbOQxUA+gfrQOPSeB3qe498bvWcXm1qZrPFzbvRcDtz4ButpUDtDjhSJMHUAHrNizHYrW+NvwmOTiO1Rb/KVf+qWTtQBgJ1Rk467HjrASXiL8MTPKrzLYW8+Cl8F6Ks6Hnh2JwA3edV2D0VhnuBXzCr/UeHoXukF3aIzng5uZQijNUT0K1jjhytO3DKg+CTdhwBSEzcwxXmvuN/3bDIHWxFHymwatDgMlrPVxtD3cEnpx+BuhEX20VlznvSvabG8QruL6zX20FC2kGLHoNfMUrUenvWfDcjAShGlWuXkk2I2L1y2Bu+9QFEx1Vhlrm36vIKPq0XBt+EbCtt+bJ3tmw09opfXe2i4q2Dqhl3GUsI8XLIaHtzTlPh7sI7TU9/UhemzOhCyEhpqL3tcYJQs4omLD5I3xS77kS048OGNGWF24ozVwxEjKZv0UGq7hL2pDEa6wWdFRPKmxbFiTRyIFIFrvswp9c2z+KQQ9HxYOkFQ/axlt/Q5HVr8y2Frj5fF3utOdboG1ssd7XrTZu3kjGanNY/shGiYTGZ/2tsNZe1a8GRBYuYO8YrzdQkc1HiIeQqEqSjgPTHRaf9pDip8u5m29kVe1goLBsQRaONkVfS+EwdKhqLQIXHe+W0Q1S7d7KBdcodxq8AnSzTBJCop89jYmTwSi30OwMAM4kCsh+nkdjIuHQknkGJkzU2rGuOGgBcMt7qJNyfKImISyKGERX5adSqYK0611D4haMxaMkedGKWSuQUoY4dtcKSkeY0vxIXxZDwkElkfzRrnsGfUpRanxSP/rnhhX9zVHjUGoxxHy+tN7OmeqeTJGBZIwKjRmrFzDgKC8S1zTi+rHAKD4ubl7d9kBvEmUm64j+KH665eYPWYoZGLcPcsZJjWpsVv4TzipfhBaXe/U1i0oZt32vesREPtHl+gNY4b5wbwap6Mn7MvuwTR5XYRqGlv9TNAlINuzAO4UD9f0vNaaRU5AAWty0RtP164yixbt4dY/Oo5h80h0X3TUWicMoqv2hz1DceC5MG88gRgzq1jmTEKLZ4LV3r2EBm8BBUTYTp0Z41NvpDFQrLomwZswwle6FhCyvYdmhLMIH9lllHyAULQnZJPi0FylbOGdQq3twQwLIcSaOYahUBW3RlGhcApT2RObFr5gW0r4KrMMTjydcrLp0+2d+hsfjD6iNfVm+hxrfzQP6wHruYDx+F3KQ8/iJWEodU3zlKcDcBYt8Er3f335wAc+cKb3Pj2v3zp0NyVlaW3PcOMhZ8RQLpoX69ZHvx2f0JzVd4ZkdLNzvYoGY0forPfKjIJnsT5kE9q7tV6Uj2sFpQkX/1NIZmNkpY21mFz0CJXVeuONN542JwUH7oJGjQmx9mJMG//rOmm4CEpOehp8efDlf0cALaQzcnqHc0O6r77YuItwpwTlMs3CUna71jUxx3LkC7MUnwXqrb+AuhGglLCIlVcIs6+/QIsb3mC59A4Fr2JW9UWdj8YB3EcAiWv2r0yS3hmTjxFI8WMp9HtCtRgz60RtAILaWvRv89g4vvzLv/w0hiwPMXCpy7xbUuf0P2ugeWNNx0z7vjmsz3vu0mYuYZ6NJ+utjyyrGmu6jdm4F0vD62KTS3tlNdeP3/3d3z1XXnQmCy+OLIye3fXRWtfUZ0pUc9vBm83dz/7sz57oFE4H8LdntM7AmhsGqQHXsbDEy9FNjVIvi4Y3xzk70P7RdH1qvin39UWFzPZG/QfQbF2F7nguo0MeygRGp58nTMNQvPvd7z49K9okLHtnTQZCtBa95r3oGlU573rXu572VPfedNNNZ7A4fEf9c+ZL9Mj7BxtUn1urakb0b6n6mH6tOejZ3OP1Pz7UOvM8tc7NgdoozXFr2xh6jiy4+Eef5qpredXQ6BYirN9AnJSh3tEzG0PeBx5m1nZ02zjiHc1T+4jnwjrUN6D51jLhJd1c9dfOEiLA0L7aRvHlQqh/+Id/eAZjKkLHq9z6qAuCR2Rs9Lz2U/yh/mWZty8YKPFmobHG32+NtXE2T81P3/eM3t3vMvJkmtUPHpfmwRk49YeiFc3Xh+YqI6a+LKQAX22teS6SC7AwQtcygeJbjibg9eI5osxSWP/uEs/R9XmQJRMAUuP5+Er3baFCyjrDo31dv/STcr5ZsMrkM0gqhS/c2/fJG1ihFC1ep2i08fU3rzuDDZ6HAn9NKCgtGq1zz9Hpb+CsJqtNlbZZY1XHWPpIE1ZrgjVbI5SlUxFgbTqgKQQPP6JcfQvVc1oYoRMx8xazZ8jacFCU90QMbTrZLizTxsEi7X1tWGWUbfA9tKnxUYw2hZQGrbgVyw/Irda7FRDDeOpDc7eFvGAjWFhCR57ZJqrFLDCePkCE3ZPAiYHQ6LuuOWwOtigYD0XzdMMNN5zG15jqa/0jhBt/c9Hc1IcUilIUX/7yl583atd2TXPQGsXAKQfqHDTuBEf9aI26t/GwJBykyHVNUDU3Cd2EQ8+OwcT8rWdMzqGJXfumN73pXLFVloqzUcSQN3Yco7L5ZfS85S1vOY1TbYTmqDF1Unjvivm+4hWvOLvqFcarn33X+kSTHQYagI/C3O9f+qVfej6ttL4mMJ2cWwjk/ve//4nOmvvXvva15yJzstOiW/uysUSrMkcoIOGYEsYxtrxnvAFCA33XfPVstNI8EYLNTzTotO/mIGVGOIzb/fWvf/3ZyxodpigS+jw5aKr+16f629x2T+vYd81R7+r7lLFNaa0/Ce2eG911jfRril/zyXKHeRCGaa5a49ay/0t7FUrgYY0+WgNg2OaQcK5F/9Frz24sCe/4GQ9Da1Rdj94DINsHRodH0wnFskWk6zdf0WP03D3NTXu3WiI937vbPz2j90cLzYeKqtFZ/VSjqLE0vyl/ANqNh+DtegpAghI/ir8nCFtTxTMZeGgTTqv729fGET01jtYtRao+Nn4g+WgyQ7M1bSyqowqhw6E0vjwbzW9z6myr5r531jfeEzQs7OfEe8p/htf/dWlQbFovftCcRYM8jz3j7ne/+4neGle0ArJA+a6f7bm+bxyve93rzpg6uEPKlPe1VrwePCrRSLTDsyuLjSd51ywad8SMujz1o/df9QqKuL0UOWljfdoc3HEmvH8jmCZXASmxTIhyqWlcghQgDFmtCi43pZBZey1kxNl7WrQWM8KnGLBoudj63hkF4qQE/2q2ToWEbnceggJEBFgflonqlns6KDd/v7VJhaDqa8TGk9IzmicEJgsgr1MbEaFTCleJETbp/xH9KpLqE1AmeHG43utffWKtKrIFXByTisCf85znnGPZNhBLobHGUJwwCrAotbJxtv59FvAXA2GV93fAvOuvv/7irW9961kIOMcCfoAnoY0cOO3mm28+uzdhPVJUuJSb0/7tOmXsAbS3SFjritEKm0m17l0UC2GENryaHsI7CTkZN401C64mpNV3XP2ue+9733uaf+78+hidSQ1NURCT3vHUeB+E5HouTJLrCOAYbO9jJVqf+t8zNuuBsiJUkwCB6QDmRNNCU4CZMFnCBACsjaf1VYRLFkr9TICkFMAbdU90XF/hgFjHPTvLWoE+38vkav9EU82NuH7z2bujl56rRL00YYZAQq0xNJYUzPopJNRY7E0hxWjIs3gPoz3YptaOV6vfMj66znkpjVcGjuyilA7p+c19a9Oayrxq/N1PuZZtUhMasU9gOxgw8CcpJykYXdvzG2c8Jj7aHPRb16oMXd8pOECcQO0ZLWqb8Jw1R9FMfeP9pBz06R08PzJz6nPKRHTZenlX3rDWDVav76OZ5qnv2pfCQZSPlDSHCjbPW1+rRnl3PlHzm9J3pzvd6fQ77y9gOcVgPZvNb8qJUhp4JcWbxyx6aPzwNF0TrTbuDA90KWTY2Cqnv5l6vYc3T8isvym+tX5j4NYn5Tgo1Le2fVwrKFzsUPEOT2tREg5AYCzmvm+R+vBIiNlBpGPeXL/cgRhYxNCCAj4Rehig1FvxbgTLFU1JUo9ADB6DasEBXGUkEHi8HV1fv2QaYVgJIJk6vcOJtZvKzIXY+NqAmJlwjNAGAdOGFtKRImnjSNtkgXJPqyjad80lpc9G9H+VQXmNMP/+T5mhyQtZCEW0aaQSAmSaf2MkrMSm1aCQ7hYd9CzKIsWOMGwdeU9gPmrqOnB/C2/I9lCUigIdHWyYCDhb6qjUTe7W5gADE4qJaQI5O1+DwglTJRTJk0fRsO4wHxTQ7kHHfcTKN02575sD/TTPQNIxoZRB93LpygaRyRLTbWy8djBQ0hmdsOq57RvKJaCgOhssSXtOyJWhIabfPKEBtVTMU/wh+s8KVZrdXLQ3CcWEmvmR0tm7uhfOaUuuEwqU0/5tX/b+/gYg7/kpQX0HSL31h+prfEbND4BZNOFUYEZWz1R/YtPIs2KFYIVQ7aPojJevcckiQiv1tXtUqOaBwD+EchqHsJJCl+a7e5orGZDKAMDTNGeNoU/fNabWgSXvt+YUsBa/V8yQdxsNM+oovfiLvc4IaG0VAOy7lABKMSyPvq7yJpzHsIte0I0q2WRI/RLeAy+gpOFXsDJbiBL/+NBkvjjM1ryoEs1IpOzimeozoSdYkd4ZT4oG4RAptvWRd4iBwUPMEOk+5TLqs2QFeER7VRXx7usdwuKb9XZVKyhtbpsm66DJUb8ijIKMEOBXwLgYptTWXL6sXZYsq7eN1+TGHByN3f/vcY97nIhF8aw9IVNtDyc49g4paEBt3KnS93gS6pf4c8xJ5cQYh+eyFNpcXH9KSWcxd5/yy8pWA9S1UShjYv/1s2f3TKBTgoFAqTV3PasYfkRGyABo1mJmjaN5kdJnHKpOwrsAbjYXsg3EqdPg678SzvUzK0dKHKZkI8laIIyB9vq/cEH3t8b1Vdyb0qA6ZW5lp1a3pgmWwgRHwJmxAXtxycJ6OMI+SzCLjtsdIG/PHiH0KQ3dHx00Hxhc3zc3wNiAusZBGDQ+bn1AvvWkRW/Cij6q2uo3Ny8lr/mgePR31m7zAn/Sv7/zO79z9lJiRPrUpz2Xksdj0j0EUh9AUCD3xp3ngPsaQJJwMU/2NWtYKFNWjhAcD5mwokJbjVUooU8hv/qhlg2mjlYBuGV89GldhdfqOw9DvINnQgxeuDn6ute97nVOjScMKZb4WL+bT2NKODQuKaL1s78bX7TKUmU15/aPzuoXbyW66ZoUmH7Pyu/+3uXYiPgILFH9o2zynvAYtL/jR/YnuhBeaMzCM13XnuRBEVbqmUoNRGP4mv29ZR1qWwa+vra/e3ZhLuHpxkx4AuP2DkZqHoP4fH1tnpMZDARGp7WRcRMfK9TDc9neb45aF6FLCh3PeuNh0GxWGgWLMYcPxPPis/90qcAznCV9NA9d0/vU7lGTaTE4slV5Setv96hm/dCHPvTM6+xJRfIAsft+y2/Un2hOtqIqzwyDrkHz9qLwUPTR7440uOoVlAQZV1WTGGNhebIKuLtkSbD6FWqLEIQT2vQ2DBBRlp08/wirzdhiiTvu+TgUFMjuCCdmXj9leXQNBLbsnGKcrGMZEhDePDEUFNZ1z3KN9933vvc9a+U9P0ISR1WrwnkQEdBmGG39AGGeRdoLI+UCxLil9sbYe754spoHMlZo7tx7TvXcdNHGllIhRl7/hTLavG08Hgv95Fnpdydy9j6x7O7NTUzbl55obCwG3rMYHAWS0raA102txVC7pvMqAM96f+NgtQtrcK23SSmWW7Oj62Oa6uFQ4mzuzThqvmQIsMAcNqfPCzgGZK45U6h+RMus/b4rVHHPe97zHA5FFxiQmH59lYXVHComBqAN5wP30Vp2bQKyOVYTggucN4hnrr43n4TRFiHbLDzYhuaCopYw7Hr1dYyDoFNd0zlFMWmAwJ7/xCc+8dwPCqhMKNVsozNewcb5mMc85lz1s9+l7PdpfzzkIQ85C9T60d88m8Ig1psHs2cD0jdPPau1cbCcvd0YZIOFFeIhihZ7j8Jr6m3gQTwaPaM+tYfDK/WswgvwWAEkgbUbCyyOPWHezSHjZevr4GGtVbwhPp0xxVMsI8vzFwiMtuO3vLWNpf2JPv2uymm8P35R3xXKEz4WTofp4QnDTxzsR3GkoDSP9Q/eb1O/uz+eDrzq/TLMavBY+GihD7xMGFK2WHNZ3z/h8rwsoVsGC4ODwsMr3D34IVpVQgEvZ9jhTVvnqGeADOgr4K8QPMwkxVYokLHRewuDZcinhGfMN5cwfGoVXRMKClBnDBDq3OSqcMotuFkLvClNVsRmk7V5EpCe0cTKCRejVwFRvDnBKP6qzC/rRa2KFladgQ392IjGIIzAkuT6i/BTdLjUNsQCVEkz51Z1UJbQhQPdxPExsTYTUCMBuJknEWx9oxULowlJOIeofovri6duKWnPlP64FpAYefMnZ5+3YxHfhI30UtYE5Y3Q543ovdzLW6tka3VwZTpltbUAZhU+456VobHl1T2DUqf+AcEuJMClzcpfJcA8sNYpnuatlgCh/FKIt0AZbJJS4erseAflkAcBo9+U0uabd8H7WWfAz2oeEJwy03be4QVqMjakhTcfPEH61XsI1lXyKYQ8J7UV3nAhlN+eo0T6VlA1x/a90CPFqn2A9jF8aZddy3jYQmdSxhsLb0vzFz/p/yojw8YIWXmPkAv+BOe1WTTCXzK68AShV7yCpa6SaH/bU82nLBCCgeLXe1J2hFMSqj0/DI6QpXCicZhf9MdoMtcbKq0veB9eYA540HjAvI+iRimmTMADySwRdsfbHeWwacXtRQZcNCU80v7qgwYohvBljEvKIi9H74Qjifaa75R85SZgWCiNsC72sXfA5PFmCadToIRC/uUyZOYcrt4P68RTA+/TvbzelGVeDb9TuDcbUoiGR5LRsDVuVLiGOeJNotCQRXCW3a9QpPlrb/DaXjNn8RDYLHbCiyCkVAiLYFA0TlYpV5iMCEKhezcWztVM0PWOtGiLUCNAtpgSAC/wLRcppsv1iMD2aPc9hwFj3SJjlI+eIb7MCldEbgu+bcE0VTQRslg1BiHOrygZt6UQg/nmbQAOpDywevsbeLJm/uAHeh8GTYGrAd0Kn1nzxb1QTpo7FgZrUTy1e8wlYJffuYDhN8RIMQIbc+PFBLQWjWBC1lqcG5OGC5C+vXgQDMqc86zsWmP8LDupu7tevHg1ioZqjjUMktdk6+3U55gK+gDYFVIhdDZkgoa44r3DPB/n0+mztT3SoOZ9lAwpifaZ8cME8AoQxBvqk7UQ8xSmXOwPsKE6Q1vYcXFaWwWXRWrP4SUrdNE8LBnvnAJbq5AJEUhXxZNqQo/W1DgJbH2FzcHf7E90xZJWW6bWM/0Nm9YzltZTsjx78UuUH0qa+dvxeCZcFvphPNa6Ro0hY6Roe6c1xTMXkwEEbSyLyzBeCrX9st8vb+I93wQFijZw9fYLb2IIwCG5x97jKbHHFhuHts2P/1NYKCh3mCMUeKnwjTUS8LPF1/Fo4W/mmcLr/n2OkgCMDLx75QjZcQyTL36xdyiKSE4AwwsTXRMKSg2QcpkfQV58mVCsUQAoL1shkiYunRXR2bhbRGtd8ixkwE+Tjzh4PGxsAh0xwoNwW2LKmKhMJIKtZpxwAeKrNtcyQe8Vc0d8GGauRl4X2jTtvmajE2JHi8a9BKvsFu+x0YB610KiSPU9BmZj1PSFIoKJWdMjAEwMlcfDs2x+lTE9gzVGmJs3G4s71QZchdA76n+bETgQE0VXnifjQ+wWs6LI2OiE2ArdVQiEVbYKrDmAlaAk++x1MoGANY259yWYjgXjzBPm2zrxjuibfrqWpbmpkcDSrLAV0AQ+QZvC195C3+aPgsBiJ7CBpM2TMSs+xio1z8ZRI3hZ5xvurAFNU3B236prwzrHe3iEVhnddaAwWh+hZ7iN9eBR/Bsj5VL4FFCUEKIorbdpP/q/wPEakLZx4VHwewwQc27/8QYpKrfeAIXS1pshYw0IHW9g/Nkr5nXrOeF5Gm+LeeKVYRiiHbzJOsKsrBeS0CVg7WF8kOIrZM3rhfYozOaS/FkFX5hdaJky5DveEgrRzu8nTZgSf5dcsevLW8UjIsxMZlCOFlRubP22WDjvsPfwe+sJnCtMRDHqOe3dIhErL1ZRw7uuegWF4OT54NatWQyYE+AzhEuYK5ZDM1Z2HJPiAeGBqRESngkUKFYI1MS6ZGVxvbbA3Q870hgAGDFsrsf6q08rgDAT37O417rvPsLXxvF8FtpmDvQ7BDsNnFdAPLU+2jA2PqYIH4GYrYVsGd4HoCwK41okrO6enWIGR2QjcL8DSGICysdj3lzkaEToStXP/t94ALYWHMs65NpXFjuBt0BOQslmbw6lVbLOuIxhRjAVKb+rDPGmSEdHdwST8SlktwfQ5f3o2jx6vZMSLgTXM5T65xHiWVj8VP0rs0WKpj5hzopJYeAUTQK8OTLG/t3jFWporswfwFf7UbYDDIMCi9KJWcCUvdox7En5kdbKOOj50bCUyhpBsoyf4KMUt58xVJ4MQhOtyh6iaFDS0N4CIDes4B15eho7YcEjR2AS2Kt4MCDsU4qisfiboIoWeHcoRoSh7CheCjQp3V06LGHFw+caJebh/VYg1U88kOeVMs/4cC9FGV6lJsTYJwWk9YOvi87RgRCzceH9vGgbirLOsGGwGhQyuDfz1LN4ZhXkpBhSBuqL/lpv/LkG6wNszaNhndb7uVmJ/3JQYgh8xvSGDe1Nhek8k1xBNwzX9eCaQ++AM8KTNfJFiE34ThYtfBj5up5m70DHt4uCUh2MF73oRafD2yLMV77ylRePfvSjT7810OpTVAAm8FCLUh2JH/mRHznHpGrF7o6FWl74whdefP/3f/9t6gvAD2YONLgfWvm69REfpkCZqBHcmO6msbIoZTUsE1qmIN7f4tUvSGsEu4IZdkaIAzOQQdH1rD6EhglzCcs6WuufsCE8uTU3m0EaGavaB8HbUDJ/pPuZT4S91oQPZUhtFkKHkPYum0ZWkXnGgFkcQMrmSh0CaeRiodaupg8EW++OsdHsrTWrGCMjFClR1iW3NEYvWwKTMdfcp2gP3a93bM+MInwBZDes4NnrQSJcFe1bK8rZL3saqlBAY6EkUmjtmX1uvwn/iKVz71pP88swkJUgFR5ztLekgC7DViQLaJtnDV1SPrnRKawb7tsYuDVCz0Cy+IOU9GXWwgeL2dBney8eUfhVkTNAys1kIUBYkOu5WgV53ekLpIefUF+i/qVoqqXBk+c+YQ4hryPmY/F2XUeY9ezAnP2/NVLobSuaMuAWywHrRlnauk2UGoZJdBlYVyVpAlxVXfyDAsHLQdEgvChysGuUD8aP0hHO7eHJ5hXgzVvsh0qqwmaNA75pw5DhJcLhJKdkNfEs1A+GDDpdYHPPT1lRE6vvCXle3JIxHDXBE0bpiC8otvmBS6A5HmCPdW19JwOF3JK5YQllUka7Uvcp7MD00rdhlCiI3rMhKLyTQWMegWNBJXykc8NZrid0w7q3i4LSy6se+ZSnPOXisY997C1+a/ClQz73uc89XRND+a7v+q6LRz7ykSdk+LbnP//5p/LVGo35tjQEsPHeGkLhssWglLjG5FaTxCARMxfWMaNBeWepkbREG1C6l2c5oZIQ4/Hg/hTzwyi9x/kXm+1CWxb+wZhoxevZgKL3r3cIV6iWiTFgniwkqbUbH4WIp0QtaI3XB8PwvdAOBgoZTvuWSmrj1cwT5UHxuZ2ntUKNixXDXbo4BBbMAkSNbTEFxk14cP1SCjGJ1oUQkGqMkVhvltTW0UCrnr3xbXSruqNqr/XPIWDwHovDoWgZ+9GFq9+8QcDXalqI07dWLF1eovUQAK9SvmoELuG8fEKokuDjOQMg5eliZRG81oWFygrE6OxzhgLa7FlOdT3WyNk5XgxDzVrZX5Rt/bIu6wW0BxTX2tANZXdBikdvzWJWZETpk36hQ16OxdAtH1nMmHHuOyij9hlPKaFLQdu13fes0r+G2BoZ+I5aRyxsSsXuXXyFsmF/oR/v3/AlhSn+3bo3L3sYpHVFl6uoLE0t8JVRwbNFcTEGh+vhL/Y4HsxjRhki3Ls+ejRXvLnO5TIX5tg9+IS/P3TZXx/ZkPbrGoIOsGwPby0SMglmyx4ESudBXYwMxY5yCkcmROzgVYU9eSqFd8jGXXNy2t643RSUhz/84afPlVqTUSnsbT/90z99SjUq9125+VqM9rbkQ1+psUoJKxsVSGs3K+3UovJALBPnfsbwlHm2kVhoNEeCwCLIQsGo+r3FRMw8GASvDbEYF/2AbyFoF8Tp7BCbjqVPmO14bGCChMbcRtcWt8JapdyZU2hyjGM1bXFP4Tax4T0vpWbeCVpMt9+laBJcNv9RQXH9Chrr7Lrucy4TRaI5W7zREf9wZP5dK3NJ2Ie1pxCf+HVrtdkmQM5c4ECT+y731zyn1vVSSRdYqcQ3pQfTRGc+q5TyNMDomH8MP0XavHe9uhqUOMx+x76CBOMUQtoQq7T6/nb4IAUH/W4o0PMZB0u7lNBl3sblnt7hnCn4hhWgfY+e9YORUFuBRWj7vxL7PYPXwR5rHJi3fi0odUMQfrffKENKgTurZgvnYe69x9yvwFxMibnfsaAXGJYEWNepQrxeVtY65cc4KEGevXOGZxl3vCVLHp+Ekdu9ylDwLgoKOlvFQvrqCmk1dSgHxrueN/vcc9YzZJ6Mf6/j0VRCP8NAuML+WuVy+eCGSEALXBsPoaDwxOObPORHb/M/TQiJXEqZ5XVGE+ZESM6+Ec4yzwzs1oWX0xEWZJ910uD2GKEqkkdH67XaTFeHo/LWLKjW/vtPg0FpUeo0l5RW2OcFL3jBSWn5hm/4hotnPOMZt4h1bVsXYM1BT+L7Bo9ZIZbcjYFAU47kqCu6FrOXisUNakNw36l3oY4GBkVwINCemcBVkKjF43pzKJTQAA1d6AQRAQ/W6hcBRVjUp1yOhXLKWoJ5oKQ4sG29KBg6oUtzNkZnELVGUip5J/RdDJhlv/gaAniFE0G7MUkgwv5fcaTqYLRB2vzKL6vYKYzTO4DGNlWO8NoQFuVzi7D1u7RPh+rxDvFSYcLr2cD4zWuNItomzD3bfc1XYUqFxxSC487dZ2F+FAfMuMbCtMkxXNkqFCV1NXoH78Z6shYUyFrz+4aXMKyuVTCLd1GcHTPGuKyzNcVoauZ+9yjrrb/bC4ruOYRzAdaLxRAiMv8sQZ81QOpfdLMZGPW9NYd7ESbcsGmNYFs811rVKzD1s7Wopg7L2J41XvtxFWvzcKV3oFPYtb4L1G/OKckaQYCmKFiAsgvS1qdj6Kk1UAxyywW4dkMJ6IgxBt+wdA3Ab470q/D/jpkXUkhaI/BXAHuOQ2DbZ6rZKtWvQJ4z0RigKdxSpinN+uSzOMRVrIU5+i364SVF5/bInn1DsW5c5t9e2wreW++EItv3jce8oG+0thjEf5jMHP9v/NZRYbzGvskEzsOCiVJLxrqRaxRiHklG3npdkklCqpvp00fhRhWR+43h03y1dryPPOf/KRSUOvOsZz3r4uu//utPbmPtO7/zO09xyjZMh1U9+9nPPgnkH/uxH7vic8KnPO95z7vi89cbIY3JwXVV8WzyuK+bMIc3KQMesSv37JROIFGATEC07o2oEE33V2StRXdmgSJYvaPCV0raq7dQbNPZFAveouHK9EC4tO4qlTa+mFgE0tkc9cl5Cqo/qoq5dVQwdc/DCGK4KQbKaFOkzGVjas5iFAEn6z8h4JTk2mIChL8S5JSO/lZNt7n67d/+7fO61feulVuvBH9FqQjSGs+DTUwBXLew1EWueRiNtVzXFXzEDcgaIKAoVgRD/UkJBS7r/WpdiOOvgrKKybqsMR6KCRQ8vAFsFSEltV04kQfFvCwtrceLdU8Rc8yA+DcwslCIehSsOEpi769h4CtYePgoscJdvE+L5Nd3JyATuoQlBr6u5rUg+xtTBozeQnoELsET3fY8xsSCz9fDCH/BE6MScs+ONjMIAHbjG9E1TyzaJWD9qzw6/A0sgP3YfmVN+4RzwYMqn9/4mjeHLB7ng7K4WKruJyTjV93H2o7POGOoNWhPt/7t/56ldDpDj4JCmYMFaw7t8+61/2UcZYAQUs7tad56hvDeWuy8a7JC1MsRjkcLTmUX9nKmV/cosFa/7EN0bH/jeyx8Z9IIG/E82NfA0XmEekbjjafHnygghK09YR2Eq/te8TUYsejJ3qR49IFpSxY6V+l/XJ45JCTPMyG8DD8n1MgAUNE1WqbUNB6nfssY6z5KkUrgWybCXJMllBMYQKHb9gT67x34vv2n4Fzj6NqPuYJSx772a7/2NIiXvOQlt/jtmc985vn/nbjaJDztaU87KSImflsKzN7ThOSKJmCAUiOeiM3GtCnWHUg4NGHhZeR5N6lVOLS5d+M77dUpr5gMSxXACQNdDIaYL5R1VncllQmfJVIHpaWMEAB9bzxcswieIKpPKU7eEWOrYBogJhdmzDQrA4pcamN/bzElzHqtwfrVO5prFWTzfsVUuXn1twyNlBseF94iArZNJPSzQudEkHe84/kEZPVtMMCjmxBjE7MHiKSgsA6tI2AdpQODZMVHU45Sx2wIM0Ie46KkqJ7KciU8KTWeIayzYSr9RgOsTWEu8wF/5FlcqQvO4427UrhnFVRKoGq0C4rue5ih9RoJsWx4igWqH4QLt64aCgCVQOj6Cp+AAcJAbIx6sWXGjZZgsCiWmzpqfxOocAApl/bc0o5r+n5P6/b94i0SapRt5+dEVzy5jKUNi3mHMSm6xfu43hIYJkXWHIbZ/TINKRHHNaYkep/Ty+2fPcwTKBioWaZa84i36D/6x6eErnkThPmsOaXb+UAEYA0/6HfhqaWhnt9c9vxNp11P6dKjedeEsVn86MneWc+TgmY8aTBTMu4ooWqd4B3radizh9Df7m3ywzoAqC42a2EGm3n4z8MbPWPXe40f0IHNHHUshmfwiNgf3Qecv7AGntx9PnrWL3yWYc3Y7MN7aUzC77z3R0/af7iCQjlJGHcS7HpPrtSylht0AjQk+7EtKn0brVuII6tjzyGxYDa8XHWuvjYYwsdIAThZpU1sgrm+5b0guAkB1rNaLFyIix5HvPUlBpgGrjZDzcZ3KqY0T0xn4+c2tI2OAWLkFIDenyWzR2EXXun5shw8G6NniW48eHEHG7NWD4AHwbqneChjvS5hIYz61vgxhVVSvNNBgT1X8SVCxRwID1CKWJX6IqRkc7FsCTMMYhWUzsxIOVymtu7Z/g87sfUJMEVzKWQoNLIAtB3DZrVgeJ5HMG5m1ypKXQskq39oEtPwfoyDNwT2Z0GCMFk8dnAxCi6tYF8vhHuFaIRAeEz8q+8yltC0DCAeoe0/enM/JQjNH0N13O5c9o0FZgB4W38X80KQ8WxsSIhHbIHG1pvVzQsDv7ACyv7Bp/rEo4wTvgEQsXul/a47nFCk+NqTR6wCvJP6JeijRgncPYm+GVTwMBQP49iwm7FvraRj9lCNgmFvEsSMFXOCV1JQhAdhgIQi1sPZuGST4NX9DqOx67p7Bu+wH7amjj1h/RmpG5LbtGdzZh14fH3W+2P/omfraOxSwFeR+cSp/uxZK3u2IKA+8toxJMkk8m4BxxRv87X0g08B5C6+qe9hJ3dd4BTtK0q9fUBRojB/TBQUykmhj9///d8/16f491oWdwNxPs6tbU2CA4je8IY3nE+nrIm5Cnn07JgWjRcxLSg2BSehvppiHoc8LQku8XiM3WmieRKkjHGlY+CLSK/1DGGifouI6n9KSQpE7kSEi7CFbuqb1DDxSwSN0dj4BKhjsFOu3ve+950VDUyONVU/SqcsDdHhi/1LuG78dEMljTv8Rd817ptuuunsvtdvVhUXo3Tf5m9rpLCQKYH9RtG0psZLQ7fxmsPCeQC4zRMF04biOel3qb6YcX0r7NjBb8aKIROOmHL/53kjlFaoErybUorhY0jGZI0X3d/4pe+iA6ng1i7GStnAyBeD0L8xp+ZGiG29G9aCl6k+JZzVnVmFlVsdcyzEl+UpVk7oWAdxasXauNx5QXpPcxeeoHVqjlipGoEBdLyeMPgEBfMUGnMdpazxRtPNZX22LutlEIqRVs7FT5BIs7YOMDvWjbWoJo0YP/zMhnwIgv5mnABVtk+tXc92hpZravGi7Z+9QjlxiKX3xPMIi+YOLbNiKXnmsfekPC02g2CnHPLe4Usr1IVc7TvKjO8ZckD9i/fSf8pZn+gougUA3TOxYD8I0RqFWDhuywfYWxRpZeNr6Ep/4QV7F0gA3tq10dSGwvAliqs+UYYoFDXrtmDZVbLc0xg/7dM+7Tw/Rw9m75JFY++rM8NQ5dlVo4hXDs0wrs3nGt/exfuxYVf1kRaAvYagMTGahYXWmL7dFBSxSy3BnYIRE0hQfc3XfM1JoL/mNa85dVS2iDNpbr755tOpmQ984ANPjK+/A8g+6UlPOmMabm2LSSVI/+Iv/uK0sZo0mBICSOYOhssiN5EJNR6XPvUXar6/S492zHlMpAOQ1nLtucq7R3C5kQt7HK36Qgc9h9uWlek49oBl9YPis5X4ar1bXYv6ldcJ0AlhpKAtsDCPjPBNyhdmuDnqCLn/K3Xexsib0PtsUN4KKHFMXZy4+8Qi639p5ilUWwqaB6XvuLkTat2D6ff8cEkpOTwWfR9AmDvS5jpaQoSDmLq53DoYzSuN34bt03cpKIvdAXxkGbD8j5kMNrpP80gxYwlv+ALTwch6duHI9dzxWmyWgVAiJt5YgE9Zw+v5ovTHUOpT3jNhCcDKruES9v+e3X3hpawbuu3ZHUrZia7t8+grem9+609zT8jxrPRd89E1DuFMsW3ftFcphAsoxOzNSfTYtfU/gUVxINzUJul7Icj6AFTJa4d5Cr0KnQLJtx+FL3iTtkQAgS0lv7E42dxe0+car9QKEvV+CPz6bs4IIqFCe7Q5jn/AZ9QWWNr/pcQCmsdzGEMnZj81KBZH5DTgwu32Ek8wAauv/dbawb+FhbO/CSsCGZ0LYbYmrXnvac/zCsFysMp7dtf2vVPQeaDxD0pxc8KT0jpY/97fnlLQkHFpPepnNNF7JFK0Bg7hI4CFm3jG6l98zWm9Mq94eXv+0bPcc/s0Flgz6e+Udt4rB03yBP0/l963XQPCvz3d+OtDMmQLSW5BPWnfvO7dKxFh+R1aJ7N4G5uj3hFPlvm34fTeZWwU/97Rfd6xyvSVoiEfNQUlgZ1yocGGPPnJT774oR/6oYtXvepV51OCt+VNecADHnDq3K/92q+drm0gbbwUlMWY3NrWBgS4azIDgKXdRnhy42mUGzvbWgcRWoI8RYsw5mp3GGDfdV+YiPrLKqbBI07a5tYhaKHaVDYJUCrAVAuY10RmUoTZkeHwATWCQ0GcFltIiZvZ4XrAqcqRq7ZYXyPYhE7Xqb3AldhcNHf1hzejjclDJT4bobahKXS9Rzx9MxfMQe+RGw93skWkhDY2JGaTQILXSlUnAAjwBWKyEJTMX3e8Z9cXGVAbjmENOwyNm7LvPQ8OpHlxYjILob6gmzZr+J/1nPmNUrNWkJDcentgXHhcANbWRRytUy7Ro9CSQx0VTNJ34ERMg+dlKw2LQQtBriubqzfGGPMHIidkeOP8y7PRb/pg3Vu7VQDXYu/TnFDAlfZfvAzhrWqvkAXjwZoCU6NpdMqD1bjUPHGSdcJqFRfvJngXiC8jENgQo6ZgYPxbGK81LAwqfRYf2Iyltf69u3kX8qBAbJ94h3gqotMtVS+jjSCN7zk5mtcBRkFYYA8zBCJ2MB4hFI/sPgXn7A2eLrWger/DWGsELnBr84Ofy4ijwPbu+ik83po6DgGfjX8JUfOOWYv+Bjg2P06ljh/yinsOnEj3yd5aocvjQCGFp4HjceZTrfdRmHm5pPN3fTxb9pCK3fBBf3/pCZTqXn+9d5UMx1TwgtQXZ6AxAHgwGhuvaGvFGwoCwVurYrUCnfWpcey1DCOKib3VOjEKe7ciixSy201BScnAaK/U/r3falmp7373uy8+Gi1tzqS0SI4f5y6FfF73mw2N0XOTYwqu6foUB7neGCOXqE3DlbnFfvxGYBzjd4oYsTpiFASHU2UbB2/Bbrh1IxpDxBODgcqu7QnA3h+B9exCUl1P45WhsnHUmti4+XCeBmsfY6EAYLbcyM0/a5FrXpiBsKIkbUXYBX1S/AhQ3gSC23eECLAn9+MqCU7Rra0w5MlYQCo3J4WLxdbztgy9j7EDnwKlURwWw7PjgokhUDEWaZ01yjTLxLk5O+8+W3eh+SawKQmsKkpJjWDauTRP5mdDbwu+lt2BftCkfuwBdviDPcRyZhUu7kHfZAnAhhHYhKA9LPQBL0Iocz8TuOvi7v8sSGBnYyCw1B1a0LNnLJh3a7WsgrKxfWFXTJ0SwvOz9Nz3wKrGszRAMDK+WusECUOEotue5T2QTWgNCB7fr3veuiiTYByUKuGUBBa6Y0Tt0QB4r7PAeFQBevFc4wGylEXFmydzxZ72Tn3vHcJilFB0Ze3rD6VFgoMCkc4pE8JYuaDfvaPxCleYI+8CDG5e4XMYECoO2zc87n3Xs4Fx7a3aBy8VE+9SCwkvRdu9QymF1ktzgOzSrD2D3iVaLA6LR7ln4iH4I+97z8LHty4QWYHPoFV7j+F5TZzFk2CvsawWvNQicEshHkzRZgKKk8IHqIXhpNma8K7lSkvAE1gBgXfhHdonFBChd09eDWlXtG9gM/UuYBbU1ajV9xSC+gk7g5Gx8BpLBCCljEu1e2xqrnrvcbaH827qT56RLQKGWWPUvEXmvHfIe8fUIduzQlkdX/AFX3Ce+zYRRr6uYG5u6Wqr7KxySSjwWtX6vvG0jlvPxVjX9W/T81htZpD3bRbM4l/MY+/gzuYK5r1RAXatDHRJuKKBGiXVs1mpW+xtFQUekgXGEezCCjwI0YP+iXljSr2DxwHGoKbUthCnlHdKNxrYdWjNWJ/97gA9dIXp6rvTUVdILYiU8DH/9Y+HgjLdPHePNFpzRdmyL/AF71lrMtrnzifgYr55GSnTjUmJ+w05ULxS+BcHtnUpKLdoAh32rM/93M89e1vq453vfOdzX+zF5pWRk8W9YGmeEQJb6IewaC7aa7xz6CFesnuaJ62Wh3NDpjAg0kZ5U2QHNc+O2LBmNYBP69S4+gjj1g/lEQjg9TQ1JuFcwFd4DEXCuochxxPIyKT8wbrU3/6fUu898EbNcQoIvB6ByvPcmvX9Yg89V5i6PtVfMqB+wftQ0njvnRklUQHeaLPdKKcfuAxd1Q9HExTqbB7qH28RfpJcsm96V3y350RLGdvNCSPTWJpLYxWmp4DWL1gdSnPznBd6DX91Y0QNKIy1rhGFkPHmHLKrXkFhGbAgAuZGNBHk3e9+94u73e1uZ4bUNQpTWRyxx00b0wj5RXh3b96fFjRMRLFIFjsrR0yS9hhRhZHhCt9Mi0Wk61ef8Ci9u3BSBCWE1QbrfazZ1bRb9IjQWFjfBByrjTux9+bKBLZSSn0BntImufpjYAF5m+NNRdx5k/O+oNrW44u/+ItPG8azMcLeXXitjcKlTylYwKfaMtYhQq9hxjAZC+YD/m0OY6S8V4skh9kAUqXpG/vOY2MDPFzAYN/F5Jqn+rr1G9DpglgXkCbrRVaOMFJzsiEktUscpKZugb5SfITeajIUKJ1A2ZQdTI6CRMkS46fwWhNKSs81Nz2/tfOM1lb4EFOiqAlxAG5Lrd/qmSxJJ3hTnqLvVQiF9yg0BI65qA+8B9aKwqRvBDHPFkxSc5Jgb76jMy7+fqvvrTdPR/e13sI70Xr35N0159HFphl3LS9c/asPYXoo5TyBhC9BlHKhzwwbHqQ+DgftubBoQnV7LAP+x6MgdEpwN454TgYDRaQ1cBTCHifgHDA8rGfEhyljezijsTJsNlTWXG8oWZiVV1zIZ9Nfhas8194GaBcWaRyNG2YLn+5+oTzA+n6ncMFLUNbND9Az5YQxBlekgCiZQKm2n71rC1FuqrSQyN9f8sjmSmYnT0hNZW8KUL+lHFEOoluGYOHB6LZrGDjCR+az55VMYa7RDZpZ8KzQKfnTtY5T4IFhgOMhSuRzLNyadod/+5/FZP4TNi7fJzzhCecNLw4LSJVALE7PGpTdIoTRpFfILeUB8LMJBUTreSkglfVX1IrwbjG48lsQisJasxajBZfdoJqfFNw2b3gTsVMWplAMC5Dw3PRHGzGFI+YWk6xvNqSMjLAbadaNL82XldGYCRX4leZrwZlt0JS4mC0wVvPt3AXZRx0WKYunxlIVekpZpGwBLVNw+sR4A0s3BnNjvjDPr/qqrzoX91sGSyiuyxRDJGyahzxdffSzd8kgwoSjmZirdD3roc+8CxsC4j2BvTAvNr3Q3GafUFIpH4CQLHlCR6gEnkdbwCUhbhvDFdS4ltVEAGzzTNcsTmsL4FEgeIN4J7ng7TdjwMzF0Nf1uyBKVh7lZUHD/q8KpnHBtCx+bEM7KwAWy7GZX5uKzaPa/ljFaQ83Q+tb9t/+wfjxF5Z5+6T9lyLfezF72Uq8Ks0d4Z7gZFlTYBkN9pHD+gjAFNh4TPshwdMel8EiVFBTf4TLfueEksnDBUMXD1HFtb3Jc8sqx6NksKkWqnjjrjsvc9lxPNVCHAwYio5554VFaz33oQ996Bl3xXvctepTlXghDIEO678MO8B9+0rChEKBDESCdr3IUr0XY8VTpiI2Hg9vw5Mg9NIY0Kb+LXAefW2K799fKo09VzE5PA2UgcfQ/luPLLzSZpSat80YpMQ3BtmkPPGMmy0gKYsx+ZUTINnR2NTLKpOTkc6w4tGnSJZ168yxq9aD0qaUwSCjB6LcYjZJcBA2fxPUZAEDyWiJmBLGSvfmscilJq1q02tZXk58pU1igKw7LnQgOX1okaUOsygJCS48G7kFFtcVhuBFiBAiXiCzBc/aLClAfac6oQqb9csGSsOOAcAsUOJiLqy6NnTXNeZ+p9gB3bJCoee5SLncCQK4HO8BfLWhMS/o99YEFqCPWK4wGuYZkyQAW2/KB4a7KZGYECHZfJU9ROmxnpQIQpsys9Y8YUgpWYWBMkWZoPxiiKzlxW1sRdpNVYZdImjRg/93L9c/Ru6a9cZgZivYMUhrskyNZ4LQTimmxAl9bV887/ie2oJUeXL2fZ6jMNWmh8JtEULo17wRvkCL4urrtUTL0Vg1l+IhPBCAoqxa1iZLUl2KaAn99BucV78J4RBi9avveENqwKCe3W/7uwyymvkl0ACfZRKlnMSnADsJYAJqvbOUbKDn3mON4HR6nxT3/s0Ig33rO4oQN37jkDUCbMuzYV/1d8YRbCBvoXBM3zECKR8UQPPF40Qp5QHou/oY7xIego0Q9rVOGUlwaIwK2THWvO8oGEIezdfuRRWZu7ZxdX3Xxafiw8kPmaD91ndL790XkL5+87R0f3yTB5ei8U+X9xmbd2+6OHpbjxsjZ/kD7M4aNTCU9mn/D8BNmSST8Pf6lUKG/pvTlNbFTsnQYvAYg5Am7/WtaR/XCkoTYnOm+Ylr1mIiCW6xfNcjpGqCFEpp0XtGIZviwv2bVyVlpw0FZIVIxWm5gas+26ZF1BZ+CzQpOw4gZqHE2FMCoPLbLC1wBNC4enZKUkrAgujEqrntueRZdVK/XFM/hSsAIQkf7jhaL09QGysFQYw/YszLwBUORd+cNldSk9sciFTIgxKIuXCJd9173/ve0+Zsw2ZNtnljKK1BHhyMnwuXAG4dpe21bqUvxugg1G1gMVZxYYBfeA8ba4WweCmmTilh7WFyBAALnSt/haI554q2Qfe3GgUCYFEYg+Ih+4vgxTwoF1ufg3KxoE+MX3bNMmKN14dC5XmUMcqxEJVaGh8pVLQgRsqDdVnlQWYW4Qr1v+FD4+D9iGluOrfwJ4A2z5W58GkdEyxhTeAwCD4eOUKcm51iSrni6RLi2rWmOLg2S5PQpwzxVng+/MwqY0rdK5ve8yj8FGZZLfoLm1V/joaVDJ8Fbpvr9nmCqecq8AgQvYrzKp59VOFG1w7SlCmkpkieaEreZjMmzLPYG2s8Lj7SeGTR6LfQE2HdfKlU3X3xHn12feNPmXYcA75mXzAy9QteiXIvm9B+wrMqPtq19TmZgU6lXefdcj9P7Bd90RedaJJCVzmOeGnjrdXP17/+9Sc+WB+a18/5nM85ezYok0LksJWM4Nag56HxronuZIMKX1PYjBefgweCESKzGANCy0L2vEvNce+tRUNVc49nk2fd71iHrYp7TSgoCbMmqTNwECQUecxHvvhuTDHENsB11113ZlhiuC10IYk08jTFJr3iZUCrbRoMq0Xunk3DahO0IBFqC9WG7XkpG/3OUu/3CL5/W+BCPfUroew8HCW1pbuuhdFz3/nOd56UqTZEzxbWah7qe240Z/8Uj+xd3J4RfARXynjEh5C8ozlrszh7JoZS3YtCVv1GIckKpRT0fUyuORUW6TfALGBFAhjTaSOyZFU/rLFOFG1qDfqujacQlVBRTeyXotg4U2JUAe63lBhpkv1W+jsMjDAMC+PoFeCp6f7oDNhTbQ5eow011FjJC/KsYWI160x4bNiwa+ofADGlAbAWE4E9qfWMrt++E77mOcaO4TXO+q/+zIKGa/A8vYch4NlHZUz2l2JsW9Cu/dK8Uxxcz+ql7Ni76/rekA8hzhCwB+tbe8Ppw5QTFqk9igE3zvZc/YpOEpjtxQSP0Ct8wNEA6V0ZFy9+8YvPFaJvuOGGs5dxw0M8FPWtd/G88l4spgy2i3e0/uU2b93aJ/Wr+e1fmT3t1RtvvPHErxp7e+t7vud7TnuUB5YnhUKO7pzx9dKXvvREA49//OPPGInrr7/+XPek/sdHovfCyo0/3lgNK7gGyvfW+0GbsDoMiMYffTSvaphQfPA5fNWaS3XngdHat+ED8TXAVnWC6puCnkJDKRr1/+u+7utOCoSjBJbuKc6bNfWyl73stN/jtRUljZ7j8c1HAto+82Gc8ghHi29729tOc6z+TiHu5hQfYgz835cnwgv3VL6jtYwXLwAdP6McND/3v//9T/3r3fX3da973cWb3/zms5JCwYfD6RlAuIttkQoOi+QgUiFrOLzeL/SI1pr7aodFmwwwZRCuegWlyWiSZLkovmPjQlwrjFZrEh1wZeEdZERD7Rksnpi4XPiYEHcdDVd6Lwaz2TMJ0xal93CL9eyYn/ocbST1SwD5FBNLWSKsuYuFC2BIYlhd1/c2Zf2NSX7FV3zFiRgccii3nkekQxxlLtn4NpTDFiHcm9PGmpafh6Pxpmhx71mD5qjN36ZoDmM8bf6NY8uwUtSr3wgtYC25/YBrjVEaZcw0QSIM1jqlnAEC26DwK723/juoqnfXemYMqk0ULTVeignlgUeJt4tFQ+AJIW1KO8YkFk+pWGvsiP1Qo2RBuX2n9k1jZQ1rBO5a3hs2WUaLhnouxbBrnPLdu2GXNhtowZSN0YGChH4NHmGB35RRYUaAYMo9TJXUen1dL4l5wtQWeEuIC9kIgbKKdw0xcBY5Wuy5MXqeudYvrERKN4Wq+d/sInNrLzJ0utdBl8IWBFP09trXvva8Vr/xG79x2nvtnehSrQ8KH+YOb9DYMkaK99eiv/ZEfITQaN7bZ+EsVA6ON8DVUPAWS9S/PJ4V38sLSSmgdMrAwUcziMKCNW/RS/suumDIoN/FR/E8NAcJqsaW4hOfU1gMHw0DltLXfY05XlNpiwwtKeT2qDBjz68vecTzxvbc+9znPice1hwDbbf3G1t8OZ7bnn/Ywx524jPWSk0XODPv4hFsnZ///OeflYjWvHlLHpSkYO0oFDA2/dbeouQoqQDMr4gizIzaKf84xQuBcIVJKb88Q0LZDPLmUhi8f+Ehu7Y1bdxCffW1++OrwtAUfHSpptIq/jLO4v9FMXjNhSh7fsqXI0TW6LjqFZQIkOC28AnAJp6lwFvQBui7FkHxGdgRbtYWLSLiIoNO7x41CxL0ac4ERwTJrcnd32LBnbQRlK/XT4VyCEAH8UkrY1Fww3av9Fkx5DYkQmFtKWzWe1QHZY30zM0eAHRFNP1ug2wthBiod1Caun/rIvBMSYskAAgfWrh+EpB9eL4SlAuiikEIL8VQYoD1o3f0ocyxVFnS4slAcntqbNelKPJ+9VvrGBNvLrNgzAchh+EQptZEKOaIv4AXoYBwrxO2i51xXx91aXhZ0GBrSDGRiYE5YFxwI/u8o6KFNnloMBf9FP45vv+IrTIf27wL7a33qSb1ntVkPjFXYaJ9rjUQ/mmsxkHgwrbIciLQKY+rzAnLWIuaTJmEi/d1f0JRSHIxMgS79e0dKST3u9/9zjQvHVrYSAG23iPcXLg1vtB7F5dmbu3LrR/ziEc84qRwCEfw+vI4tU9Z7mpbtGfgVdDKKlnWU0iKsspiXpqWbpsSlEBOKUu5T0HZVN8FJXsPYGm8o/AR1/96v7bicg0WbSuiUni8YzFl0VjKCKyMtN2esXMsHIIGUraEbHkNl87Rvb3b81ICa/iZZ/UM9y4d9+EVF6bfrDuGmX2Hbv/3y8Np9wgDNYd2jinp6/0VwkrhUF2bgmTtlXeAW2NE6Qf+cdynQn4iFsJ58JwUPC2eK2Wfx/iaUFBsLu5IZ7zk2RATlcoFmwL/0YZWpKnWBHYvrVMYo3c4x6QN3/0RdRuaq3eBVH0nZRfSutAKwQUXIjzQwkeIKSiIBVqaNQiDIObdPc7l2HTJnsO93r+5A50Z03izTGKMENkJetkvLDfhEv+y7CmAhUhYD0I3m4Hi/KPeGcOTygyfIcuFIiK7yBHmGL+S49Kme5bMgrTx+sXCE+rhmuz/fc+zscXPmiMWRs/JNcvVzN2+QFcpc8Cl0oL7v8yMZaDCYzYj4Y9JHsMhGAGwt5DChmQoOstsu48yvQrkMtTjczCSVWb2/BqKKoYH2Ky/q7SsgFglzhzWMDPhreaOd8n+5VlRrGpj98aCma7HSB/RnRo3xsprs16XDffoa0IWcLt7H/KQh5zXrmva+xg05VQ6NAWFIUMR4EGiLPb8soUYDAn47rPmm/pMKPLSCoV827d921lR89mxtK950ny2pgYXPeXHvDZnFKWjUWFtohmFMPNkGEONErWVbY3fPhLu63iOvFNCM4qyUeQaR+/p2fHa9pcjEYBNKYc8TujekQMpTvg9+td63p6R1dr7P6VO2z1ivSk8K2jNk0qwey/hLluRcs0rhlf0mzkAkO0Zf/RHf3QLrBDPy9KadRTCqqGJ+p6CIttow6rwQsmqBdGvBxONMwT83t+MSny7eRB92IQOyRzL664ZkGwas3DHgx70oDOALMEn7knQmhxgL4cYtqi5StsE/T+hblOpo5CSwdrPddizWlyZMdxmUrNY69y7PZt7dV3MNOE8BV3TO6ULt9EAm7rG9zTnlI0sPWeN9GxnlMQMcuflyZHGmBLQxm+Tio1zH3Zf/dQfQqpP3zc/rKvmjyLF29PzuwZjyEqqUXgAWQlSTBhWpethSlIYAFsJRoxTlo7wG0uo9zg3CDMWtqL0CPn0fODY7hdCcH5J16Mba9lvC/BjjVPsMBuMX30Kgl/qO/rrWgozgYpmVcPs3gV4t67OkZL26+wkTLT+A17yJrGo+hB460XgSYMNqGGQ3MnGC/TKWmJ1NQappz2fIuo5NdYj8CPhRciYKxk2NbSPsQOXepZ/eWN4MNTNUFVzPTO8RkILm869YGJA4P4l+NFibdOWt9iZUNDiY/K4Mhp6Tkq7cVDc1vNkTvbclAVk+wg18rRRZu0zis5iqsyHceJHwrvmgRJasw+EwFfo84yhhc1YWwyDULbxoU17tXfER2Tj8GQRjjy75o0xQrlDf3gXRUw6vBo2uw7GZi3RuTkiuL3Ps+H01rNAefc9we6erT8TL5ANZQ5S/CgLBPi/XvJIXrT13uk/ZR+vpmBGM8nH+D7jOM+dea/fyQd72TO8bxUyWaDA4xnTrSUZKgGA9zq+pNZJz9rCjPb9epmuWgWlReY+XncqpSUvA+2Tti6LJk9Jcdc2BKKX7bHgLAyvBjG+hJniQJBipmLkvS+Pg7RCHx4R2nGgvPqb5ycicj0iX4FZA+wVprIRA0VhSEozO80Zg9jQQ+9R5U/6V/cqSiRuG+NwAGONO5eb0jzJCNjYaP1KmbIxjKfGok9BixnJEojIVe+swQiljKXI2aisf2E2XjNxUlaFyp3AwGKutcbQxi4MtzUFhLgwczgIVjylpbbroKAcgcCTlvJl/N0r5FVjJRNA+kzoUeTUslDhEXOuEf5CgYQ5BX2ZK+YGkCidtvlVlZjHrGspB9GRapzwPqxO3iEMUkjGeSHWS6jLIW7CPhQT+w2NY2qrSMKjSNU1VjTNO9I88VgKcXhH9LxCDZM+Ws5rTKBp62juudnNK2XJc4UC7T3M2bMInVUiFqRM4F4JW8Pd7l3H8N56MygaFKg9jXrH5/8bCrMvCPD1BuJ3PHcbZqQo9a/n6Lt+oEV7arOUVonad66HjdFmP5pnvF/24Hp6a0eFED82j3j+ZuYdDUxzZd3Rae9TvkH4TcE4gG6KD1xbtMlYwDf+fmqhrAeme+yZnscjx2NsPimpapdQbhYnRxFHYzuO9khy1nlTlGag5k3VpkSmFPVdCgwjMM913pz6R1Ze9QoKN9NqfjYMzZfLVYiExirUIzMB46RtukapZhuKEIVqtznFVNeqAEb1DkKsfqW9IrIWu4VkibLW9ZuWayN6RsIQMK/NkPDekt6wDdyomNO6zpcpUlJYMNKJpaDR6G2S5mSLGHH3YlYUHxuBdcnLwfXutE0bxzvWM5ESQUDzQCD0dXnv/OsDZgw3tDF8m5c7k+drQa0YJsEqREYRwrgJow3xsCC6nuBn4WAIsnAIEYLdO6zJ1hThViWYKQbmGC2xxgj3Dbf5WxhRps6xdD5GRTkCAucBcD8hhsbgAewr9Tyk2to7i8+R1t33i5PCnNGS0tqUJ/PC+rPvzAkvjXckOFZZR2fmA8Om6KJvIRPp0Ovu93/7hABzL/rc+DyBV3MNoSUst6739X6sJ4NQ8f0qK4DjFPRav8ODEVyUWMrJGkSrqC/mqIZfWichDzg1Lv+aZ/KuoYv1OKxivnva/jC36GfrKmnWddfHWuyc+SwvIQ8obA52xffWI7cNLo0ncAvCdT/voYrg+kJBSCFpHuIf8fIPfvCDJwMyI5jw7xndG++3Z5IrquSiXzyKkcJgkFCh1EDekLwdxtg8Sszwt3N/VPLN2IuXejbogT2fIbzp2kdD4CPN3xXn9OLjuCEAm221dlaHuC5GZ5LkYyOKGiYsk6RNLUWP1XaMLx5BZzXCeNPgxPOB2NQs6W8Hv6323fPqA7cZNxqLs3sjXsIvwq1hDPqkXxuTpugsEG6ZhbQ+JxHDoBxBUsJoC7ysLZiwZy/6ftM2jUN2B+Z3LDJGUBgHZWEzRhY3Ulths9VcF3+AcXqX7wnBtVgx+tqGg/oefqF5i564g30Wf0IZWSHgXZiEGG+f6E5W0mIwVAVdxbCPipP1UbioJuxIWYPfIRQp78Dka+VsfRAh0k3nXpd2c5UCg3n2zhVA9uwWkVpljlDZQ8/8TmA3v86vUtyPgieEBdCI2R7f0b4+xtt3LdBw80Uo6Zvf1hWuHZUG/7pXWKqm7gTlWl94FtEomvVsfGY9CugXX6KsUBbQ/h502v3CH8sfdm8eFZXth+/xnP4GyvdeJR3Wa7FzpN+e60PYbYgF+N288zaYgw3TfSRBeFwfis7ie+wr96slRcjuemuUghRfRz+4juLmBO/4PSV3PWoZmcK0rvnQpSzyrK6JrhXbZLiQXU5btu/sUUpTig8DBzB/IwfNeVEF4bM1+vGyFJT+r97Mhs16Ng/oQhrWCOl510SaMUUE8UOfb5E0zD63E/d+10sxPrqyEXDXRWjKwyMQgFgbBnOgycp04cWQfozBAsZipMCWNhzBemRCioatC9ppoxEYjMMWnmp8AUETGJQswpw1gklF8IWawoMgvsYpZIAxr1LWHHPZrQAjBIQlCqdJs26DND/cj2KziwXgHVDQyzk9fbj+WTjSR5UZ5/GKGfR8h45Rutaiak49l4VCyGFEGDdmS7gpKmU+WPMEIka7wohnZ93zNi1GJNwiq4JHidIJC3K0Mv2N0VMEvIPyybPU/1UA5mZfa2cZ7AolzNrYNszAswhz1Dq01rJkPIuniqDZ3zwDTVF6KI67t1mnzkHi7qc88Kxs/62LbLgNhyxDpzRL6eWNQavti/pQ3Qhubp9V+glY7zBXXaMmUzTac9YF37XRc2OOB21GkXF6D6Vmw0o13kleAZkxBHL0Gx8E1DzWYWEcCGmhN3vJeIVXmxdHgDhOQ+gCtmTbMYS1xhQvMppzeF77wjicGeQQPGnkVwov+Z4BsArRHsiHTypyh5ZVcA0rwpOwz+09rVNHcqjHYt8HNShMUhi7/dC7CnvzvFrvvCDC0g6X/du//dvz+vUJBtBcRvPVXKm1Pk6YD/jbb11b6nJ95Z3u/+EQHSnSO/AD/K4xVESuvgnz93y1nBjTjQmuZ2t0Acs21talfVKJDrADmMDm6KpXUCLOZcA2K+upxY0wQo5jJHAoLZKTOC0QgejMnAikuCGLBjHRiNUYSej2HoCk7ld2f91fLLIWrffX9BvTgiaHkwCik7dOEWlzFtPjHaBomQueipiHuiK8ODXWDgyB8E9z0rv6PgIn3DFnm1HYR30VioGwSdfWN3HHfo+5KMrWHHRdv4X/cJ6I1O/GwHskk0AatcJfNZVDi3HWD0C71qJN6wTXUoiBEzFxRap6Lk+RsJsGpCpc5cA+Hg7MTV/VnbDePD9AeKuwbghAXRLYIkwYvSqnTWDArKxHDP3oz4ZM+rd3U5CER/tIgdQ/VWZ5fghG/1LMVxGlPKvMy6unjDtmzrOorLyw1eIx9IUQgXES2lFkzSmwPjwFe1bOhoVqK1gaB7wUz5Y+CnNJ7SVEa8DGPT/+YG/xnNrvFHn3ryKnRky/R6v2P4PLibiNX5FCyq5+7Jroz3p2YYUYZkCYXU9AqfMS/REgG1rBswgfXhNWNaxcz9mUeKFNiljNHG0I0ZpRgigxqywxluAs7E/KG0PJeq5nCaau53S/tWZ8CHN1bfyV0kxR6pNXRH2S5ALFYr1U9mSYwxItzPtmAHZ/+6NaMikKQMM9u2q6PBz1s/X4Py8NMyFwByeqYP7VX/3Vt/Cg8vAkFxXZBIFg6FVLJyWmPju3zTEgCms2p4rmMTI3HJpywrNYf71D8cL62nsojBIfnBDeWl0TCgrUstoeQjhNqEJmlIwmsklskzptlttKCKJGUycMmnAMBhjPR2uhnV0RQbeACeCNu2GKUo1V+aSF2pDrskUY9ad6A4ql9bwIlytRdk//X/Q8d79YJq/C4jA2pp2nQ02A7qtwGYHSXNVPDEVcW6aF5yyGp2swbQRtXuFrHN0OlIrJLfCKhac4kQ2/72lOeIIoQ0o7y3bYbAnCDmaHB2Vd7jWCjGCs7T3c2/AarYtzK4Sm1qLT5w2jsDSkIsICscLQSeNGP4T7hsAIps1K4BGo/yp5rvcGc+tZMf/mSpaW1Gz9JHA39VGhMFip6HpDlZ6N2fUs3i4p9Quk1X/jxRh52xzKBnhKCaN8b7iicbQ+vGxbD2NDg/YOgbaWt4KA7e0ESvsoxV3xQDgLtG+t9/nmi3cUXQkrNG/tNYfhtSdaK1VWvQPWQt8ITfueJ4+3EzhYn1R/BYLH0xgn+OGu9yoTvkOH+k756bdoJqUuDwFleHFNy29WYYWL8J5VMHgp1JdSt6Wq1TLdZCVuWIhyJcPIZ0NBq3x3beuQMqjKa0XIGoeaHwwSitTua4Zr124YFA07ydneoZwzFPAl5xn9r5cHKG69KYp3z3YUhvf0Dpl33cdL2b97GjRDEnaFIWyNNjTNC8tLx7PNu9IecyQMoxdv0y9efaUAFoN1VSso3IoL7EIQTTaG1SQ6/txBdjYl4sFMYoIWgHDqO9dZuFqLBVOSYLKBZHJs39ZC7fl7GJPMF33HyBCFflroFZ61BeDtZuOGFj4QH8bMWWxilkrD1w+KGsWP8NzYcvNCsK+wq9mIno1hCMP0L+VEbQFMzzN3LWxUoNtlLjVVHhurcurKRgt3mH+WpgMVeT+WaW78mpKnDzJheICEnjZNcwGP1uWooAgBsC5c2+8qWvYc1u5iIRZEzHPCyiUcKVriyQk9nj+evuiQ4KdoYJT9niBYobUKCoHG64euF8hMsfMx18YsTEN5Nv8rbL27OdnU4+i45/h4LoEECA8QCCRKkKzQIrgwd0o3LwHL2zkl6qyYW/S/Ass6rGC3XluXpWvMHePKHqDsUMI3jAUThZbMGRoC1sZLGApbe4PHhUdkcT6rlC79rmFAiaZo8xhFrzVhKwLQ+HcvMDxWEfK+zeLixTTX0ax9Jxyz+JS9fz14iy9Z7BoFQDhHVqJQvLVdhXSfq+/ChQxMBpc5o2zLLF1ANBlmf//L5Tx1rUJrvLIwXYvZ2zXqnvawQmzmuP6o/aNGEWOxdyzu6BiKW8OpZ8ZjU6QYNZuBtfCLDeUeQ31XrYLSwqqsJ8a2sWYKQovV2QdclE1g1pBFMPHcaWKqiIn1Dx8BMKuAWC1iqNRyBL5HnmPiiEBRNaXluy8PD88FoFp/uy5CzbvB09I4qnPS7/1GaK61LjWXAJfeZryb6uzANR4jWAh1ZnhoKG0EGmu2MYr5N3fwAgixeCSBESYmawuQUroa/A6tvD7C1zg4rrkVpmNFUNxaT6Ejxdx6Z3MGf7SMsnEI7QDQLtgXE6UwYcbKSWchJvDQClyK0FFzRlmrESiYMuHU31zglAV00TzV594Xw2+OstqbM8yK29w6b3bUWkaENUuH56Pn9v7momtSSCivlAiZAxQu40BLXOwEuTOdgO/6rXlTeK/nN3fWwZk9XOcbRsJQlW+n1PXM6BaupzlSmI8gbG6EBft/1iJleENXlLsalz9aC5PlaIfms2dUTZXiv3ucoDuGLqw5hYvB0LXCQ3lPeOJUneWBWOzSPp9Ce6VQn9CvMGHXVCjNnFG2FwzOg2lOfI6KnPebg+apkAPwY2PbE+LX28JzwVhYgPyVFDs0G/2pr0RYVpOqRlnY0gwbVmUs7Trgk7xQlIrOJsN367NTh60NTyyFdRWCo9dzQ2I89sYVfsS7lYFX/0do7hMu13vBvPbFen7QQA1NeG7Pojw4mNC9vN0UXOuxyukmFuCJQvr9tkeVSK2mzAHmutf9MG9XvYLC9SnOydpswpoU57NsrHALKEX4CQEAnza00sJAiQiZV0JoAKMIU7Fgp1oblKab1RrDwTBiopgNwsBEeV30B4CSsHvPe95zC+s1oSiFzbPWkiXoV+BCT8cUWWwbb2RdwK8IgzSWhHLXsYrVHamPjdd5MW0075XeGMOKCcckV/HrOc0Jq8T4mu+EDqHN4jWP8CDWxcm8gdgqRV2fFqhHwPFAAcWpdUJg19APL8AqL77joeJi7W+n2sJA+a0G20Q52VRsgmEtFR4gabRowvX+ldWDobGQV6DwjDQm7238Tl6l6PV99MpjQjlLKKPB1oYXg+eEQBfH1ofmvP2FRllVPR8N9Iw8jxRo44QbQIvNtQbr0nud+xSNbYn23gHEjPECWTIwrCt640klZABppWwrDGje4dYIXSEYgoh1juGvAUE5Ew6zz3kzhCO7D/2vt0zfCVcWsvnZglwySCQBEDiuXTAkxc5eM4ZVHngACHG0B/AvbGAv85IQVNbXZ7MUpQ37P8+YPbqeCXSIJxDO61FZob6hOzxxsUrKBqgbxbupz3CB1puxuIoH/rFrjfbBAOI7jDvGQu+D/7Oed5gwsTncPYG2eCo8S5KAI1b0v+/CpfCKe4b9qoBlhtbO1eKvao4l0ZctZNn71bBaDxN+Yt9fEwrKuiZr0noJCdgUhN0kCRnYlDRGrrZVXjx3rZbN2lhXHtcWl6/FFSqhHBD2i3vZQ8n6f4vtUMLGEMjXZsB0NqsDAMrGl91DoaJ0OJOm/8OCbGgCSI0gNDbMFlhuj+bmvTE/zuohFFnRzbu4agRtLniqFO5abMW6XykHYrc9R9giL4DqwDxXTp3u+Urr96+sEptKPFlWFYwGhZN7dDcsVzvBU2PBwUc4a4XnAU1hxqwXIQTCFZNdZc28W1+VagGTKWcLQBTGWlc8hrl7x1ouMNK/GB6F3B6SPoh+7BvM1PewBP7esBnr0YcXyd5Y696+WI+nfY5pb0r/7kHM1boJya6Vh7aAGClxKxQZFBsysYYUW8ri3m8v2au8DOv9WNCme7j57SvK/NIeJcNcr/LpmIxNIiCUfRYcbK3grFZh2fAxPmDNzYf3WBtjQB/miAXOuMRvjzgtHkC/rVK1As57hEiExrZYo/soccaKfxGgnrXvWs+BtVwjj7JNWVxj0HiFv2QdZejBbPX+vuuaeNox1PbPE05bz4f9u5idlAanWTuDLCUFgJi3vAafYj1XobbelPj1sCRXSowIhyV8GsC399YkREjxx8sXD4T2r3oFpSb0IBXUZGA4G0tbxltbKwqj2fgn7dqHK5ewsqlYsIh6q1eqALjEVttQ1LofF2BHQKz1453rhuz63ukYawyBdYMR9Z3aHSzwjeELn2B4xkGJ6z5Wpc9mxQB8NZ6s4j6qVS5T2bkRUsrS7pqEbQqZNGnxWZYqZt578jIA18o6EY+1CdY9KSQms6T3rlWGnjAZrui1jqyZezB0oSFzv2W3MUNMYIUMRo3G0OYxXZTwcg+8xPZnlQL0tq7VVU68Y2P/fnP/0aNlbnyHqWOSfrfHzKN53b3I8rNG5ofgX+UUjR/3sz3stxWma/3piz2xFqrrXMti1vx/x3UUqBRBc+pZO59rwRM21sM+3XduDQmYIMrbsV8rFAkTyuLuOwqmvhC0lJ0EirVcZXZp6BjmsWYL1KSQLx2aIwqYPbV0vwoKuiKc7S/Ptw7bFyXVgXg9b/ms5+sj2vHM5bHGfrT4rWG/4YfH/WVcQrjxt4Q7ALQCgoyowNhKFPSsY7XZD12uC4Vrw5RCnGUyAp83b80Hb2+f+HFQAbVpAHnN4SpZx+fDpzSODMLGInOIp50hkfLSvYxBfHBl7TWhoLCuxDwtJO8Cl/cye+EBVjslgDW9TH8JmDITERGui7ewqDwVC/biHsfcW1QbGOOjkPC6sOylcMp02Owh7+seHhEC0qZlSSvSpfBT90XMGDawlU1KCTJuLkIERxgqlCWbqDAO5SSUfX0qg8r4e2baNoYruyQtXNjmXve61+keXoc9tI0nIZdozxGiKtRWvBjuCBCa1t+9whfOwmgjWT+MqWajbmjQWrEWodLXAlsG2zgpTCsIMBngUkrLUZHuw2XPXW/OeVTEh4+p7DX9WLA1WjCPqlrWV7gjY8ZsCb21qNG156wC5Dt7yPoIBxK2q0gtqp9gXStL31eBW2+DDyXBb6ugEVDeYaz67m/jWCG+oEpemxVGDg4lAK/U1pNkTxEceNTOgfAFQCMQ8fIM1vQ+3/oC9Aqf9ixp1IQew6NntO/CkayCir/aEwTZhkfa50J7+Cg+Z96Ffwh2xuTuqZ13dIbWMmLauwCu1pphxXvXIa5CqvYkZXqNRP03L+hoFSrfbVjCHBPqNZ7XNWTRbPfFe+KD73//+8900z3Ntcycxh8vqj8J/3hTn/9+CTBe4c6DbG77rjX+wz/8wxMGUjgSXi3FotZzenbXpWQ4r6ryG5v9uXsMXTX3jSEFqHtVle0ZZB9Dp/d1yKEz6ByfsdmAH2mPfFQUlBtvvPHiRS960WkyEhCvfOUrLx796Eeff/+mb/qmi5e97GW3uOdhD3vYxRve8Ibz3w3iO77jOy5e/epXnyb5cY973MVP/MRPnAZxWxrXHvdY/899FoBUmjFchWwOAl2BpFJ3E24tVJNZWhmBLbbusK6e0zVpoQnMFrzrpHCpZpmmqQosr0PAup6TewwKHZOihe55FBtaYBEszkUKJY8JZiyFcK2WdVkqaNTY2hSUtN5ZWIKV1TjaQDAcGHFVBOtj1/RbfeudwibS5FIWxOQrANeGk7rHWgBMjvD7u/VoLhzhbf0ah/nQ1z5SifvtD/7gD070GCBWESc1AVqnNhYlSwXc+tqaKGa1njWNG5QCFiPHzFqb6IFQxcwWeMYrt4x/Qx4E51ou3ussIpaqNSQ0uo/CTBlb6wQNdB/hRKF0hketZzhwchVlFu++jwBwDYZ5JQsPrkJ6I2GyOKed61UWCBV7BXOr7bwB7EXXClDZM+bA3NpDvt9QCaWqeXG6uLO81vJmtADMN2+dgUVJd+2G/4SV8CzFs3pHNItPrPJgrdQH4unr+w3jGRelxNwwSBoDFz8FdfEHPVPdIMYHBQpdLk3VD+mnwmvhmDbs10e14p4fJiFAa/TG80dZEUYHcF0FmiHQ+5urPT+LcO45zVPCuDFQkDx/PeEb6usae7swiMxLNO1+/FU/m6OAtDAWizsRUkOj8ehwXm9/+9vPlVuFPgL88ho2d+9617tO/1d6PiH/WZ/1Wafr1G9Cq1vEzvv6bQ+ltAeTa43BSdC9u36lWDJGwu2ho1XG8cL3vve955BOSocU5XjhHhRb39s7zWF0Hd+1ju2RxkOW3WoZf3EbW0QSCPEpT3nKxWMf+9grXnPDDTdc/MIv/ML572Na0ROf+MTTAN70pjedJvabv/mbL771W7/14ld+5VduU19sOC5/3glVAAGGthR2govmumc4qCCI6FjpmIcFR2i1NgWGT/mJyGIqQFAtqiwIBEC7RvT9ToFy7k8EgdlSXAi2jX3ztrT4FeCh5An5RJiEAM1XifcIq3ulrS4DsTllNvW++ibDA1OvT/3evf2u/osaETGvlNN+Bz6rb7AsKSURts3f3NVkbBCsPTeC7zkpBSpIUqwwJcAzAEbKmgJoMR9gMIoMhr9WO4bPgmVR9g4ZCtaSG9X6EkbrYrdmq6AsDsB7FDjb9wG1rUt7cSMrOFlCizVoroX29EvojMLB28EKxrzgp1g9268a4ci1LqvKAYrKe68Cp6Q/qxa+hBK2eB/0bn/pp30O99E1XMrr3meREzzofQGcGDo8Rozeyc3Ch1vsTRpw/aF48xDu+4QyeUwXb1Jfu7b3qARN6PV9SjxaSwjwHBib+fRMygBvYH3p3oSbwxv7uzEJb6iLo3z6ZiJRsvABdGJsXduzEliMMEDTfk/I4rMJWYczHsOmvAzxAfSzBRJ54FI+lD1Qdbo16N76y0DdNZB5xYvUugqlyfZp3PiHulJoQQjUc+tT4931Xu/Gep+BtHmlKP48l9YRTbfGayDBLv79Jf/a+V+DIXqtT8osABTbI/Zec1V/VgHr+u7Fs5Yn4YHN9b3vfe+TEQ/X1Mdar9eoPgTCtacoYLxdyzNuNwXl4Q9/+Onz77UmLSFypVZ6VQLrfe9738myrv3UT/3UxSMe8YiLF7/4xacB3trGjciTQkFRbY+mx7shTimtUn0MWjfNHNPvGtq5hVhBZMPvmSaArZi/1EsWyVp2FBTKj8PaWC2LDt/wTn/zHOwBdIiytnF3zxMf98z62WaTc7+VSzEmNVPWNYsJrFLAAxHDgIDv3uZHKfntH2wLKwygGchQGEN/pAQ7BThlZePAsjOs9WJPzBvlSmwbqHQrj24IQfhvsSSqe65AptAag7kTqqCEEIrLCDaUo8+8EmvJiFev65rLdwGwG24yFsx2hT8g5c4VhuzdPA4L+lzBjznzOK5SRMCZB31CF6vgKWFP+O0ztBW83WeOdr3RyjLxjeMv7gEGCxaAclKjzHV9tLtge89En9H6McxC2VU4MJ5jHVYAtt/MyfHE43hOTVEt163iQHjhRcC/+En/OmYALorwbCxSjnkVN8QhVN59jspACwS2jD2H1FGi+l2qdC1ZAHzv+UJb0XTKTPvbCezoe70pKif7TrYPj+bWBLJ2MrcchnePe9zjjOPhKcCjCFH72FjqR2tY6x3Outl3LYbDHkFHDK7F8VGOds/ab/gAfvu/XR53gZ6t/dEL1nw3Dim8O4+yCfHvPelckTWKxGKH8E5ZfIxh+2XBuvZxa7i1qkQrHIbLE/kxxaBUc6SFaQM86EEPuvjhH/7hc72Qm2+++SQUKSe166+//jQRpdE+5jGP+bDnrbehBvEvtXGBPhaVJSpkwlVdvyLWrAcMQvysRmj0vkI53Usr7Hu1HFoQ3pm1sChNhJEFYTViZketkuUZkSkEVet3Cp8y1BFhm662AC8Mm1eI8kDZiaikzcp6YOUaCyIiEBf82XMASzeWy1vEFQqsW4u4ZbMYnxDLzhsLxdxjpNIJszKlHVMoMPOu6z1ObrbZ9wwV8eQF+vUONV3gbTb8og9CDH1k3GDQ3N08X+avxoKgGKzCInxh3dGL2iNb3l28X9/MGazTYjY2Hr70QYD4DuPA6BUz44Hb55g370bX5ghIfBmofYIZb+YLRRKTpugsbmFj+pjfrgMlg3dswxvmdWvxdJ2iW7xRCd4tpiXVuya8wFO1/WF8yBTUR30i2LPcCx84z4sCxUuiyqd1B7hmqByPAjC/PAPKigsHer71Fv7AX4ApKaJC15TFFZTe0Rrm4eShkPK+vKk9LbQsJC486/cNizIKlF0QUiPEeFfxhe5Rct17FBF0ZIJ9gvfaR/H51gAflKUHtyV0i24pdfYYbygv0fHID7xSiGuTKChOeW7gAvGUDW8Kn8MiMRL+5fJ5vatxdP1mT/LsbsjKPuCZrP+UeXyb0QXov0BaSu/uPQqOyraL38JL9dPcr6erZyaLZXV+TBWUwjuFfnIJdUjQD/zAD5w8LikmDaqJplWeO3HHO55jyFdqL3zhCy+e97znfdj3CmQ1yblEMfIWRU0Fm8TiqHFCqBB2vVvFUxZ3DC1MC+HneOr6GxE79G61QnF8IaOIRZrr4kTEy4UcEA1mmFKEWBUyQ3g9p9hizxCyWtCUOGtNufuur08xhGXeGA4LmEVAoyZ4MRMpj1s7IaaXe9RZFq0FV6NKpDw1lLj+FWrp+YCs3r3uU6mfvSPFrA1fvyN4ITYCjyDr+Wp/NO76wWvW/EC6F2qMQUarxxDPAi+F2ZSx5k43P5RAuCV0wOOk9sZ6ImoUB4qZzCZhLwIXg5DRdfSG6DtP3SooOyYCiceMEMTctijdeoEIyAXRriIHsLnW4QKPvdNabXaQd1CEFtDqXWiUQJBOf1wvylZz1WfDFhR0ykpxfiEJStAqi/2/vb/1euBd1gOkYdAU9gRjfK+9HD+kHG1oublQPI5iTnBQJK+kOETLlWWPfu0Bz6SU83YIuTI01gtVO2buGK/q2K997WvP/a9RQCis7Ue0p04Ij8nSIM+G4xTqe5i/3//93z/Na/jG5rhaSUIR5nlp96iw+aDb+h5P6vlh08Ikdr90eZ4SxS3hOnjI4l+U/zwMMIbeb0xrUAjH8yKYZ/KN11BjKNobWzPJfv+kS74iJbl/1bbiDaOM4k/ChNZGuNjc93/riw9vpW5YHPyMXONR0teaMCYFhfeMkskocTwL5fRjWqjtCU94wvn/FUrr8KSEY16VBz/4wf+fnvnsZz/74pnPfOb574ih2FlhoQiIsmFhgMRWq671W8wCU5cbjkm2aE1mi5QgvN/97ndavDZRAqzJv/Od73wifFU8Y2ApZD23hUmAdOZFaOkE36Z87YFREVoYkIc+9KGnsVCkMJN+w6hY5TuOPjENigShRAuPaRQGCaDcM5un1XjVH+ne4tT1r39hddZSawwx2zJtWNwEUXP91Kc+9aQASPWt2fAUIQoYAbfMt4OlCAUWv03U5nfYHKvMoWfNPavVeRZrEdefxk2gAeTGdMVTax3c1djDE9jA3ifM0UZvTgP/qjuC2QltqZgatsrGpMD2jPZB8VweHQoVq2wzUnjaMBcKh+9qQmEK0mFkGBHlA6Ct79AhNzVF5+j1EUJIWVr3b+P8jd/4jdNv7bG8A/0bCLw9oIaDU05Zqo6XVwMn8KDiWjBkPJQJXqDB+l+f2yPF81ujFGHzR2D1joQSq61xJJxa135rflr3aIfn4Y1vfOOpH+233h8NJxzxjhpgNNyYcEfvaO47+A0jJpB7V3QW3+h9r3rVq05rHw01L9ddd9153LBfFJLmpv7V7+YnYZmRRInZzC4eqj7xJAq59W6/tiY8pMIuaMo6xNviST2nvvRuuK9Atl0bT2s8Pas1j/e0b+JT8Cu8D5tl0xy1Twvp4wWtkwNZ+z3aefzjH3/mQ42x3+KhPZfgbZ0ATdeT17o0/owxgODmqnIF0Q2jVG2p/t7wEE9Wc3XES643unvruxPcCWhhpPZ+a9CJxsJWDuSDE2l+m7fouHFS8AGa+7Te/fuBD3zg1MfWTTiXR5rSBMLAGO/vTfm2NxaArQ4YHriHnzaX0UPKezTWWvNEo6voglJszYQ963PrwHPHGJCt6dyl/zRpxgGk2pRt2BSUmEvEtw3e4yPhVjDaYxPnwrC5+ri8/K61QC2KjwPRWhTlxJdhrzuKd6INkrB21oRzUixw12X9RmQxRFZRcyBGSHOmbS84kSYM4ETYHlNRCQyu6d4RARBSBEMbIxBY1zTvNhEvk00a0QEdslB6X/OCmSagI0CWMLxMTbn4fuMGR7RdK0a6OBdr05ibR9lPi7PgVVAdlnLZd2uBO3XaMQOsd+nkMQwMBSNtTrjj60to9uamdcPoKKHNk/HKWCJQu5aC5bA0XrqYHoa9qd7onsXcc80rCx3NUkDVTFD+X9gS8FTcmpDmxUA/MFrCn0KGaAn63jEJ0Urvtyco9TFYSogYed819uYOLsRYop3NpFBMSqYHTw6h40Rrwql3UPZkH4mfuxeWwl4ADq+/zYl14a2hhAqh8GxSEJoXa4zhGxNPU/TaPu85G+qTrdQ8JMCjAdlz9UUFa+cD9Q4HTJqDnp9ykrAIaC4sxmsL94QueWoJpgX8s5Ype/hHa+WoA94FSqX9K7tGiET/m6M+tf51Arb7hBYYV7JhCGWeKfx1S6TLsOOFWW8mBZjxSVETgmbl21MLVI+m26sUzvi0PR7NJX/6rIeIQceolGVDzvRsh7/Wt9ZilST1TDb8wjCWYcozRpFiXH3KpdemJkTU+vWv04q3Jg9+I4UYrVKyyDTKVOPB22GmhN/s0d7TnHhmc+ecsP7fvpdpmaxINkaz/Vb/G1serGRTc1hf8L//FApKm6yOR5C1LMgmqTTljmGuvfWtbz11POvltjTWEAbkOG3u7mVsXHxNXkTWJHdvTKtF6VmYK/dof9t4LITes5gSBXDgH4Q4Nm0NocZcei9XGMHB+sWECLMaq0mIh6BoDN0nTtkmSwmkKNjQ9Rd6u48zUWopL/3GMqhxP4vfShVrrM1V36nkKlTXeMXsCTHMoTlOQWrjcDOb31VAekaZS72vewG5MLdqHAgLOf8Gwfd967fpl7IjurZnxuS5uLu+39t4G4YRB4Yf6B1d4ziDrmsDdm3zVh/byL2bR4oQEK+WRYEBNM5jONAGj16BI5tfioFy4Opa9M7WH7OnqMnIIIQ2vZQruN+lRu9puayqxidjqvWI7mR3AWfHlJTmprgT2tLl9an9ACcgo0I9BWmjzQHjpH6aP1Z/7+FlaB6tPU8Qxs/1LISqmrIxtBbNCUbcczOgVrA2Vyny9b31ELYi8KOb+ttzWsvWInpZD0X9UWOmd/ahOAAqNg+UdFgOCkzfOe+pd6gSjekvtqOPUAUls+dy70txhvlSjyJ+46wW1q4qrEIVAJQwMRQkNM1rJOxAKfA95a+5EkbY7B/CX1hRsUYeYsq20Ap8g9BP/UQLwllA9l0bDbdPGHJOI+7fnu+gT6FaCj4lB21HQ42xtciz0XPx+q6Bi+meeF3XCTNGE/WpNURLvYfc2ixFSrXw5Gd8xmec1qn3Rc/ShHunZATKGUVyq1Ufs7K6Hy9srhmfZM0W0KScNH/C99Ff9N684SXdjxbiF3/8x3988tzZs9KU4yv4xIa6PuoKShMRg9EabO4g1TnDilTXpAGlDHzf933fyYoo1FArFTacSmGBl770pacBfvu3f/spNHRbMnhqP/dzP3eOWbc4CTFV+ZrAXHxf+ZVfeQbk5qJ8xSteceqvDZPVDCjEKuDh2PNHuPLLaW/M0tta3BY94dZmahFVed2wBcWoa7m5EEKZTSoAtohqeTjtN/fwd33Xd53607MjgBe84AVn7InDunpH/QJQLQTGys9lHgG+853vPL0/BlH4rT7RjqtpQ8gEEC4mXDo5BaZrc/VGiCmcoeL7FxNuczYHzX/jtGkUXePh6RBCArt3teljEo2759HONzTTGHMTt2lao9z30UtzU9ilDzdvY8nj0li7V8pfG6VxEQ6F11p/ylDjeve7333quxS/NppMjsZX+KFNyMX98z//82dLIqaSUEnhluURfeR5yo2dglc/YzKKXFGWex7m1fMLe3Udi9Kx7zwOCdbmS9iwuWz962O/RydZLo2p9etZ1SLo366t8FLzQimrD9EVplYTsqj/jjCAj6kv7QPnHFFCmweHKEYzlLaeG40XEqlFr5ipsER02By0VvXlrne964l2WI1c0GoMxfR6RryGYtf8x5/a4zBtrY9D/6JTTLW1r988VEKXPDTNQ7QpW0elz+i7d/Qvi9O8dU3P7XqubQKuxjXuTJT2p5OqpeLWv9ZHllXX9o763pq3Zv2/d7XG7cnG2t6Jfntme7v6VEJRzi1SOygB1RxXn6TfW9f2z5vf/OZzaKx171nRU+saP+1DCYGfE/KWzNC9PEmNu33YulNQ6gOPUXPRuJvLxsKTE++JHgqHPeQhDzldxxPEy9b/oynA3/rUmOp/+zR6d35Yc/OABzzgxBd4iRjNSklQsinOssviwwr2RWvJMOFfp4C3blKDe3/0ltyhzAv58Ny3h3gaG0/9Fp6PNlvzL/iCLzjt6fiEkGfviY+0N3gnKbnwhTVHbixwmLep59e/1pLSBnNSyC8+2d/Rp6KarZECcfVXDaX4aXPSc+tn6906xK+EpskpcnTP1fqoKyhNfoVqNNiQJz/5yRcveclLToRRobYIvklOCCRMN0Tzy7/8yyelpJBPg0mh+cmf/Mnb2pXThG79EulYPAS9Uz5+xNjE1C/KSa0+NnmIEtNYQJr4Xf8SZtz9vU9NjoilRYqpOkFSBUgCr74gojZkm0uBMsj6rUHhYKk2cMTee2KOe4ZQfYqYe7f+Rwg33XTTiaG1KROQXatUcf2KQLfGQcwamDYm24bivYlAE6Ixm/7f+9qopYw//elPP33XBoqx1ucEY2Olece0bIDmTbXZ3pHnLAbbZuy+5i7GxJ0tBOTk49awDdvmagwJc3Vf4D1Y7IBg/Z1izPtQX5vPxhMNJLya+/ve975n70FjyctHOEPAp5h1b+NqLyQoWazNYevVc3t3c88qp1j0ewyp8QMep8TzfLU2KYthuGApuk/WUfMbY2i8vC7RXGvdWPs9odVv7UdZQa1fTRw+5ao56fkpyQmkmB9wN3dtc6qgXVV+uzfG35o0P9FAv0cTaiMJOQn3EYopNeG4GBbt1UCY7bXWUV2N1rY1dcqy7KnmvXlpLMqG8z72vp7f33lq+w3OoTVtzpsfpxoDyrKeU4B7frTX8xtTz2seWOjRbgpk9NQeaRy9J0Wm57ee0ZIwEzpPSPGIZEgldHkBmle1Y2rRaOubEhdPYXS95jWvOe3hBHx7D0hdQkACS0pvv9ff5lxqLQVPKKt7excPKYWn5/PINC5KVX+37wCBe2Zr2Vzx2DZGNWSa++aktfzyL//yc+gLv9Fv2ZYEcGvQM3tvz2+9KZUy7igywKjRbt+lhLSf2y/tzXAsvdcRF4wvx6O0vs1Z98dLYJnQYO+NX/BE9Pdv/uZvnsNA7YX6LNzZ7/W7jNT2lTBy/K/nU/aFPFqr1qF5jvc2nnjkr//6r5/+5gmKrhwOS2Fvz1LwKPLklcyf9nONQq+uDHpoPlpz4cHmAsi7NW0thFt5/NRO4dGyL3jE2mMpUIx+MppHs2uPMI+PmoISASwW4th+7/d+73/6jAjlthZlu1KTukmBoKFCCTc5CZoWEghJyW0tAqWJw3kgxp3wBfxwMXZdY+HigimA/KbZ70mbcCVd2+JGfMIUGI6YuPoh/T8LhGs2poL5wya0ITAjY4BTUBOm31q/rpcJQqhT2ghzbmREzsX7FV/xFWcAaO/oNymIcAD1XzG2NuaCDmttDMylNeu65rE1wGgh4ZuPniGNErYjpbbrYqbimjFHgEAgOKWehchidqwGoSQAsJ4lTbpnxyC8WziuTa6yp3oPKSNSHrsuZVCKYgwphSt6UBq6MfR/KXzRhywnYQZAOAJIjFnmRTTN4yCWL5MDmK7xNob6AQAsdl+LidfvGI4QlZBJ72/+KNndI71f2BCeBQ001uadFxIThPkASI8BwsZsaruxtI4pdkJgwqvRM1Cu7Al4i5q6F/VTscbeSSlvPhxIudYrpd5e0yehg0339g6KM1xaQiXakFoa3QndyL7CqJtzShsMwZaCl/LpuATKgzGwYBNazXlCpLbhn9ZUgTZ4COBhIUahRTVO+juAJx6ADoTAeEFb+/ZqcyO7h/KBX+p/tMC7BUSZUhhdKjlAoQK27H15HyQMyHTD14V2avigPjdOYP/GE43bZz1Ltk2tdYj/t4+idRhGChCeiedYvwU2o0+Kg37yfqKx1qM9CTflJHWe+GOIioL/d5d4wda4OUn55X2itMv8k1aOtmUKKbHQNY0Tfo8BzngWlnJNa7pHu9S/1psnF/wAllAYiSwUTsxYah2OGYFX/Vk88AbQyTwZWxAI2M9EY9IYTtaNFC7xXx8TuXUcuL4oFFnM63WxaBFRHwXKuMcwXUJF7FLf9lRW2mbvScjF9ChkYrSuy6oT2oHelr5MmYjIsni52wDQHNjneTJpeFzaXDxGKTib2pcwFuvumVzmcDoxUBgGip80yDapeLV4KwYa0yCAtpgSfE7P3ZoPkP/q0mCuNnrv7N5c320yWSVt/Pqsyi08QUyOVc6FqsAfF3dNVgJB1pxlWbfJV+A3PmDlxgeND00P78ClXF/qU9f2f9cAUUtdJfThkDDrmFTPypKpv71bXzCk1q5nAz9HQ6ou95wsPpV7nTztKAJ9bQx5BOpb1zU+yikciXUzX5QeQiNPgdCAfafiMKHBy4HBwy9hxgCx3gWrwHOLkUfPqtvW557Xpzl0Bgp6JfykgHrHAoYVEfM7MKiyBbJoMGshIIdhSnMF7kX/PVc6rLBT/SSEGn88IYGlJIGUX0KfAQfLpfAYPiX7Bii/a/Jq7yGim75dk9EG6EhJW2WSBxd2anElvR9EQMo+L2AfdX0oRXgSfIU54vHGNymajEZGSHODP/Q9RbRn9FsKb/wtZYVSltKg2KJ3bs2arlecTso27waALn4Ja6iQJBnTd3i9eenfrY78N5c4KhVsnVHGK991wuQ8SfEVhg7DgIKC1mTyrFJpfPVbWButkX01RxwIeRnn0i4eZxy9wynzCl1eEwpKi6NxtUbYMeMmpcVuwSLCmGcu6DYH9yYcBMEZMa2QB4SilbJOKESEh/gdj0YLyELukKisAxta4SNgva30inB5DTAWpZ55CxIcxZoRhSwkShOPEstM7JwLeTObgHRT4uonKwSoLMuwfrD6mkeK4Y4V8rymrHRN6IvSAlCHAUOE1zdppBg3pgF4uhlbi5WATleSn0Xe78JerV1zuDVeZMhgwADRm+rrnVIuG9eeWUJ5le6b8KEcekdKkHg7dD3FGriQ9675yFuWS3w3cp7A1gcNOK9oQcFoVr/rTwIMA+SGbw+0rs03hH/fB1z/xm/8xjOAWHlxNEphgc1Rx6PwFOZuXCkzam0IF7QO7cf60pzI0qgfCvClSPCMSSc2D2EKtl5F72ge6pMsB4IWjgn+xJlTipP1fWupjHxNxpv3KS6lcBeGzrPV8+CrKkmQMriVo+vbzk3hCrVWCNQ+lCkA154ry4pHsO+f9rSnnTESlHeHsS24mGDn7Vm+QpmoNdZa96BpPNF+BcS0D2HEei/Ba7wbRuIxq9Xfno9PpAT1boJVphXDCtjWd/YghQvmQ+IDxVF4a8Mx+LTQqXIBFNz6srWytrwAOICkBvs6hZy3QBYVftE1zVFj9e4aD3D3AQ3jv93HaGi+u795/cIv/MLzM3i/HNiKdlK4zR/PMwNaqQaKs3XGP2WukpkZPPB63ctAgomkAKbY5cVHq1s3ZcPVaKCwub3pmJhClle9gkKBYGURhNDYFIMWSYgn4oyYYsZNWITQggDf1XgoWA1y/yOYNoEwS+7BBID6DpuZgkECzEnHSgBtIS8MHVodg0HwPTfBEDHBy7RxGlux1K4FTozYxOu3wA4GzIUojCDdse/yLABVST1rbBGuI7TzvixSnHa+m5MQAFqzkWFPIlbv79mFXHLptzn6m5cJc2F9sQhZQ8CEaroURw2ILZ2z39oMYaDa+IVEivur/Mm9CaSpoBXLhOXDWhBPzYPEEpNWHBBbqnNKcN8RKmLlKivy3rHK0C5FsbnpGRQA2RvRKUbJygFMpJRhdvqWsMDkWTmB15qX3MU9l5LVmPKopNBFbxQEhc2sR/2VoSYjC5icohONe585YEwkINTvkPHCFc77KBTmmYSL+ZONxlPGXd1aCe8B2xLMiuixqKX48x7sp/44J0qaqPBt30en7THhiOax5zZWaf7CDLxN+x57CA6OYoB39C8AZ/1Uip5w7tPYWqOtoCxtlcfPuGX6bZgFLgkfFbLUP7ystXAoKOVva+l0rXALJUUNnX6LhnonAHBzlqIGLGoONqUY/fq7JjRgnoRnKY7C1jwH6JPnSoOXwAtlu2yYQpic4di+ZwAI1ymIqU9kBqXd+T7ezTNEMRFqFJqCLxMaUUT0Xy/5HxoxxuaW55cx5vv1JipmKOTW+1oTnm5eFeNvLnmghOZ5VdFQ9JDBRnGSHi2MmExJSXFmmQJzGZ+MwsJ8V72CYtPEiItp8lo0ySkjERIswLo7uV6lXLLss1xNIMJavAhQE6065aPntPBLHEC0DhaMofcRplFTgGVDuEuF7Lk1R4xjdjVMx4GEmEAMsFifOHaNIF+AMs+HXHrgqPq7sUGpdhvaKsbOQ8ClrcaFQkHuXauHFwNTY+GIx/d9ylWbRuVDVjBGSxm1kdZzVGgnIUG5826CTd/S2rN4CTAMQkhrKzliTq1tClRjzBLnMTm+A6MJWBvYk7DoOxYWy5zb2t8ELBwIK7VGOavfwJRqybDirRG3q7nSV++I4QnTpKhTlLjtUxZXcFpPiihaRVNCSQuSW7c+BUMmEoZL0BmbeRQ+8SzPFoagAPMC2KMYsmwB67f1S/R3953x+d019j9BuEILw/dsz/9I9VKMYZVe9EvIoSd8Rgoq4YlWrSm3OWUMz+HS58FYL6pzZACPrbHQGSApT4LvrBdMB2XLXGmrBFBK1ztJIdB/c2j8FBK8kDC03owVfN9+443cpIHlT+iKMcPzgj/aYxRqz6EoCafxkEszpzSoa0KRR4/2OwN0lYCuW5rj2cDThEf+l8vyGBROx11QntDV9r9/hb1k0C1/6Nl7bhsFiNzg7aolVyn5jM32mLR3hdtghwD41Q9r7nh1hO/w7Fst4y8+jhtiBqZKwNFEaf8YoEVsYZpQR1M3wdxRiHu9AjUuTGXZxRx7X89anAnGy/JJ2LSgGLQDpFo0mAaarfoJLHSEw+3M0m4cKT55TShcNj7C5n7lPlzPgTDHpoByP67lAqAnHlz/EWdt8T+YB+HjQ5OX/cQSrYl7Kuiz6ZquWZfzYn9sQAfoNWcYh76xDCmMaolQHvY55pVisLFulkLv4GXTR8xUCNAm9Q7eC/OA+VBmMc6NdRMEaA8Gx/W9g1Kw9JkC7ABLz99aE2v17+Fq8CLqolBkNsa+YQI0ztLFOAlIDLk+Ni9ogcfQelOIt54JY2LxRdbK/KFhHiUC71jzhSCwN3h4do+ifWPkpeB5ULvC3oNfgNHitVqsBGauH+63HubJc4B2hV4We1LjAfEsVi869Lf3btYh3mcOtsrohii3ng6aMl/HZ+jXetYohtbSb2tomDN0Z12tlTFZc33CC/TJ3DBOzaficPbkhrvtsx0zg2cxFIQ/fru1hqyD380LWqGYaPq78srY1mtLkFNSl74+YQ6IbQzm0nxu0TrrZ+/oJ0XQOIXSjAWfxQfhSsyP/vjOHFI8ZDm2Bg51NT/mzJ7njb4mFJQVAJQMhFIWQJ6Htb5r0tryfBSiSeA2aaqBYqriuqof9uH2zFuTclDYJ3eWuDIQFYtASlYuTSXjY/wASIUESgMtFQ4h1I8s9p6XYuKTS5sSQVhKrcvTIrOnfiZoGl9u/J5b+KP+EpQIsf6rAaPo2SoozVPasEqCtYCUlCDWRNfLsRfX5tLs+xSlBRba2Kyg/u35XdvYFYbqGb1fuW0gU5ZOz0kJhCxvHnbDKUAFfFZ/e35/c2FKmRR24DKVQpcimruy58rqWIYGTyC0lYepcJbf2rwyrSh9Gws2T1y7sr8wBPfIYIGrEXOm9NW3wlhSPjcNfkvhK9Km5gLBQoi2Z9Tx2VNIu5bCRkmjzFkL7m3rqrZJ73NWFpAzi209TJTL3rFgd6EVc4UBewcQOPqWStk4jlWZo6dVqCmw7oWLsM7dC1S7h6qxbmWpUITQwgJ2YYAIUmnR9YEh0x5RdAt9q3ja94q0EbY1ngG0KNRMQc0rqZZSY+fVMOdwSc2fbDIKg/fAyZnvVT54Dgh12J760F7Ek3uXMa+StFlMFE4eF31ez8waj7JqGJiKjq3Sbt5hIyjAq/hS1FY5sx8oENZaX8kTyiGl1hxtqIpSYr/BulEulKtv3wnxWN9/vaTp9UZT7Hde/N97V7miyPU9j6HnrifYHEV3681RYK2+wkLGh/uude3vPkK43Z9MBKYlkyih11QWj7ivTIoIwPkQfaT9ObuBFd1k5a4PFS0tEciyZqOnALAIWGo8Jb3XYYIKjMnc6dnOm8iqlc65Wnr/pnTUzwCRDrITGipMEKGoLVL8rs1I4Hdvz4UdQVw0cMwIQl3sEjNB1LwTslcAaTd8QAOW0bEbestScwV7T83GimERSEp106qdt9Mcul5FV1UnnZPB+ji69xUIYo1SSLmwKYt9CL3N9mhsreMxhINRO5TR83k5gIn1u/8HmNS3Tefj7drKxN5DEEmDFK7aterd9TMlhLDHgJv7xgaPQPhQnnnT1ALCJOC1VLvt+rBWMA8OteRVaI84V8SeiCYoK0DglDzWG3c5b0dKvrpFKS9ArkILAJUEkkyx/q+ejtRHc4gRotcwVM17Y8Ysu0fqplCFMCCgaXOo9hALlXezfkiTbt4ox8JggJSUNtgBfWoP18+UTIpY71Ujov/DF3VPfUkgOM3bnoJnkCFE8YXzEJ7suRkvXVtRtgyy8GTNQTg2uBGVoYUZrXfvdc4ZZRd+qO/bs4GuKQcqbMtkYfEzkBhnPGqLHRLW2UbQ95saUtEGYwU/4vHbRvDaJwuYXeXXO7xP+E94IlptzYX3XLuGsfCqfW9e7WvhE/PafMdv4mu9oz1X3RQVscOB3WmwfBRH8+b9q5Bt2FBzvEj3J8+UycAr9ZfCzshnXHWPKAU6bTw8tRS0nQcp/skn9a8osr1H6YerXkH5lm/5ljO6mNBgMbFGmmQpmykDivQ0SW1QaGuxP1Y+ACSA2mZHrFUqRdghbSskV9ASaGLLNUwuZQSD6V/uszaEhVUsqWdH2DAx9U/ZdR4Bmr7DoAjSIzaER6fr+605g6eA4+l71VgxQvdTFIRmjqExjGjPzWk88C5wOV3voDNKyMZr1+VqHfzGIuW6t0ljjEq9Y7Ti7BjHxl7X9cm1uWBa63C0AFTuNc/NZ0JscSwYmXlbywrzWebVddz8va85whzWjb5zjf6sEytVs07Cn66T7tpv/d1aATTaV8KBqkCyICkoFAMKX2OO0cIn9e4KvtU2K4VFzZrmtYKtWtwS5df6AuMqn9/17e2YI8W+phS8cvDrMo957juE11pDCkDCtzVjBChjTsE017xg3N8URM9fBb6Gadd3HjNlzdt3MiGaO9kz8BG8Jku3PvY3L5NaI2hRthwrfUONRyu76xX1WsUcrzLO+knBajzNawXa+s15Q4Q+I7F78Gg0s4rLhjIouwyNxVj5l9cK0F9YZvkdxU34hwK9RhtPwBo6PEBoyn7iiSCcG6MjBbbmB2wULwVvq+f3t3ldcPM/X3phQQeM52jomjthYjKMJ1rab2sf/Roj48X88NxFl4romTf7k4IazfascJvVxlKEMWVYUT48jVFvj/BUXfUKShst4QxsRCtWUOgoTGQNEFqsLu5WRK6UtjjdCndxtM37V/eBa5TQdZKtOLXPhghkmzggjnbr+ZjQhnicd4JRIyICScwQQ1tNezV8mwATIMi7d8F6C74jGNclv4j2o+dE/2vcjzw9fhNXp1iwaJbZbgzV95vHv54jv7WJbFpjOPbfht9Yt/myIb1fn4V6ujeBwvLd1DpjXUzM4nW8A0OGz6ht7H8ZM5rZehP7/MUCrBta3/UP1iFGJUwhFCCMASsDU8TTAm+yyigB4V3CUpR5oZ+a/YTueFbsPWGPBeXu/jMHvD6b6UMZocS6bvE6hBosznpIeUuOtNz8mJPFGSyWivCj7O/86MNiWTyHIub5AOsLqqzxUKGF/t1r1uNnfwsfLW9Y4cwjSMgu9sPH2KzDjoU3S2ijhgdaB9euAaCvu776jYZ2H2rWRUZdY4PjA8y0JtvQ/u7Dxeh4l2t3rwiNOafIOPRteenybc9cj4b93rz3Ueww+u/veAml6UoZRf90qWAvpub4HvdQDnxvXM0TRZOCadwb0gOURh/A78L2Ej949J15JlS+56XxmDNyrhkMisVda5HFCzwJtNikwQFgRE2mjIgFFS2zJ+wxXgxcTLPn5DZlDfTJesi9lRuSN0ZMHeO2AXreUStepmgzlaFjE2bV5b7GTHsG5oHQaMMEOKFCw15L2ve9O+VqhebObe/hTVrhumA5oRUbt3u8gyVs43Cp1whjQLcVqrwDCxoUdqmtx0ZBrpoaEJjplvX3Du9cRcdcsOb13xiFk7omxZHQqxHyx3eskkUYWFu1HAgs11IGFq9TY5Wgz/UALkB5sQSraG16suMUVLTkebOvPGPXYwWntdsYfmsMwN1vPScPgOqvhORmCy2orrbvOMbguzcLlAvcJ3d/fe93nk3C9QjQ9kz/N8fomVWbi1u6ZtcoqLf0vyDcI8BxFWG0S9AIMTVXvA0x+7wnjr/AKzwTnxBy2myXNXp4Exg9a8ThU5sVt4JxFf7acQz2mj3Ow4N+uy6DS/ov/NJiODxXuMh8HsGc1sd8SuOuxV+z3PM4Od9Fv+zZGqFqX29IY70naEDYGX/ldeCJWCXOfqaoMV6NZbE0/k1eKO/QvKdYF3ZLbsDxLM3+0yWNCfvhDTwr+ABa4Il0tpx9b59vdV57BM2otN6zJXVQSNRUqf8UkH4LR1m/GQT9TomEXSGbPeuaUFAIeZbYgozgKSKEBHraajUgihkrAOYeaWm1RemzUmxUmIsItUlv8QgRIYr6wlrs/07tJEQpKghCXQOCiedDCl33JURyX0dgNnLXNyblrFeArodoN6eYP/cjZgIcysVorEops4SEVFbQYuje43mEJSEta2StPgS7bk1zuJUcMTpjEBJYxUThKIxMv9AEJgmku9kzLCShKAqpdai1FtKMMYneUaxYTJUnaLMKFhzMAluFpMbbwl3NsuexQyfrsdoCfxvj3f9TXPRJtpt0/Fq05Zj5GIcCYbKFugfNUBbR93rJMOn6L25NIbXWfVJI16JrzAsopVyjkyNegacp2uei5iHRX1an/uz7rNMKW0Jrw6O8MwvkxhN4GXmUeP3QIhD6htjQeK31UTZdWMX/d95r6nzYU2vhb1vlc3EKR/yc79CNed/wszleMCmBWbPmBKXS6/BlPAnCht6xnq0N3R691Nb96N3MKIO1i1YD7Nfi5xVPs8dXobX21nZTd+2l9YgUPlfqvXUOY9hzA78r0If/6RcDoO94wGCvhAf1a4/nSB51TEYyqmse+chHnk9aZtjd4bDn7b3lLzvenguaUAsP5iyp5r86Tq7n+aVo9o7en8KHJzrDp+c0J8m96BO/VO05vkJeZbQpYNr/KZX4FcPyqldQMH4ESAvmNgVs3Bg6b0px0hVALDdhAxveJsbwI2bF0HpWRKYaKuEQUReLCwgXCArAdU9HtvF4LzBwm94hgo69juCA/fqu50NUEzA2nw3kXRj1ulYJv9oyIpuXkKXI6SOGg+Ei8trRRWtsNe8EeCOEuBk3fLGeAYrEhpdqhJK53BQ+wnGLIRFYNH3MgzKHRjYNcmvP7LyxSJVu3hAhJkjZ5EGBKem3DfGsZU1R2fmqrVdl17NGecAolRjH+ClCcBKbvSAEQPhbm53vjWtvQaxlavq3GAwhJnNP+AmBojGCiUA1t5tmKtxqvITKhhD9jcaMYVMla+gZ3VufDQMaAy8FgLlw5IajVtgS7osxqlkfdLWp2GjVtbs+1tYe2f1grdZzjH4IM335SMoiOsTX0Iu52bXwHrxxvbE1iiAjY9cC3fEcoWPjPYI1j0LXuNFHioKMks3cQR+eg95ky6x3dBXGDY30vUwj4Hdza66MC5/t2eZLkUHzzmMF14SvODjUWVmMo2QLJfgzP/Mzz4YwTI6QJIVzeW8hFvvIvKq0TPFt7+lHz0p+2Gs9o+vDkvCyx9+ScfVtvenC8ck2yna8RCXhBa/3USkXj7omFBQCjXCBlu6TVZvXAQK5CZIxsCcLiwPajEvEFg0zbsHSLi1cz4koaI7rbpONQQDWH7VAIPlriEw8t+ty9Ul/Jjz27Jn64wC07uldYW4irjRZ1S/3kDObcuO6iyVYpPi6vhftjln4zvwfAZu7NgveXGuOMNhYqaqPG1NlSelPbfuyCorfNg69Lt1l7hgMK2Sv3XsxRnPhXnNAwG6/V/Fbpm6Db9wbjcSQetax+BKmrx4LuqRgbFx8Fa9l0rv++stiXovVWM2t95knVvNiMAiIVfJqu9bCazwkq3wutmTXcJU17+/69pxQp0JlBDyXMwXGcfQEL+XCmAhL7+PyXuF5dNMLnbl3w4KE3ioPFLEVungCpYB3y77ByPXDXHk/ujt6HtCKU5SFZCUP4G+AqeZf5hIhaM1qC34/KhetSUaUUgxbfEx4eXFuu9arEC2/tf7uoWjifca89EvhWgOId8Y6etcqM/brKqeUug37KcHQ3zztyyetgVCfkKWQc1mYq5QKTeKbFJMNvzev97jHPc5g1aUncsP97kv5IO+2Poq5ZXzItLI/7Tv9NxeMf/TWe5RygLGUkrxhxJUT3qe8//KPq15BQVh92pTF8VroGFUCvn/TUFtgwNUEe5u3353FIbU34Y4AMUiTLL/7pptuuoWwEF5QN0WNEu4xTLuFtXEqKZ5npYYZdJ8YYGWAW1C1VXp2Ss26eLnxMeW8NsqVqysBJb7u7HV7YmBHIbuClgCnFAg/1PwuNEG7xizVl9n0XAXHhIT6TQ0adT1W2dP3ZcTwIRg5psqTYSOyJDE4ngeZUsbg+ccYO2ZhbLwC6+bduD9lw0GE7ju6zM2R93e9rBfVh1f4UXiFp4wB06h5D0FYW9yGz1rr64FCG6vIYTo7xl2L/U6KdJ++l1LM0gMs7h36usLCfC2IfNebgdDeVdmX19CY8ix6f7QQtgNOTQiiZq1WqbPmaIqAW/Cs8OsqTP1/q5Ni3gvGNm77Kl4E02LNue4pozVhv+6VPYcvbThzvZLNS4ZLmLV4IgC+9HM8BlCz+/Mmxwudk7L4jaNSvrTQc7K2G486Q3AvvVupA6HPpX/e3lUSNvSyHlqhZuNeJUW4gTd8s5YW67I4u91/1pKXQy0Y99WcH9ZzM2jti32OZ/O6Caf3vDwQ+AyvBX5EfsF94ZnN3d3vfvdz2Mz82McbEl4jhrEs+4es2j1uLfBkc42+eCUZjkK+jaX1ThZtqjlc2coEZRV6ZvNnvAzna0JBwQAbeLG8Cp41OYqctenafG08GTxpfG1gIKLia01iE51wjyhsnBqhF4N929vedj6QsI2Qdtvm7x1ScGvhEvKCpDARnoVkpBuLS3KNsdDqW5iV4qmrwUrRkvLXdyleBK4NIbWs1jWsmlUcZCk5lM7hdT27OTOfAI15nDCaWilkmB2i39g+BUH6GgazzIfLngbvePPmQD0EDIVnieJY67r6l6BKYLWOTiXGqOFhxEkbbxulA91yS+Y+pcCt1i9Grmpu9TZqzaWjCFiiGIwUS6DaromRqYvD/UuhIPA27k8AbQiAEDfemEP3ptwSniywrqkfvXsFF+ul8dc3xeBaw+gPeLZ3OWwR5sFZH5igEBVr0fe9I4EYzUcv6uVsHQyF4giUfquYYpl4TnBlXZvbtchrUhuLh9sLFCFeCbU/nA/i5F3p5TAma1UuTqE5jq7QbAYMC7Z7ZC+gCYdoEhabglzb8Fo0Hu95y1vecvq/wwCdNE25dU5NLf4SbTuFXMhpvYdLU4yB+tWYFIFTR6j74mEpxDJgZESpo7NZT6vAE9LNC4PwPe95z5l2u0+FbIDMPo6iqHBkxymgC+8whvWa1aLD+Gae8He9611nJYRRVd+aT/i0cCKd9dV8KdEuDMmbsyGs9XI0H70nD7kT6vEqRQajpfhHhix6IMQbI97FUO39zf2Tn/zk0zw1781181Bf8YT+7f3toYot1s973vOep72BvtQuAgOoD5To3hctdU/3A7E63BMPTdb1qZ9gAX4zTwxeBhnlBg9RriEeaozRTXTbO/HZ5pE3M5rtevviiJ+6ahUUjL9NJatFnFO1RxqjI6oBZDGIGDoG3ebCJN1HeUkheNSjHnV2xSH6CJnlQDPs35D4bUrWT8y4JiSi/orKlxhy/WuTEVRcZXsQWC2i0D/ArI3b8yBRJlgUDr3yDG49bkHgWR8pfOYQ8FV4oX/beM0JS3Xj707oXGuUQkCZTAj0t6JC6nE0x/2bwKggnWf3nu4Rk21jNG/qd6zyVP9jYj0/Jh1Iuut6l7ljxWEYG+OFB7KuPEM8UdLUKUHNecxHQTYKH6uu35uPGkWs3/uOZaMgGIWG6zmFW2xc9pl+NE+dnN2artKDQYlR82DJRtsCUz0nQLlYtNNhFxNRo8j1feOs/07fFsaMITWm3tffMfnopD7AgCkgxfvFYl5v13oLHDVf/SI1bfb0VgKBktwea/wL8vbh0aDkqSKb8lNfe0Z0woiwH4Ut1Q9KQVY4jCeEV48Axsj7Hm/oPkdtxFvgelIS6wOQKS9j75JGLSxEeWBN16Qot34ZXIslASDunfAD6JrSgIetp5UgXMxMYwbUby7gPFTd7XkwgB1+6XBDHoEaPsvrZ03wsf61BtFL826dWeqMg1r7w5pHFwsBaB6jP33YBIGuBY7NOFxMTM9uHmsbnjE3PBcZMu2Xe9/73me+bs66rjlw8GIH1cKu8Ra3d/u+8cen4iGfcMkbGAGNo6rg3dM1i/NA16qn8wBTYmHT6qMiazBa5qi1Snl2pAvvSY1R0zjw9FV8zXXvqOYRr6c1XCiGgqhXvYJi8pvMtGZgIBZwBIBp0PIjEriHFpdS4reetaW7MeOeERFDJ2NU3O0EfE28u826CgYmwtJKiWgTL0aAEAb09duCAHlbMCjv9K84eARHqNS6zzPrOxDYhgwWMAVEiTEDbClnzt2dAkGoAaFuDFsYi5v86NYFYFuAqvlNGy+N7eEPf/i5b5QdApjicwzNWTvXyVBZgCsQZp+UnsUP1KfGTKBhzoQwGqRoCcdJgTVP5pNl3DwtMLG2YSd0UrP+qsguFgaD7Jkx36wjKdbmnrUtdLQFySgIvDUYEiUIdmFdwLyArCFMvnnq/zwswqaYMDwIxVxBta1fRFhRAhdoC2ip8BTmx3PRb0pw2y+b+r04mnWtr1Lac1OCPF8mnZApxUmos6Y/V6pzsmB1VnXXC6dwxfeOPTJBqJkXtGvXY7a4KnttDSoKAvpZPIVwVO9Ev+ZPn4X50AT8xwL8a7I3KKGAmV2X8FKUbT0/RzzbguCtN2+ddeyZjkwQXuQllcVorxrHek0Ixfe+970nQxbmkDELG4JHb7iu33rHKmmbNSm8nqenex3GaX+br+aY14/xgZ4o48mw/hVC+adLgb/Xtseb045PSdFdzzSDcQ1SfKLvHbthT9oP/Vu/U4yLQiTjGLL4MxqnSG5VaMqROcL78MvGTRbx0F4zCgqhHXNqYmm2inJhGjYoJUYMeZlLE74MXoyaEMdIFiC6wC3ELr6nYmZtvRJcZ92f1a2vmAHlitBaSwPDWcBl3yv1rw99B7ewwKTFUqjoivnVNre+97jGXCFMgrPvbc4EPE8ARrFZCSvUdzw2FOWFBVL/e3ahKAxsLVOKI8/PYi6Es3h8IMzXKl9QYQwsl+hiHyiSq2haV5u1PhL2BPQqrAt0TdnKOo9JYiwbakCnC0LG4Chvq4hy+daH3NNKmlvTVXYxqBpcRntB2CMlp2c580Us35kahFYK9abgmkvr0P27D1zT/DjE0votUPKIlVGSe7NH7EOKw2KGgGJXAC6OagsfbkVWQo9wTXlQar5rKZzWktd0aYFVvYJivTSLqeH94wHUdx5JtVCcaXXEsxz3z4ZGzNGGGLZZD7giiqk9tTxt075VQhWqMjbePngSjQG1vAPOB4/zLrzYAZgb9lgALZ51nAcGCKWBorYJBj07YzBsX8dQ4GGLpdq1WGzUAmxrlHSCX3gz/hsd5BnjtVzcC28vbIh5ACqPb/I02yP/cJlBx2PmaJXeVYr11p7Rt/Vg4+l4V9dF+/gHJb8+5NnMC5QCZN9RcCg09iJaN35Ki33nXehww9vo6ppQULSNITd53LK+V+J7zzYQL12maAJtJht8gWEQ91ua2CakjQq3cI8vsFI2R39HaLnDElgWUTZSGwtOoEYbJdSWcLmnXdc1CnA5R2WF+IK5lrFwY69QrZknG3fn1TW9q/h9jAmz0B+MZN+1mv8ROCrLoM3S5peRgHkchXvfUwhslhrrkkDZ9GgYmz4J9xSH3LPSJCl/cEvL+AFva9zLzkQ5ppFTIBx6mDeoow1yjZrntYwpK7Ab5se4bH60CCvzmte85hZCuEY5hmOhoCzAsOcSEj0b0+NB4uYWagh3wI2vvypumudjW+a2CoS++p1A6V0ppRg1ZYt1Tjk/hhN5EDx76dT+hT3j7jZGfeKNW0Anhbd3SwsleFYp5tbHBxYQvEDZ477TeLaEozdUZI3Q1lYsNS48wfzAi/hQglYgrzICJ+OZrPvCfvBpi4uyFpuJSMC6br2hlBvATcqijMfFy61Hzbh4vnbe7XVjJdil2vdvNJtykhD+3d/93dP3vC32ubngCUQT+qIA29aB6tnxpje84Q2nftWHcIrO+1rvIF6Illtjc6+0vLA2Wv7Hf/zHs0LT/zurp/dliPz8z//8KdSZ14W3w95bo3CNCCUQKOiUZmGnV7ziFafrGF08pTwsDAPhIed6kYe80T2PIkzWCVNJp7617Q7/turix0lrslrgZz3rWaewi+JTQjksfJt1LQlKAnCTT981sX0igJh+3wETQcLDFnjuMgrEh6nWNk7pnIMEVZumZ+i/kv1CO57PTc/69EwVAlfxgSmICBpDTfnkxlD8cMMcLJ9VsrzDGFYxs/FTfgopNIYEe7FsWIuEfd93Tf1OGBeekc5N+AlLdG3ArgQSBpEVu4ygPgXO5Vp0wq6N0DgUrVulpz63jurG3Hzzzaf1i3aaBwKfItNaNO8pW4HWiveq2ZFCUR86d2KBvLXG0Xta18B8KSHAqH2a3+4X3+95MRrFi7icxXTz5LRe0hUbR+7XPvUHLggWpWv6rRbDMj8s3sbT7/Uz13DPzz1c32z/rotWuvbGG288Kc7NS2sB0N2/TlV2BlaflJrFqiyDXOAjOiPAN5sGYFOsXWnt6CHcUDUjuPN5e7ieFU70zBXmsmayPPu0Rr2n/j7lKU85GzX9zerfjCIeRQJreQnFgdLTc5tjSms0EF2u54L3ivBabwDaWEHDs8HIci6Uk4BrPFspTykSjYNhs9lkV1IS8RN8qrkieHpfz+vdQmD4hv9T6PR5+QYF1vh4pYDwXd+1b3zjG0+0B5PEoIyWw1UEGE3w44sUdffLhCPAlWEA6mzspe3GA9Fn+yfaBdK2Z5YHGof179Mz2+/OTWr++xcQ3dyj7/ZZ+7IxtJ+cTXTEdwGZ1v+e/deXQGYZcvWtfcDQ4LGt/30H5rCyY9dllV5KR/u8fSF7Lfrtb2Fb+54iCrMDX7eZROsthCXzvX3i8M7f/M3fPM2VKrNXpQeliQTQbHFi6oB5LbS4+2ZTQJbHTDC1JiqCUwittiGCtTZsjprNtJbKErbYLeuLpcH6i0BKQUug5Rqvr/U/AeDQsjZz3zc+hM/C7HcuuIg+K6FxqPOS4sBKrj99z9XG7VejNEhRW6a4rnKEpgw/sHEbqGcLVSUAWbxtnDYcjAq3r+qCvTsQWkyIpcSlzuoCHuxap+X2TIImwV6Wg7RSY2h+ogOZHywD45DKjVFT5mp9H0MhZOX8G4saHKwGrv9OyM4jZhP3HMUCfepf/e2+5pIF1Vz1jhh141ctFY3CcPAEik/Xl6wpjKE+9j2mw1PhWU64NS6eM0Df+hwN1lqXmjXDTHnaoouyd4TJuiYhkLB0iKX9s+W3y7oTTuWRsW6YGyYIo5TwaY9G413TulMEo3WhAvfzavl/Aq65imdQgnqW8ELARNlElH1zTXjZOwyDPgknyk//RkfxouhA9VG8QWiBArQhBAz+qNQtP5IlIQxMMQLkbg2a9wRvfd9DKK01HgantrVjeBwoq12TYi4s0UeI7+jRWm/BKlz4j+/XE8Kg631bPRX9EqRd49Rz2ZO8M40/72300b+KotUfKb0U5zwF29pz0XrrBSjrWp7LBUYT4O2f1qKPcfEyol3rWf8ot10TH0xRsQ5d01znMY6GGoeiax+6VCiSVbzhMmqE6kQEGDftC0Bhhi2gbH1P8en+aF8dmwXW9pFRhvYXIK3shaQGXhZeN9mMjHdKC+X1tvhEbrOCknX1ohe96LTQLdIrX/nKi0c/+tHn36/kuqz96I/+6MX3fu/3nv6fIGmitr3whS+8+P7v//7b1BfFzBQmipm2MSOAFliKHfBjk4yQ1QhQN6D+cDU2+RgLoOam9dnkgHQ8KiwU5dlZUlyZMcIWjrCIudSfiCQmjLFgmDaaTByac8RV8R91DOAJ8hDY6BgpMCm0+xIWi0a6pjRdmy2hjqh6lsJ0lEKWBs8LzIK0RWGwregqLCbdtOfHHHp3z7cJFxhYa1NxF6qI2PWskOaw9e5DCWF9CCMImW1RqZ65oElufoIxunGQY/1pHrk+ZV95R39H244YpwA01+pCsJplQXCJxlzErqMLsf3G4VwL4UtlrNuDwiuNTXaONMEFwfUBXKOksOQBDtEmK4y7f6vvUnLQNfBve5Fnx54gtLzDunVtlpsaM8pkU/RhKYD1rJEU4j5c6s7dcqiheivoEZAPg43+e4fQgjT63pMCQ4lqTaOprm8tmt8+1pvA7fnCqWr+qNPSOqWkAMIDKBLYlDw0vEJ+rU/GRfuOct576pt32u+q/aoHQ8A3RsK3xoomoJqf5lvIQ/iw38tA5Lky14uno2x49jFsTPCxoJuPxoI2ohVzRGGh2PdBh/G99lcfIZJ+71kpyTwoaGPDFFJoM+zw6vpEIUjBxbeXd9VHZRl6Tx7i1sB+3nAvBQ7vaE77WyZh8xD993wgdFi4+lHf6otswP8yBu1mFPZbY5UlyhgWCicHU4IYn/1eH/JWt/eioZ5FRvBwUSjwjA2x4se82L2ft5ZxgOcKo+IVix9jaN8uCkoTEMHmHn3sYx/7Yb8LLWivf/3rL77lW77l4nGPe9wtvn/+859/8dSnPvX8N9T5bWktNuu9OClvCTBkyknfxfx5MbLc0lRrG65ocWn7LXAE271dC9+Re63Nkcu5FqPtXTG2NrdzFCIeylMbSZ59/e1ZLVoCKoLt3XLtxfe53CKA/q5vBEP3tBkTTgS22gn1dcMWrMwIqo1Vn3pvxNsY+kS0EU/jyKpPWVAx9x3veMc5vBEh5+nJS9Oze47c9p7fHDT327f635xFlPL4uYSbizbIuvSLsaZ4NZ7wIKzjLJv6KZOlZ9bX+sEKaa6bp95h0zgAr/HmYWiOe46wUGMVAwaI7F4MoLHGNDq/IkHTeLreKc9A1U4CrrV2vae5a76bo2o/sPab58aupk79ac9UGwETJzAoEL2va/b03fpa/8x9zwLaFOrMk9H8RhelMdYXigB3rowiJ48Czjam973vfScaqm/ticbQb9Epj5oKuPWtvUFZ4vGKfqQZEk696z73uc/ZIiP4ubQxMUUUZc7E0KNFYZNadBod9Xtjxti7rnfVjz7RRiE7YN3e0TrlwVTvpb3WPV3Xc5uf5rY5a68UFmtteJ+UH5BhUr+is/rZ/ZSpcFT93vxQdngCe5+zU6Lz1o4CudlwCZaeI1072mqtFP4qfFH4bk+Rrg+9bzMRoz8hiowjPKU1UrgyOm++fLpXSAOPQQ99HNCIx1I8eMScDk9wNYb2VfPa+6Suup5Q1Lfe15q0N9r30Uzr0W/RaXTD60NZ4Ilz2jhDSFkHIT1hjpSC5rw9Un8aF9BtY45Omq/WjBepeVcSId7IEOsjE2e9hgzdPo2j97cHuqb7A77WnxrFr1afGyfZQcmFpen/PDzRSfTJ4Im2Vjnrd++oj5RBBmhzAQcmBH3EDtbnaKv72x+O9hDi5DE2Vve7V42Z20VBCU/Q5yO1iGBboKQHPvCBJ6GyTbGY/z+NZh5hxygSBBFujCJBqUaDT0y6CZOjT3lpkiPMCLFnOl2zCW+hIqwWNcFrU7L2ekabNfcwsOuv/uqvnu6VQdKCKaDDJde1NnGtfisuF84hhYIGW+Mh6rt+az5lV9goMSixV+79iLT3pMCpsdBGo5Q5uCxi63m5c52sGSNpnpq3fhPTbVw2XcpqY6wQUe/u/tDgij7ZgG0amIr+rQ8s/eabcHN0dwJMzBdWR8pr72mOe3/hoQQoWmBFdq3+N4eAZCnM9bf7en/vJbT6Pg8hS1ONmxhW4+FGbx1ZtzG2+hOj4KFpbWUgVdgpOuf6JXDqM8Ug+opm9b/5aK5bu9a7tWocUjp5077hG77hLPBYa7xiPedVr3rVqe/NZ+uvSJY1IeTUiGjdo2OnnTZ/XVP/uyfaidZYfv0bxig6Srkk0NV5UX25dyje1Tj6uzHHkNsX9fn6668/H9MgvFdaqHBl16cIROONo/nHP1r79kbXAotG8xTWFK3Xve51p73VmvUcnhRF9RpfQpBy1LzlLu//9bFPz+vZjKDelSLaWiVgGl/z2xxYp+Y9Wk+5AaJuTuvT4tx4SlrLxttcqpNS/xT26jmNM2Wl9UjAN2/RYXH96KXnLRCbB+ZnfuZnTvezZOM5/Vb/68tv//Zvn71pMAjNT/QTb6xPzcsqlA5O5AkSTofJ6LnRVeHS9lz/Ko7Ze7umPWFOAZTrY79J800BS/lPKW+uG3vfR0O80F1TY7D1jPovtNK1ygYIu/Vv1zWO1rKxPv3pTz/jmlqfjFpnruHpDBWZmL2vdUhBbTztfQZH/Y6nty5913sy0LuWLEq2KCAplPwPl4cDRq99KHfxEtlm5Ev95pltzpujvktW28utL3mCt1JyG5e9I0KwZS4WsMwrR0HiyZHOTQHShPuF7/7TZPFEgK997WsvXvayl33Ybz/yIz9y8YIXvOC0KDHaZzzjGecQybFRMDQTYPIisgiqHG4V9NaFKp4YQXO1KXoEeNjiU2hofBF3G8I5Dyymnt/itGERMeswQtA3rmrWuhAB4hCzU49BfJklQYFpQRXC6hMB9xzzFXG0SdOQARq514SZpLlFwBF28x5zWzBbxIWAVKVtvEBa3NCbx04Y1T8HIz7xiU88h5Hq72bg7NjVeWg89Tsm7Hh79WpU060JU/V7zLW/CRd9FLZpTtrksrV6R+966EMfevauSZXksq5PCT/u2cZ03XXXneap32PMrZGQAFeoUEfP5cHI69I8AeCJ6/aJFtSOkFVkzdCVvi3mSVzdWFQ9XlwIS7T/h4dhGQOayjLpd6EBjHTT7uvjDTfccKLplJLuk/UiU0kF54SeMGbMqjmQ5dCadJ8j5vtXgUQVX1Xf7f1ZoeawNYLDaV/0fddRVIVbHAtfg4dp3LyyKTUAtd0D4OmMFYejdX2KCEBmz1DcDA4smur5zTsaoKSw/BtDY26OMlSiHwpewoqnwToyqPIeEha9rz42Xwn0lKeETu8gtFIWWNC8Yb27NUsYM2gAhqODhDgDBSatcbT+jb1+pGD3jp6TwdF4panzoAG0KwbHm9EYohd4NMoXvF2KSx+eNfw7+lQ/JBqOpuDcegaMHg9XCmd9Fx6vwFrP6J28as27zCp060wz7209KazxusafYp8siZe13/t/ghwfSDnEN3h0m8voleGoplbXV2SS4uFctcD0GZrCvH2aS+nnjfWv//qvzzVFGHg8O9GisDa8jiJs5urtb3/72eODLtrT5BAgvPBx9/W+1lcm6eIohUnNZetfPzJSFV+rnxvW3UQHcgav+5grKCkmbfpjKOg7v/M7TwTVIrZQz372s08D+7Ef+7ErPid8yvOe97wP+x4qvtZ71P1oMWRx1LZWgFQ3Fs6mqZrUxVK4vuucleB6ruKtDcDdyX0tTt7iiN8RuDWhm94HmBfxAOf1rIhFHYat8QGnsYc6eQcrZAFxrMee7YAvDEzs1DuET/SDOz8lRJyX0tHvQFmqauo7IC9kOauFJ4lQFy/e4lp+5+qFK+g9mKCCXzVzLyNJaWzW0CpNcA3WkxKr/of4+s5R1wEObnYCRZkS3PtiVCwPgl82gQPAKFMArxgpZkB52XoQXPUUOxYNMPSCLFsrniGhNoocBrEZHWiGFyGG5zo1Ovwt7CINO+HQv73HPqlfGJ3YtPCV7Jz6FnOrr67t/QwI45XVxNtVg00Qo4cFozRGi6w39XmsI0Ax5o7p2rObPtvv8E0y5OC+KP0yWYTx+o17vz7zaNavaCilSQjX79L5GRUU7QQ/4S50qlaKe3oXISiUWgN8TcGDM+OZoHya7+aIp8oRH+ZB1havLUOhj7BS/+/+hGzP5lXs39ZYIUEKmszFaEMWpr2S8qKomt96BmyIk4z7Tkiv71ahj2ZSxCjv9aPrgG8bE4+4Olr1JYWkOW8swrCNKdru+SkONQoKb4Mwvxo99Xnr9QjX1npf/YUPjKbqL/yaUNsnXfJ956bhpd3fOvAE9h41jHhrlXfYzKkUv55HAW7uGPIM4MaNH6ChGr5kzaM1R72096IrKcgyFvEt8sBcARd/TBWUcrWzpo8xp2c+85nn/6ddNuFPe9rTTooIUNu2FJi9JyLKwsEYmhDpwDwIrGpZDFvPgcXabxFJBKpYDeulxYYet3i8ND2bVcRLQpi2aLl1hS7qX1o5nELv5eISB7UJgeR6NubEM8NiBbbt/xvnFVKB1u5ZNoy+NR7vT3vOYlhQYXNBWTFuRwZwO1eGH8JcSq7UxjY8wcJLwhMkm4NHpdY7e8YRuCoXH5Pt3/rReHp2cyUFjnCOUUhtln5Yo81jwApAAQgK59WsFyWDwmSDq/3g+0Wn11hVPDCbLYR+eGqMjUJgznkwWJOEDxwBAUrBwYjUkcD8KXKKCwK6Gn97w9jRLwUSVsFcUPxlDME59Xs01DuyCjFPKfD2XE08uga4mCcyb4WQAuG8xyNo7QmgRQpY9zmkrr8VOZPJtV4quA9KXO9oDySwol/ZcGGfrB8alvFXi86E29Dtk570pDPou+dSsntGtFrLKlWFOQGXe3/LIDTHeSt6bgZAnltVbHtnTSYfZUH5cQKLcYIHGpNaP7Ay0sMbV/1Q2ymPwf3vf/8zf2KYUBAaW4pSa9b/gT/ju7KN6k9emt/6rd86Kx5SbfPq5OXtzBiKEKUEGJ1AVnG3xmh0TELvTyY03xnB8IP1n4eyELHDJWXbtIfjcbAVzVkC2zo2XuFaNCsJgadgPbqLDxHaqp9LT55tP9SnvBrx0cKajTk6LERK6AvVfPInf/JZyaXcLNgbvtCnvvRb8qf7oqfHP/7xp3XI69OaNEf1JbrPO9x18XXe+/+3vTuPtf2cGji+zSGCt6mosWZiiJiVGKKo1swflEgN0WhJSMyEln9IhERE+o+h/4gaUiWooNUa0tYQ81wpQlrjS1Bq2m++O/3crHvccpu84p59fyvZ99xz9m94nvWsZ81rPevLw+H2qZwussmekOiL1iS1OydsliAHO/vnNOf/qoLSqb8J5ve+973/9toItkVvE8e0dsLMxp9QfJ+mpgRzlpnmfkYkhDxB0QK3yZxp0wJFVBG/VuYsDImdafQRBUUoUIqrJFmlDu25sWQtyRCX5R/D7d3THWqsBIcGbKx2LjcKnw3dO7tvHpJWzJMHqI2Zu59QavP3uzbaElaDnkUYitErjXvoQx+62YwsCda5XgI8KhG1jdSmjSkRQj2T4sUKF6oJlLYRhoR8Y9ejYgrZgGeF9Q1PygOF6ALMxfPlbuixgjnP5l28JI3LOnNF80Zot60UlbLg/7PfBU+Xd8+4cM/PrS+8IO4r2TM8wYn7zIUV20+nX3vubM41m/BJXnUS8fTGebbERxU2eunAmSMQhH4oXCocPI+i3HMc4tfvEjfhavb9QUcY3VSkwgfFmLeq+5RMO2vK2tuzEm4lPpsbDwpvSNclsBwQRyl06na4k7Ar/wJPmJ4aOSTmf9RRR+1FHxIcJXDGYyhYlJATTzxxT3k/72bAINjZ84RwsCcaQyFBScwJqsLR4TocEEDyEFSHhNfZwTmloecVjphVMikuyre7rjkIXaQUNNcnP/nJeyoE0QqvmiopHkxeVThqLCk4/S1lAS4lQ8djqiZtLjxgvMStnSqznt/YeNwYdfhtIaq8+8mk8nh6Z6kIQWsRPT/60Y/ejKexS3LnNRDW0rxsVhFFr3oaVSCiAWTfh1f5ctGKfL2/XB5ebA7hV1dtFaq8+Oip9StnsDDYE57whD0H2TZ/VV2NT+iIZykeLuyDr/f+3iEUzOimaDQmXjzyVx5ZMkW/Hh6b1obStb/wH1NQ3vGOd2w2hEPy/hVkLUDGlQGHU4Vcbl8Z7ClHLApWFheYQ8FiPLTlNpFyLY3V+tn4Mf2eIbGJ8I+gJR7OM3waV0yhxW0TEQASJDVns8izaY+cgqye7tFzw6ZkzbQxIkD9P1gyPikdhC9LCAP2Pv1BKHYYa5+sj+Yr2VXvFh4IblLCBEOmTEq4UznjYDdaOgUMc5geoWmlEOgYAEUIk25+3NbCExpwqRyYCccz+ZYHod9nTwflf4S6nIqYnA2Ovigr3Pia1rH0bWpKwgwfBNZodrdNgBAyKmtU+Oi5MnGkfBv9KmO0bhQaibnNAz1gVpTb2fdm9v+QVyVnyp6buTTCqa6DR54RGf5wah3hHZ4oP7ONt3f1fK5yzFm5vNCc90x6cX8gp6J3CZkB9B+EJ7F5ayqkKNeEl1B4TRiTYiBPgLJlr8kHSnDlSdZOwLq13u0vYUlendmvgiCcSuSsuiCYVGDhZcKeOy1deLCerZm/9X6HL05FCAjb9Q6hD96AmZPAM+jEcQnOeiARuryMzVMVUfyojzyq5tXf8xAEwnw8gf4Gd8JHqtm0JOCdjo8ceeSRm+fihbwCfZ8iYe85rLJ5y0Hq3bPxm3VvrHnfyyN6+MMfvqdMWtgjmVAIrLHlgeKhveroBtv1KYLCgRLKrUNjUr6vEhXO5el0v1DgzHHjteWtsbckdtsTfdoTWmyYGy8YvpgRa43IavzH3v2PKChNPhcSKOEqBUPZaRADLKP8TW960z/dX6+OKj6q7Gnj9XsJsrlJ26BXBjRiCgggDBmBOM6c1uwY8mkpc4kHIV+4AVHOw5IQtq6LvW8epDQFfYshWU+1REzHwjoGnovOeALt4rljY5JCGjwu/q9aZ4YWdDTEaI1lephksBPqmKmwSR6txixUoNqHoGT5UBQC1m1gUyUsbCIbQWWHTo8zd2KGTSSiUt4CGwsz7tN4CVQ5OI05JU1fmAneJ/SA8VsbzIPyAteSUCl5mozxRBDSUyASkHDOepxeFR4fITaeC9arMNs8S8MzvYdiweuDye3MxMeMZ/6BdZxtsOHH++b9vFbWwvP9pODLTyBseFU8D80QdN4RUMAmXaApShKPnGe6njeKp4qyCdf9XwWFtbceE2dwS4hh5hIPd5bHErw7lTg9aBgZaAzd6MYL793H+6fJJHwbFyUQD4DjmTgtZ4SSKdxtHr0DTwBwykvJhT955RRY2jDIEeLl9S5K5Nxj6J2imIIhLwIPZyg6MDQjMmWBx0xYT2ghuZKix9s1FUb0ID+HIiMHIz7RGDQYNN7GktIVnjIY5cXAKcVO8nT0pKcVmdAaJCfLIep9Gb1wSLmV0Jsidv755++p8gzQlBBlkGHJQJLfkUHZGHtukQBeGHl+KQ15YZxYrloP3wjfkmrt655BEUKvQk3oBA3iaX08G5ADPGb/MQWlWFnKBZAbctxxx61OPfXUzf9PO+20DeKPPfbYf7o/pPf9ySefvEFIi5+CMnNM9hcQtJwMjaxatARp7tkUp4i3T4SlWiBFRIa3hWTxa4YV427BdKjlcg/xEaMzbghvlrsx9V2Z9jPPofc41Za11KITJpKThDpYVRKRWHG8GiwwBIFYabgEBGtlJqry+BDKjrNvTH1fVn/zpG17nr4TrBThAkxvp/DVlpw1oBuk3gNKFY1tCvUpEDE4ys5UOrgNjUHybMxtHkcwlRpCZ7YMJ/RmwimvBEHgPfodECbOmUAjLAZrQjFmtczkZS51uJOAyosghCeplyCbAp1lihlPIUJgzcZOlBgKd+uuLw0hBm9TiZrerik0CTVeGonccrMklM9jJuwLjH6nEIMHNDnzfWY+EaGGJuCA8O05+u1QNKJ3hyvOnK6AwiFcpRHfLJWcyYuUk96pgSDrOl4zhZk5wKucm0BOW/fNXhTmPO+fzbUoNfaRsMLEmTWkSOJFvCKUXusptChcOMcylTgJjzySM19rltbb23MP8hAWbuIpZFzoY5JnIUO2Ygseb9eFZ4bX2WefvceTIBQq71CI3/rz7nVN38kDKS9jHvbX80s7SKinwJSjYz7wK78vBYGinFyTd5dSkPKkHb0QOT7Ay9938asqlOTkXP1y3hGNhAsGZZ6Q8N01Pae1afzNTy8X/FZuSzKkEFGf9nnKHEVSE7hCQ/gCkEdjj8/K0Jlrhm/IgZRsLfTk3plb9v+uoFQ+OTfYvuD444/ffPYFuZnSEP8/oMlqPIaJN7YERRprioWSRAICEw1JJUg5NZRlF3HqEBiSu0bjMpUlNpIGYl0TcbUptCEWj3W6JXdq4+u72UhHS2oVC/1d7wtJX13XXFlc/b/vIvpCaY2reTfW5qdFeeOJiMJRz1YtoolaDcPkMKjAoYCJG0bwDrNSYUTpan7Ti0RBERIp30Y1CGbRu7hbe2e4zaqQkzCVAEpcG5fblwuccKIc9L1QifLLxh/E5Fonwp9QJ5yVABOIvD3cvCw6WfOBsJXM9VnRML0JGCPvSNdqwkYw9BwnW0dXkirlHsnBgXeJw9NjIx8q4I2ZJ/GKy/fe1ra1mX0ihA4wwdn7QH8ZeT8UXIDZE7D6saAtCXdaqMOVawPerD6Ni8KAkfvJe8FL6EiL2XCqd/ddLnl8YeJGkqccM8qH98kn07eFSx1d6IJbLsYMgQUaxBGggeolISdGSZ/2QNd3v3DK9CLJI0Pr8np085SbNcNIs1eHtRfqsHatQ4LUERRClejK/KanlYJqLv2Mt2TIEfy8q13Ha+UU+dmrSKipdz/96U/fa30pEO2F+E9hkbwUBKK5qkjsHS996Us3fCKelDJBGePtLClVq3dKAS9Yvx9zzDF7wmUULCEOqQoVfkzvB2Okn3k9Sn6VW0LZK5WgvJV4euOb3Xgp+XID4+VK8P/38pYUPPPRqjO99EDxfc8pKTYPjC63+DG66v/NkUcu+id3hB6T2zkQhPKNkeKhTX54mYruNLLk5sxcqOnx3enN3tqzeDRGIhRCql4KQZs+l1fflfRUXooGSBGcckHuvpDnxMUWuYVJuGrMxuXV83p3z57fWUwWSM8sXhoTwbDb4Lnf5kYl5DBIbk2Jp94jmTEtl5KkyqJNzMrEFHQg5enhyidwIyKCI6LLYxLO+tlGzt3J8rOhackxBeVxmnfxNshWdx5DPxuzaoXmXxMuCWA0a+VuwczZ8P0MA1BEhaPCTYwpZafNW2Jy/Sna7DrAsnaB/hDBVCps+GBmr/e+xtBzE3zFjRtXc1PCaT0JWs+c4aL5Nx4hSpJzLDo8rb/FkJxxQ/mjgAWUBwxiJ46mVRyoNIk2skqFDVsX68saIsym4jA9FGi4+/w9/LY39AdKMUzICCsJfaqaMP5AKSQvEff0DO+5Pny0zpRY+QDhKp4wy5YptAFcUThnbtfMV/EOia8Bb5Oy256r38b05qAXXsaZ3D3nI0xM+czAkbitT0nXynkiANDyrOoggCau9C6SaxG+zLdnRK+NX/WJXj/WvGvmGVvhmGCceRG6GDvDCR+iSMGdZN6ZbyWMI8ws3D2V03CpiEFPI9VR0yPS93k70K31RnuNs/FJ6p7J66plWo9w0POV8cun6WcG+gw54j/KnfGsmf/l+UIn8zwh69Va8Obpo3LYYYft5W3q+/Cw8+Rqc6DIGitjl6LYnujZDGYKN96nspEnlrLBWImeMvzxR3xe40oGdvcla+VfOlYlhUjjxYNCQRGT5zYS35KwKMM6hGFesoptfud6SPaRF8EliBHNksCdeQstBsvDAYay/XcyQYxSk6iZC8LLw7UrqbAx1p1ViKd58ch0T2NNCE/3NHe2w+g0veLqpzjo/Nd1xXkdgqXVPuGlfJaV3PfOqFBKiCkoizWW/t+m7/+InPtc2Khnzd4NngfHrHkbZ1pa1k/yYte1Bhgv6zs8ct/OZwaYoTCPdfE3Ln3PUy7oZG1WtDAQgT3HHfBizBwMLtCZQyUGLQ8h/AkxSpyG3wBTmd4GuEF7FCbMLTcw5kM59s7WQ37XrGTauUY+MzmTBR7tpjTmXYy+lHXvLGXfmTwJX5g3up6eUKE5ihIDpb1hb81eHXDlGRSdaa1PZRSdhYvoQXVboA09JUeIaXppvA+tsmbh2T7xPWE+PWKT3+xUbrpG0r35zBAQJYBw7hnhv+ewsFn+MyxJ6aAgEkSUuskH0R3jSy4Yw8scZqiOAug5vDbwNpVFwpNS2Ts15xOWnW0jrMNUhOwJeFUhppWA/dZPh2HOcGvvlc/SeFR9wTHFqHuF+KY3LbCu8xPwOmsdMWnbPrvW5Yoarz9eNHuN7OQzDK+eG29SJUZWzkjCpMe5p9GUFAJeXDlL9kbj1sWWssjQT5Y0Fi313W8fbb2CIlmTi9g5ALRzJ/vKbubaCokhL6HtZFAucweSCa/odyDWLkzRArSQvScrkVDvPbnB8j4kVKaFxUujWdZ0ORMgkqF4KBpfmqceJjYbhhdESL1n50FkDm/iebF5JIX10/N7V2EFzYEiQsQcLiSkwR/3N3e9jSffJaCZ9zMPj7l3D+uBkuJ8G67j6Wmw2QkTG3zmRWA8rm/OlethvD1bUrN1mEmV0y0+BVjznnH+7o1ueNGsLyY8w4PeYczmyyXN0yY8M5W2XMUsNOWtcCLMZr2nt4lQEZ4iAAPCQ75CNNq1zhCRENkcmte+BNTOcn9MlVCjwE4Fub3W3gx6PjwRdBNHM7fGWAneqcjw4s1cmZ4l50iyNGYOZrKssc/3UKiNRy4XhZ73gvAVdpmWqDlYl52eLH+fyg1LHE3OvDQJx/b+TiUITmZSNB7Ag8CwYYmjq5kwb/3m3psJwK7jpbMGcNjv8ZK+lxMmodj67KSnwPimgjrXHA5noqUGaK03j6J1owjZywT3rFCbe3+Oh5eXJ5zwNX+JvVORFnIk8P3dnqB8Tu+fniPOj2p/zBPSKZbXubzCzDNnONpc8UZrRiERunICcvKQd4snk6KDr881mPlkjH7rYr4KShiAWmIwnDVsROOTf2+9gjK9JSEmL4MNNK1WQhujl/wUcls0rimaua6XFBAuWu5M37foCXWH3lESWgTn7nRvCWDyCXo+YsEUbebuT7kRhmpezlVI2XGeR8/3zBSK3IP9vjNhkdasPBZR9Y5itM4TibBYnmrVw0nhkhIJuaJ1GCSEeJpYghiYOTn9VIM0rfMJfR/xTc2UUgAwDB8bFxPQU4DCo+fAVCa5ICkYPV8Coh4A1mXG7jEINftCE33XmhS2k9vR+iSA3SsnR+w6QIcEvuRBIQM5CyxJjehUZfXuvE6YNUVL/wo0LqGTx5DwJjh5ymZH4eagv4O8Kcps9yhjnYm9BFf/Z6Vbr6k05DkpDCZEyHjQxjscaExFwaMIT4+KvxEyKlsCVR/oKEW4OfQu9M1TMKuNglnhw1PV3wjMnuMMHHjsemd0dZ+E2OlVsB7WnkteAr28J/Pre3ko1oBSJfFeiG/G+o3J/uGZEBLlAdZ0jyeCx7N9H++QB8SCDqZhMJNCVcThqZQFY+PxkTwvIZmyv9Mbhm7sUXzEONCBYwrwlfgVLypvS3zGuvAMTOWg+Zo7xYUiY3xdn0e89/W89p02FvKSeLLgbRoiKv2mBwz4PZ7hw4OSNzbe6NgPhRZ/Gl424U9hWDQ/w5+6/WY0M6K7P9pqLuW4zEpBPU7IJu9z3wyRdZ2+WY50IVd6pohFRn25TfDRPKdsOmg8KJSTCK+sZq5ahCQ+LqM95MwTQy1o/w/pDoPiqtJPQWOhmHuZ0gDDlKGsfHZ2LG1hCvuoYuGBoZkT5roysnIItwg4Ro9J9o7ierMldfPseQl2GzigqRMKkod1XO3ZNlPj1IRJBVN/d96IzRwDxfwoc9MyND/HpFMG9UvhinVKLQWCksZSZWm1dvItgskIMB/Jho1bPhErrL8TNujD79N64B2BO56WNpwN2DXewTWsa+S0pLpHO3tVYrw0U8DzJLTmkpe5ffXWEXaJSWIgEjwDwpF3jZUjSZjSoNza81p/zd1k+nPNWt/WVoiEpWTddd2dgn8qreahAsCpr30XnnRWbkw7jzmgbFFaAha6dcMsed2UW9qTFM2Z/IsWJ15nyStlYVqQszOxdQu3KifsZUJLwuMM6cpNgLv+xivSM2Pmkw55BiTWyoczbopiMBO4hVm8pw+rnIFFCZmeAIoxIT0FKx4mPGXOwkw8YRTyadHbozyKcoskrZprzxFSNA5hopmDVgMygrHE00D7/PZbfNJadp+DAXmmnQbsI6wPX72vooGu1am86zrTppy2ql4oCIwH987wo7EL+0frfZfBlyxozORDuHBYY5VC8fYMoOazHg3O7B+hJPPkyRZOiT878yrcCs/w7HZ4b8URKRHyV2pIF51Q7HlYAG9oz2j85sXzm3I1Fb2A7FCFSPGnXB0UCgphLPOdmxohzioQWvY8iyREYWrCQjwUmAOBG8Id3W0TQrhjszGPhAnGwQpB2Cx/ORdccBGUzOlAGXT3Y3ie2XxjatyQGOnMwSFQEYR8lq7FfCIsG0tFzUwca/MRhKzMxshLMhMBAxaV7wmc2ZmQoMYsMc5g5mBgojw2syzQBiKwKEKYoj4FwaxK6G+UpK7BmKdr21gouY5LCHg8eBTMRXIpRjUtq5k8jZl5H5rgqhW2m70gZmiFi3zG1ClphDShPtefd8AzCKn2iXvQiXdNYabiQstuCsBsbsZbNpVSHq0pVCnkLN3ZO2aW+c7QznTLT/c8xXmGVNxLEaUEoC2WrbmxQIVYKVkUCIqPsbA64bRPwkxodF+5TZ49wxfWiWIMP/aecCVh5zwuz6PQwKm1nkLSPkQzs4TeGhmTHKudIWTPn2uC7ubeo+yhnblmjA+JuJRaz7RPeZXkpWQwysdLwXZkiLUXtm0NnLo+c/FSWAIh+RlWM98Eu3y6/p/yMKu84vm9gxJYcUXj0d+qd6kam6HKPikL8djm0Zr1u7SDuS7tQ96OFDAH//3t8tOtS/RPIeMNn4p6CkP3pPzwfvb86AWtTGWpNXXKO+OTLKG04bFBaxvu0bw1wpcnT7Mu5qLKrjXRFHFniHLrFRSLhihZ9SEij8I8JC4grFugCGOWhXL5E3TeIbFnuhWnhq+iBqNT2kwjpV0iepauDYMB0VopAsFMTJsu6ZSiWboaYVDMjI9Ame8IuDKbD2u650kAk9vSNRGnjac3y2RUxoioudQxynm4HGFK6E5PiDwASoQ1CabFN/MHAu5vz6K8YLYzMYswmEJ4zoEFaS5T0Zslc643RuseiFMTLjNcRFCiIfQbUOCm0jFdtwRt/+cxMn60qAwULmY+iDGjWcJ8J8N2HeWZ+30qCOZDwMIVBZiCZT7mSzmWx2IcxkdA+/tU8u0n8yOgrAOFEa2wGO1pzHomAcov4emQUwJ/kksJEuNxqvZUOmZFBRqddDKVfkofr9DsOAq8f5a+z7DhVNLm/M2L8iuvyv6ZSaD+jr6FFqzFXENrMiuvJp+cCgn+ghcRZp4518CesFbua09Xvej4joR8wh6t9Df8zR7Mu12Ij5GlwSQBbV3hp78V6k6QxpeV0Hq/kmB7lVFJhqREZNTpwwU/8NJ46zTuPnPBG/AThjZjlTz70+VjxPNnMq15xMOdNwQvQj/oDX30f4m11oqHhRd7Zw5S90phmMnmfs7/g7mGZE4yEt0Z29YrKFxPFkUimXLPiLWPY8K5r3knWNDKfG08TKrfHQevm2zPyRUnlu+wP8lMXZOmbMP1U/8RTEMoRkggZUR8luKQZqxhXMqVfgc07jR9TJil15i47mdvjmmF2Wyao6kQKbxDQREz1nyojSqvIe+QOLPNNpM0MePG2L19GgNFsXd1r9bhXRdjkNTY91WXOK1zuqtZwH3EpHmjGitLgMXKxYshNi5ljFp9T+Y5Xdfhhet+JhPCJU+HkAUhhxYCCpqmfBRVrnX00Rr3O+uHhaXREyYVKMd0ui6FQagEjQn1YFDdE55L4pYgmeUfraLbxleotO/1EMkd3H7BIM2JZ1IIiaBiCBhDFmN0JZnaNUKMvVOodh6mKHRHKbBfe47ePgT2DEdQxil+fSfRXVWS8VlHCpn3OxCRQKNYob9CuMK6aFooqGtYuQQw721AIWstKDqS0qfXSGiWd6yP/LDpoZghzq5Bbw5/04ma4sFSxhd8wk8eh/jl9LJR+CgenmXtGHAzxNEceamFddrPPC0zuR/9GjdlMm9GZ6lRGLpW2TQDj6dbiPqLX/zi5j5r0djlXMyKRsZhtFRzt1n+3lgokIxW73ZkRpDHovykDiWEg4mv1tYhhZKszX+Gc+2XFCV0IIz/v5fnzAg1xW/lAZaqID+pn1X9RYeUOmvSmjo3qzF7tvSAepKpzmTgzhwdIfdpWE5lhHKL1qfx4znhOS8Q/Bw0HhSJYyExRuGgKALSceisNsKzRZiHU3H5Q+bOMjaCnbcmYEHG5CMCBwNSgmLMPStFw6F8PABzIzcWbktCHvH06T5H2c+kuMZUgm7KDO9ARDCv6bkS+rq//BPHgYerkrK4+mLiMafZa4MHQszdqc9CSU6tnVavXAlMv/+3IRwipUlbDETyrnOQZsdDQnXGW+XFdN8UEl3bczSd4pa3YTCD3okmCI6ZTL3zb3IzEuIqdggo6yW/QiVU91L4+qnB3fQkCY1QaPp+niUSvsIj5YkA1tOmZ8jIx4zl/HA3O8NlJqf13EAJvA7BQe9ymCTvDcY1vYoUNB4D96LtmGB9YeRjte4p9MbSc7IqW8/w2Dxbby5rCijPhVASIey8rmmxBwTSTO6zT4UexMIpHjH7GV4JGDtymijSQqfNu3WdNICRs6CFieSlUR7muTnzUFTejLl3UwzhgFIqVG1f2hczp6Nn6bPBcCAwej/FAw54ZoUveZQmjp0sbiws7+bZ3rX/zaNrHag482rmelK+KIoZMuE1nPfceFvXOtm9OUQnlEV9Y2afp+7Tu0QIXaRpAAAP+UlEQVSYalZGNub4JU9R70xxYvhR1uQ3xSNn+IXR0F5nmKqWVMXZNQw9nbnbd+E0/tHzKCjzFOV4l/wlxtx55523Zx/3fPtNL6zoQXpBeIyfRzfWm9EsbOe8Mnu28fLEW4ueG857Ztc3zvBsr81qu8C+mSF//NTfvWt6Zw4KBYXVNUuYbALu7hgFz0rAgxCSNAayuVmiGLG4vJJjTIsXgPXrWHTvlX2t3bqfLSYr2aaSf+Igva7lNrQhZhKaOdCce2+/9942BmaJoXLftUF5HXS0xdi4ZJW+BTZ5uJWwKUly5rnMRDZ5J3Jiuo9iJskumJ4QG5V1NktnAQsGIzHegCDEBLnEbRxJjb6fjcwwI0Kaa3WG1Qiv3qOXjMZN5hKemkN/Z9HOyhdJkqxF9Mbi7tmqT3QWnV4BsV4VSpSWmb9DYdbUbefBc96ns27PEPef7ntKIIHiWmPnWfPOmdza9c5F4eHhxaJAtD4pb+hXuSivk/HABde09xLWFCJCRf6MPYhhEpIYp4TX1jpFSTPEvrdO00PAOrSe00K0tsZAQZqHIhI6MxxFOPMiyVnyjN4ze1xYA4o/BY7nlYIhCZ/CiD7sT8bE7Fw6FQgwc7K6J6VT3yX4sCdm2T5+MfOujJeyPROQ8dvmoVCAB4U3tTGm5KJJoVYGHOWf5d93CdbGzBM687T6u/N7eCzQqz1FiRJCUl6Or+RlDHhmeFt51VUV9nu8XapB+NOpW16ePcYrSKEU+rn+5eOSYG6f8dD0fAbDrPZqXzHGrSfcWGueqZ7b/a1DuOq07U5xVonKoEJL9hmvo+Na0D3vlv0zz2W6srCrFRRhFDkfFJTA5pwJjtybPA7zcD1eg5lpzEWJMc0TMG0GMVULMC26KaRnmZqYZUDxmRYMd7tFntbi3OwzaROztyFVImGavdOZGly8mBum0z0zXs4K8TeMboarMGKWjZi2ze4sFkJgKovucVw35jMTDc25TZTgxhSnMtF7HNpn3AGliqJgbPAH98Yy8xUwYPkqGGQMhlXiWSw3DZ36sFaNY1qLEke9R28VNCEENOP3klStBZwC8+OKbr29xxiExgICCK7Nl6IzLa0Z9uz33tE4lJfOpGdHt1O4KbWEOiZt/1AYGBnmDF/G7t2Eo31LAM48Fnvd/MyxazwrJlrSZRUTPGwUMPdbSwqhip+pkNsX9kDPUC6swqV9Z56SWWduytxb0zKl0E/vBHwwOuSQoSf5OYT5zAebSbP7wtHMCZmeqPDUmupCbYz2wBRcMxdr5hHhXzOXSBUfyz6hyys4vXiaPM6CBzSjeSUvB94wc6zwwXAlRKhXC6XVHudpo8TuVHgZdXJAphEoHNQ7ov/m07scIGhdpmfTB23BOT74t9GU0KGMytR7rnQFZ6QJ68WPrKH9yVs/w2yMukA/sKqV5EqSQXOt8ayp6OLr8E4WU2DRJQV5qxUUSOBBETOWeDYFI9ADpc0wXadOwSUEER2tXj5AQEjYoLTPqRgFQj3GQgGQOMQ9akNx8+9UBGYlCI8FC0ssU3IjpYlWH7GK/wb9TrjSqLU9nkyMxu45iKvxYoqs9J6fyzRiJqyU2FoLHh5WDGChspamEJnJnXDtTCMKSto9RjbzEYAw0qwK4qL3ntZ4Z6t9lgFliTVqTE6/JbiVo++MzVOAJqOHOwLRO8B0nweSNLveYXszHDGF5XQ1tx6OlHf2TutAYJqjd06m0/Nm0l+f2UU1UGpuvDxbgZwuSk33y1XC0GZlDDxSes1Jfx1rOBlg19rbFFnMlCI1E2y9A8/o9+gnwVsood+FHhkEszSX4jiTmKeQZ8UTMK1fJ7y353pO3jE5VOYsPGDs9oexSnqmiKJP84p2mwNamJVsFBMCBQ7woGndAnQK5+bZ3CqzTZGTO4fHTUUBvUzFbhoI8nIIKXlC0VKH13VN/8dLqzTBm4UGm4u2Ebri8gLxZPT99IDL88HL+qmsPxpToiwcjj8w8OQXUZC0pOfpE8qfNBKv6l16G0VjjZ8y0TMo41OmzP4p4fpql8uRnifUPMv7JfEyfAoT9zdKVekFk5bRuVb3qkMpao6J6Dv8yRgp5ICHX3I1JRRtkTMzh6yfPZe3dHrJrwiust6fqw4wiHiL7y2wwAILLLDAArsPCreVw7R1CkraZtZPh86Jjx6MkBWVorbg4ODGQbDgYcFBsOBgwcGBjgde1XJ/Zph6a0I8TaqM7kDG88EMCw4WHIAFDwsOggUHCw4OZDw42PXfwb9WXxZYYIEFFlhggQX+C7AoKAsssMACCyywwAEHu1ZBKTP5pJNOulIlS9sGCw4WHIAFDwsOggUHCw62CQ+7Mkl2gQUWWGCBBRbYbti1HpQFFlhggQUWWGB7YVFQFlhggQUWWGCBAw4WBWWBBRZYYIEFFjjgYFFQFlhggQUWWGCBAw4WBWWBBRZYYIEFFjjgYFcqKG9729tWt7zlLTcHEt33vvddfeELX1htK5x88sl7nXrZ5453vOOe7zuE6XnPe97mxNQOaXvSk560OQxrt8NnPvOZ1WMe85hNO+TmfMYZZ+z1fcVnr3nNazanrHYA1cMe9rDVD37wg72u6XCupz3taZsuih2Q9exnP3tzyNW24OAZz3jGP9HGIx/5yK3Cwetf//rVve99780hZh2g9vjHP35zzMWE/dkDP/nJT1aPetSjNgeV9ZyXvOQlex1eudtx8JCHPOSfaOG5z33u1uDglFNO2ZyyqyvqEUccsTrzzDMPGhrYXzxsHR2sdxmcdtpp62te85rrd77znetvfetb6+c85znrG9zgBuuf//zn622Ek046aX3nO995ffHFF+/5/PKXv9zz/XOf+9z1zW9+8/VZZ521/tKXvrS+3/3ut77//e+/3u3wsY99bP2qV71qffrpp1cGv/7gBz+41/dveMMb1te//vXXZ5xxxvprX/va+rGPfez6Vre61fpPf/rTnmse+chHru92t7utzz///PVnP/vZ9W1ve9v1scceu94WHBx33HGbOU7a+M1vfrPXNbsdB0cdddT6Xe961/qb3/zm+qtf/er6mGOOWd/iFrdY/+EPf9jvPfC3v/1tfZe73GX9sIc9bP2Vr3xlg9dDDz10/YpXvGK9LTh48IMfvOGFkxZ+97vfbQ0OPvzhD68/+tGPrr///e+vv/e9761f+cpXrq9xjWtscHIw0MD+4mHb6GDXKSj3uc991s973vP2/P73v/99fZOb3GT9+te/fr2tCkoCZl/w29/+dkOc73//+/f87Tvf+c5GmJ133nnrbYGdwvkf//jH+rDDDlu/8Y1v3AsX17rWtdbvec97Nr9/+9vf3tz3xS9+cc81Z5555voqV7nK+mc/+9l6t8EVKSiPe9zjrvCebcNB8Itf/GIzp3PPPXe/90BM+KpXver6kksu2XPNKaecsr7e9a63vuyyy9a7HQcE0wte8IIrvGfbcBD8z//8z/rtb3/7QUkD+8LDNtLBrgrx/OUvf1l9+ctf3rjz58GB/X7eeeetthUKXeTmv/Wtb71x1+eiC8LFX//6173wUfjnFre4xVbj46KLLlpdcskle827w6cK95l3Pwtp3Ote99pzTddHLxdccMFqW+Ccc87ZuGnvcIc7rE444YTVr3/96z3fbSMOfve7321+HnLIIfu9B/p517vedXWjG91ozzVHHXXU5rTXb33rW6vdjgPw7ne/e3XooYeu7nKXu6xe8YpXrC699NI9320TDv7+97+vTjvttNUf//jHTYjjYKSBfeFhG+lgV51m/Ktf/WqzKBO5Qb9/97vfXW0jJHRPPfXUjQC6+OKLV6997WtXD3zgA1ff/OY3N0L6mte85kYI7cRH320rmNu+6MB3/UxwT7j61a++YerbgpvyTZ74xCeubnWrW61++MMfrl75yleujj766A0TutrVrrZ1OPjHP/6xeuELX7h6wAMesGG+wf7sgX7ui1Z8t9txEDz1qU9dHX744RtD5utf//rqZS972SZP5fTTT98aHHzjG9/YCOLyTcoz+eAHP7i6053utPrqV796UNHAN64AD9tIB7tKQTkYIYEDSo5KYYkA3/e+922SQxc4eOEpT3nKnv9nFUUft7nNbTZelSOPPHK1bVASZIr55z73udXBCleEg+OPP34vWih5PBpIcY0mtgEy0lJG8iB94AMfWB133HGrc889d3WwwR2uAA8pKdtGB7sqxJPbKstwZ3Z2vx922GGrgwGyEm5/+9uvLrzwws2cC3v99re/PajwYW7/ig76+Ytf/GKv78tUr6plW3FTCLA9Em1sGw6e//znrz7ykY+sPv3pT69udrOb7fn7/uyBfu6LVny323GwL8iQCSYt7HYc5CW57W1vu7rnPe+5qWy6293utnrLW95yUNHAv8LDNtLBVXfbwrQoZ5111l4uz36fMbhthkpE04bTjMPFNa5xjb3wkTuvHJVtxkchjTbTnHcx1PIqzLufMazi0+Dss8/e0ItNu23w05/+dJODEm1sCw7KD04w58Zu7K39hP3ZA/3MLT6VtU9+8pObMk2u8d2Mg31BFnYwaWE342BfEB1fdtllBwUN7A8etpIO1ruwzLhqjVNPPXVTpXD88cdvyoxnVvI2wYte9KL1Oeecs77ooovWn//85zflYZWFlcmvvK6Sw7PPPntTXnfEEUdsPrsdfv/732/K4PpEpm9+85s3///xj3+8p8y4df/Qhz60/vrXv76pZtlXmfHd73739QUXXLD+3Oc+t77d7W63q0ps/xUO+u7FL37xpkoh2vjUpz61vsc97rGZ45///OetwcEJJ5ywKSdvD8zSyUsvvXTPNf9uDyitfMQjHrEp0/34xz++vuENb3jAllZeWRxceOGF69e97nWbuUcL7Ylb3/rW6wc96EFbg4OXv/zlm6ql5td+7/eq0T7xiU8cFDSwP3jYRjrYdQpK8Na3vnVDjPVDqey4Hg/bCk9+8pPXN77xjTdzvelNb7r5PUIECeQTTzxxU2p2netcZ/2EJzxhw7x2O3z605/eCOWdn0prlRq/+tWvXt/oRjfaKKxHHnnkpi/AhF//+tcbYXzd6153U0b3zGc+cyPYtwEHCaeYTMylEsvDDz980/9gp6K+23Gwr/n3qS/IldkDP/rRj9ZHH330+trXvvZGwU/x/+tf/7reBhz85Cc/2QihQw45ZLMX6nXzkpe8ZK/+F7sdB8961rM2NB4fjObb75STg4EG9gcP20gHV+mf/7YXZ4EFFlhggQUWWGDX5qAssMACCyywwAIHBywKygILLLDAAgsscMDBoqAssMACCyywwAIHHCwKygILLLDAAgsscMDBoqAssMACCyywwAIHHCwKygILLLDAAgsscMDBoqAssMACCyywwAIHHCwKygILLLDAAgsscMDBoqAssMACCyywwAIHHCwKygILLLDAAgsscMDBoqAssMACCyywwAKrAw3+Dyf4QDILjmbjAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Pour la Question 5\n", + "def load_matrix(name):\n", + " S = scipy.io.loadmat(name)\n", + " X = S[\"M\"]\n", + " return X\n", + "def monaffichage(X,nbimages,nbrow,nbcol,m_image,n_image):\n", + " if nbrow*nbcol==nbimages and m_image*n_image==X.shape[0]:\n", + " Xtot = np.zeros((nbrow*m_image,nbcol*n_image))\n", + " i, j = 0, 0\n", + " for k in range(nbimages):\n", + " reshaped_image = np.reshape(X[:,k], (m_image,n_image)) / max(X[:,k])\n", + " Xtot[(i)*m_image:(i+1)*m_image,(j)*n_image:(j+1)*n_image] = reshaped_image.T\n", + " if j>=nbcol-1:\n", + " i+=1\n", + " j = 0\n", + " else: j+=1\n", + " plt.figure()\n", + " plt.imshow(1 - Xtot, cmap='gray')\n", + "\n", + "\n", + "nbvisages = 200;\n", + "X = load_matrix('exemplenmf2.mat')\n", + "Xtemp = X[:,:nbvisages]\n", + "monaffichage(Xtemp,200,10,20,19,19)\n", + "\n", + "\n", + "#Lancement de l'algorithme sur la matrice Xtemp avec r=5\n", + "r = 10\n", + "W, H = alternatealgo_l2nmf(Xtemp,r,maxiter=5)\n", + "#plt.figure()\n", + "#plt.semilogy(f)\n", + "#plt.xlabel(\"Itérations\")\n", + "#plt.ylabel(\"Erreur ||X-WH||\")\n", + "#plt.title(\"Evolution de l'erreur\")\n", + "#plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 239, + "metadata": { + "id": "i8zEO66q41mB" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Affichage de W\n", + "monaffichage(W,10,2,5,19,19)" + ] + }, + { + "cell_type": "code", + "execution_count": 240, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Affichage de W\n", + "monaffichage(W@H,200,10,20,19,19)" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "optinonlin", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/2025/2025.ipynb b/2025/2025.ipynb new file mode 100644 index 0000000..7f0641e --- /dev/null +++ b/2025/2025.ipynb @@ -0,0 +1,298 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "id": "2QuiuhUXUndl" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy.io\n", + "import time\n", + "from scipy.sparse import csc_matrix, hstack" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "id": "1xIVmvlUUvFZ" + }, + "outputs": [], + "source": [ + "def load_data(name, big_data=False):\n", + " S = scipy.io.loadmat(name)\n", + " if big_data:\n", + " a = S[\"a\"].tocsr() #ajouter \".tocsr()\" pour le dataset \"Ybig_train_set.mat\"\n", + " else:\n", + " a = S[\"a\"]\n", + " y = S[\"y\"]\n", + " id_classe1 = np.where(y==1)[0]\n", + " id_classe2 = np.where(y==0)[0]\n", + " return a[id_classe1,:], a[id_classe2,:]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "l4L0fk4YU1fE" + }, + "outputs": [], + "source": [ + "def optimisation(classe1,classe2,methode=\"gradient\",pas=\"wolfe\",maxiter=10000,maxtime=10,big_data=False):\n", + " def fct(x):\n", + "\n", + " # Valeur pour clip l'exponentielle (éviter certains problèmes)\n", + " D = 50\n", + "\n", + " # Pour les yi==0\n", + " exposant = np.clip(a1@x, -D , D)\n", + " exp = np.exp(-exposant)\n", + " f1 = sum(np.log(1+exp))\n", + "\n", + " g1 = -a1.T@(exp/(1+exp))\n", + "\n", + " # Pour les yi==1\n", + " exposant = np.clip(a2@x, -D, D)\n", + " exp = np.exp(-exposant)\n", + "\n", + " f2 = sum(exp) + sum(np.log(1+exp))\n", + "\n", + " g2 = a2.T@(1/(1+exp))\n", + "\n", + " f = f1 + f2\n", + " g = g1 + g2\n", + " return f, g\n", + "\n", + " def w1(x,d,alpha,beta1):\n", + " f0, g0 = fct(x)\n", + " f1, g1 = fct(x+alpha*d)\n", + " return f1 <= f0 + alpha*beta1*np.dot(d,g0)\n", + "\n", + " def w2(x,d,alpha,beta2):\n", + " f0, g0 = fct(x)\n", + " f1, g1 = fct(x+alpha*d)\n", + " return np.dot(d,g1) >= beta2*np.dot(d,g0)\n", + "\n", + " def wolfebissection(x,d,alpha=1,beta1=0.0001,beta2=0.9):\n", + " aleft = 0\n", + " aright = np.inf\n", + " iter = 0\n", + " while True:\n", + " if w1(x,d,alpha,beta1) and w2(x,d,alpha,beta2):\n", + " break\n", + " if not w1(x,d,alpha,beta1):\n", + " aright = alpha\n", + " alpha = (aleft+aright)/2\n", + " elif not w2(x,d,alpha,beta2):\n", + " aleft = alpha\n", + " if aright1\n", + " iter += 1\n", + " return alpha\n", + "\n", + " def backtrackingsimple(x,d,alpha=1):\n", + " f0, g0 = fct(x) # valeur et gradient à l'itéré\n", + " f1, g1 = fct(x+alpha*d) # valeur et gradient à l'itéré souhaité\n", + "\n", + " while f1>f0 and alpha>=1e-16:\n", + " alpha /= 2\n", + " f1, g1 = fct(alpha*d)\n", + " \n", + " return alpha\n", + "\n", + " def methgradient(x0):\n", + " start_time = time.time()\n", + " temps = np.zeros(maxiter)\n", + " fobj = np.zeros(maxiter)\n", + " x = x0.copy()\n", + "\n", + " for k in range(maxiter):\n", + " f, g = fct(x)\n", + " d = -g\n", + "\n", + " if pas==\"wolfe\":\n", + " alpha = wolfebissection(x, d)\n", + " elif pas==\"back\":\n", + " alpha = backtrackingsimple(x, d)\n", + "\n", + " x = x + alpha*d\n", + "\n", + " f, g = fct(x)\n", + " fobj[k] = f\n", + " temps[k] = time.time() - start_time\n", + "\n", + " if temps[k] >= maxtime:\n", + " break\n", + " return x, fobj[k+1], temps[k+1]\n", + "\n", + " def methgradientacc(x0):\n", + " # Pas fait en séance\n", + " pass\n", + "\n", + "\n", + "\n", + "\n", + " #Données des deux groupes a1 et a2\n", + " n1, m = classe1.shape\n", + " n2, m = classe2.shape\n", + " if big_data:\n", + " a1 = np.ones((n1, 1+m)) # !! csc_matrix()\n", + " a2 = np.ones((n1, 1+m))\n", + " else:\n", + " a1 = np.ones((n1, 1+m)) # !! csc_matrix()\n", + " a2 = np.ones((n1, 1+m))\n", + "\n", + " a1[:,1:] = classe1\n", + " a2[:,1:] = classe2\n", + " #Itéré initial\n", + " x0 = np.ones(1+m)\n", + "\n", + " if methode==\"gradient\": x,f,t = methgradient(x0)\n", + " # Pas fait en séance\n", + " # if methode==\"gradientacc\": x,f,t = methgradientacc(x0)\n", + "\n", + " return x, f, t" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DOjbhWDDgxW0" + }, + "outputs": [], + "source": [ + "# ############# Entrainement du modèle #############\n", + "classe1_train, classe2_train = load_data(\"train_set.mat\")\n", + "x_gd_wf, f_gd_wf, t_gd_wf = optimisation(classe1_train,classe2_train,maxtime=60)\n", + "x_gd_bt, f_gd_bt, t_gd_bt = optimisation(classe1_train,classe2_train,pas=\"back\",maxtime=60)\n", + "#x_ga_wf, f_ga_wf, t_ga_wf = optimisation(classe1_train,classe2_train,methode=\"gradientacc\", pas=\"wolfe\",maxtime=60)\n", + "#x_ga_bt, f_ga_bt, t_ga_bt = optimisation(classe1_train,classe2_train,methode=\"gradientacc\", pas=\"backtracking\",maxtime=60)\n", + "plt.loglog(t_gd_wf,f_gd_wf,label=\"Grad. Wolfe\")\n", + "plt.loglog(t_gd_bt,f_gd_bt,label=\"Grad. Backting\")\n", + "#plt.loglog(t_ga_wf,f_ga_wf,label=\"GradAcc. Wolfe\")\n", + "#plt.loglog(t_ga_bt,f_ga_bt,label=\"GradAcc. Backting\")\n", + "plt.xlabel(\"Temps\")\n", + "plt.ylabel(\"Erreur\")\n", + "plt.legend(loc=1)\n", + "plt.show()\n", + "\n", + "plt.loglog(t_gd_wf,f_gd_wf,label=\"Grad. Wolfe\")\n", + "plt.loglog(t_gd_bt,f_gd_bt,label=\"Grad. Backting\")\n", + "#plt.loglog(t_ga_wf,f_ga_wf,label=\"GradAcc. Wolfe\")\n", + "#plt.loglog(t_ga_bt,f_ga_bt,label=\"GradAcc. Backting\")\n", + "plt.xlabel(\"Temps\")\n", + "plt.ylabel(\"Erreur\")\n", + "plt.legend(loc=1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LLaiMIxoYG6P" + }, + "outputs": [], + "source": [ + "classe1_train, classe2_train = load_data(\"big_train_set.mat\", big_data=True)\n", + "x_gd_bt, f_gd_bt, t_gd_bt = optimisation(classe1_train,classe2_train,pas=\"backtracking\",maxtime=180,big_data=True)\n", + "#x_ga_bt, f_ga_bt, t_ga_bt = optimisation(classe1_train,classe2_train,methode=\"gradientacc\", pas=\"backtracking\",maxtime=180)\n", + "\n", + "plt.loglog(t_gd_bt,f_gd_bt,label=\"Grad. Backting\")\n", + "#plt.loglog(t_ga_bt,f_ga_bt,label=\"GradAcc. Backting\")\n", + "plt.xlabel(\"Temps\")\n", + "plt.ylabel(\"Erreur\")\n", + "plt.legend(loc=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "AmSlY7I-kH7X" + }, + "outputs": [], + "source": [ + "def entrainement(classe1,classe2):\n", + " ..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "qE7YMoJ7lbJN" + }, + "outputs": [], + "source": [ + "############# Entrainement du modèle #############\n", + "classe1_train, classe2_train = load_data(\"Ybig_train_set.mat\")\n", + "poids_reseau = entrainement(classe1_train,classe2_train)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JEyEwFCcVQge" + }, + "outputs": [], + "source": [ + "def validation(poids_reseau,classe1_test,classe2_test):\n", + " def pred_sigmoide(poids_reseau,data):\n", + " return np.round(1/(1+np.exp(-poids_reseau[0]-data.dot(poids_reseau[1:]))))\n", + " correct = 0\n", + " nb1, nb2 = classe1_test.shape[0], classe2_test.shape[0]\n", + " for i in range(nb1): correct += pred_sigmoide(poids_reseau,classe1_test[i,:])\n", + " for i in range(nb2): correct += 1-pred_sigmoide(poids_reseau,classe2_test[i,:])\n", + " print(f\"{correct}/{nb1+nb2} donnees classees correctement dans jeu test\")\n", + " return correct" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HgnXLoUmmY8h" + }, + "outputs": [], + "source": [ + "############# Validation du modèle #############\n", + "classe1_test, classe2_test = load_data(\"Ybig_test_set.mat\")\n", + "result = validation(poids_reseau,classe1_test,classe2_test)" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "optinonlin", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/2025/big_test_set.mat b/2025/big_test_set.mat new file mode 100644 index 0000000..e36d2b4 Binary files /dev/null and b/2025/big_test_set.mat differ diff --git a/2025/big_train_set.mat b/2025/big_train_set.mat new file mode 100644 index 0000000..8696949 Binary files /dev/null and b/2025/big_train_set.mat differ diff --git a/2025/test_set.mat b/2025/test_set.mat new file mode 100644 index 0000000..a8f9919 Binary files /dev/null and b/2025/test_set.mat differ diff --git a/2025/train_set.mat b/2025/train_set.mat new file mode 100644 index 0000000..d670e64 Binary files /dev/null and b/2025/train_set.mat differ diff --git a/README.md b/README.md new file mode 100644 index 0000000..e69de29 diff --git a/cours2.ipynb b/cours2.ipynb new file mode 100644 index 0000000..1c4e8ec --- /dev/null +++ b/cours2.ipynb @@ -0,0 +1,548 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8e81b5c1", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "4301d681", + "metadata": {}, + "source": [ + "# Question 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c3e61f7", + "metadata": {}, + "outputs": [], + "source": [ + "def gradientquad(Q,c,p,x0,maxiter=100,choix='exact'):\n", + " fobj = np.zeros(maxiter)\n", + " x = x0.copy()\n", + "\n", + " valp, vecp = np.linalg.eig(Q)\n", + " L = np.max(valp)\n", + "\n", + " # Si le choix est \"constant\", alpha ne dépend pas de l'itéré, on le calcule une seule fois.\n", + " alpha = 1/L\n", + "\n", + " for k in range(maxiter):\n", + " # Gradient de fonction quadratique\n", + " d = -(Q@x-c)\n", + " if choix == \"exact\":\n", + " # Dépend de l'itéré, on le calcule à chaque itéré\n", + " alpha = (d@d)/(d@Q@d)\n", + " x = x + alpha*d\n", + " fobj[k] = 0.5*x@Q@x - c@x + p\n", + " if np.linalg.norm(d) <= 1e-6:\n", + " break\n", + " return x, fobj, k" + ] + }, + { + "cell_type": "markdown", + "id": "9c418d62", + "metadata": {}, + "source": [ + "## Expérience 1" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7f35335f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Q = np.array([[10.0,-6.0],[-6.0,10.0]])\n", + "c = np.array([4.0,-3.0])\n", + "p = 0\n", + "x0 = np.array([1.0,1.0])\n", + "\n", + "# Méthode exacte\n", + "xopt, fobj, nbiter = gradientquad(Q,c,p,x0,maxiter=25,choix='exact')\n", + "plt.plot(fobj, 'b', label=\"Gradient avec pas exact\")\n", + "\n", + "# Méthode constante\n", + "xopt, fobj, nbiter = gradientquad(Q,c,p,x0,maxiter=25,choix='constant')\n", + "plt.plot(fobj, 'r', label=\"Gradient avec pas constant\")\n", + "\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "c266cf47", + "metadata": {}, + "source": [ + "## Expérience 2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "90781b5a", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.linalg import hilbert" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4b09233b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\conta\\AppData\\Local\\Temp\\ipykernel_10208\\2863094032.py:18: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " fobj[k] = 0.5*x@Q@x - c@x + p\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, \"Nombre d'itérations\")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nbiter_exact = []\n", + "nbiter_constant = []\n", + "\n", + "for n in range(3,101):\n", + " Q = hilbert(n)\n", + " c = np.zeros(n)\n", + " p = 0\n", + " x0 = np.ones(n)\n", + " # Méthode exacte\n", + " xopt, fobj, nbiter = gradientquad(Q,c,p,x0,maxiter=10**6,choix='exact')\n", + " nbiter_exact.append(nbiter)\n", + " # Méthode constante\n", + " xopt, fobj, nbiter = gradientquad(Q,c,p,x0,maxiter=10**6,choix='constant')\n", + " nbiter_constant.append(nbiter)\n", + "\n", + "plt.plot(nbiter_exact, label=\"Pas exact\")\n", + "plt.plot(nbiter_constant, label=\"Pas constant\")\n", + "plt.xlabel(\"Dimension n\")\n", + "plt.ylabel(\"Nombre d'itérations\")" + ] + }, + { + "cell_type": "markdown", + "id": "7c28bbfd", + "metadata": {}, + "source": [ + "# Question 2" + ] + }, + { + "cell_type": "markdown", + "id": "795525ae", + "metadata": {}, + "source": [ + "## Implémenter les fonctions" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e8da3a46", + "metadata": {}, + "outputs": [], + "source": [ + "def f_grad_conv(x, c=10.0):\n", + " f = 2*np.log(np.cosh((c/2)*(x[0]+2*x[1]))) + 2*np.log(np.cosh((c/2)*(2*x[0]-x[1])))\n", + " grad = np.array([\n", + " c*np.tanh((c/2)*(x[0]+2*x[1])) + 2*c*np.tanh((c/2)*(2*x[0]-x[1])),\n", + " 2*c*np.tanh((c/2)*(x[0]+2*x[1])) - c*np.tanh((c/2)*(2*x[0]-x[1]))\n", + " ])\n", + " L = 2.5*c**2\n", + " return f, grad, L" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8fececb8", + "metadata": {}, + "outputs": [], + "source": [ + "def f_grad_strong(x, c=10.0, mu=10**2):\n", + " f, grad, L = f_grad_conv(x, c)\n", + " f += (mu/2)*(x[0]**2 + x[1]**2)\n", + " grad += mu*x\n", + " L += mu\n", + " return f, grad, L" + ] + }, + { + "cell_type": "markdown", + "id": "4e106212", + "metadata": {}, + "source": [ + "## Implémenter la fonction methgradient" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "aad0cb25", + "metadata": {}, + "outputs": [], + "source": [ + "def methgradient(fct, x0, maxiter=100, tol=1e-9):\n", + " x = x0.copy()\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " for k in range(maxiter):\n", + " f, grad, L = fct(x)\n", + " d = grad\n", + " alpha = 1/L\n", + " x = x - alpha*d\n", + " f, grad, L = fct(x)\n", + " fobj[k] = f\n", + " if np.linalg.norm(grad) <= tol:\n", + " break\n", + " return x, fobj[:k]" + ] + }, + { + "cell_type": "markdown", + "id": "4b2a063e", + "metadata": {}, + "source": [ + "## Expérience" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "5a665f93", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x0 = np.array([1.0,1.0])\n", + "\n", + "xopt, fobj = methgradient(f_grad_conv, x0, maxiter=70)\n", + "plt.semilogy(fobj, 'b', label=\"Fonction convexe\")\n", + "\n", + "xopt, fobj = methgradient(f_grad_strong, x0, maxiter=70)\n", + "plt.semilogy(fobj, 'r', label=\"Fonction fortement convexe\")\n", + "\n", + "plt.xticks(np.arange(0,18,2))\n", + "plt.legend(loc='upper right')" + ] + }, + { + "cell_type": "markdown", + "id": "e6e7014d", + "metadata": {}, + "source": [ + "# Question 3" + ] + }, + { + "cell_type": "markdown", + "id": "6adbe45c", + "metadata": {}, + "source": [ + "## Implémenter la fonction\n", + "Note: La fonction n'est pas L-smooth parce qu'on peut pas trouver une fonction quadratique avec un seul L tel que cette fonction est au dessus de $x^4$.\n", + "La courbature de $x^4$ en $\\infty$ est aussi $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "ca042253", + "metadata": {}, + "outputs": [], + "source": [ + "def fct(x):\n", + " f = (x[0]+x[1])**4 - 2*(x[0]+x[1])**2 + 1\n", + " g1 = 4*(x[0]+x[1])**3 - 4*(x[0]+x[1])\n", + " g = np.array([g1, g1])\n", + " return f, g" + ] + }, + { + "cell_type": "markdown", + "id": "6e8069ca", + "metadata": {}, + "source": [ + "## Implémenter les deux conditions de Wolfe" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "baf4f554", + "metadata": {}, + "outputs": [], + "source": [ + "def w1(fct, x, d, alpha, beta1):\n", + " f0, g0 = fct(x)\n", + " f1, _ = fct(x+alpha*d)\n", + " return f1 <= f0 + beta1*alpha*(g0@d)\n", + "\n", + "def w2(fct, x, d, alpha, beta2):\n", + " _, g0 = fct(x)\n", + " _, g1 = fct(x+alpha*d)\n", + " return d@g1 >= beta2*(d@g0)" + ] + }, + { + "cell_type": "markdown", + "id": "5b935acb", + "metadata": {}, + "source": [ + "## Implémenter la bissection de Wolfe" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "253f97be", + "metadata": {}, + "outputs": [], + "source": [ + "def wolfebissection(fct, x, d, alpha0=1.0, beta1=1e-4, beta2=0.9):\n", + " aleft = 0\n", + " aright = np.inf\n", + " alpha = alpha0\n", + "\n", + " while True:\n", + " if w1(fct, x, d, alpha, beta1) and w2(fct, x, d, alpha, beta2):\n", + " return alpha\n", + " if not w1(fct, x, d, alpha, beta1):\n", + " # On bouge la borne de droite vers la gauche\n", + " aright = alpha\n", + " alpha = (aleft + aright)/2\n", + " elif not w2(fct, x, d, alpha, beta2):\n", + " # On bouge la borne de gauche vers la droite\n", + " aleft = alpha\n", + " if aright < np.inf:\n", + " alpha = (aleft + aright)/2\n", + " else:\n", + " alpha *= 2" + ] + }, + { + "cell_type": "markdown", + "id": "1dc9c161", + "metadata": {}, + "source": [ + "## Implémenter la méthode du gradient avec recherche de Wolfe" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "acd3c8f0", + "metadata": {}, + "outputs": [], + "source": [ + "def methgradient(fct, x0, maxiter=100, tol=1e-6, alpha0=1e-6):\n", + " x = x0.copy()\n", + " fobj = np.zeros(maxiter)\n", + " alpha = alpha0\n", + "\n", + " for k in range(maxiter):\n", + " f, g = fct(x)\n", + " d = -g\n", + " alpha = wolfebissection(fct, x, d, alpha)\n", + " x = x + alpha*d\n", + " fobj[k] = f\n", + " if np.linalg.norm(g) <= tol:\n", + " break\n", + " return x, fobj[:k]" + ] + }, + { + "cell_type": "markdown", + "id": "c6f5ebc5", + "metadata": {}, + "source": [ + "## Exemple numérique" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "fcef62aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.50000003 -0.50000003]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x0 = np.array([1.0,1.0])\n", + "maxiter = 30\n", + "# Importance de alpha0!\n", + "xopt, fobj = methgradient(fct, x0, maxiter=maxiter, alpha0=0.05)\n", + "plt.plot(fobj, 'b', label=\"Gradient avec Wolfe\")\n", + "plt.legend(loc=\"upper right\")\n", + "print(xopt)" + ] + }, + { + "cell_type": "markdown", + "id": "c36d5972", + "metadata": {}, + "source": [ + "## Bonus: Méthode gradient accéléré" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "94113279", + "metadata": {}, + "outputs": [], + "source": [ + "def methgradientaccel(fct, x0, maxiter=100, tol=1e-6, alpha0=1e-6):\n", + " x = x0.copy()\n", + " fobj = np.zeros(maxiter)\n", + "\n", + " xprev = x\n", + " alpha = alpha0\n", + "\n", + " for k in range(maxiter):\n", + " beta = k/(k+3) # Paul Tseng (version plus simple)\n", + " y = x + beta*(x - xprev)\n", + " f, g = fct(y)\n", + " d = -g\n", + " alpha = wolfebissection(fct, y, d, alpha)\n", + " xprev = x.copy()\n", + " x = y + alpha*d\n", + " f, g = fct(x)\n", + " fobj[k] = f\n", + " if np.linalg.norm(g) <= tol:\n", + " break\n", + " return x, fobj[:k]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8b110f9", + "metadata": {}, + "outputs": [], + "source": [ + "x0 = np.array([1.0,1.0])\n", + "maxiter = 30\n", + "# Importance de alpha0!\n", + "xopt, fobj = methgradientaccel(fct, x0, maxiter=maxiter, alpha0=0.05)\n", + "plt.plot(fobj, 'b', label=\"Gradient avec Wolfe\")\n", + "plt.legend(loc=\"upper right\")\n", + "print(xopt)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "optinonlin", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cours3.ipynb b/cours3.ipynb new file mode 100644 index 0000000..349480d --- /dev/null +++ b/cours3.ipynb @@ -0,0 +1,610 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 138, + "id": "c03a657e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "id": "a462ed55", + "metadata": {}, + "source": [ + "Méthode Newton $\\mathbb{R}$" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "e90827f2", + "metadata": {}, + "outputs": [], + "source": [ + "def f1(x):\n", + " f = 2*x-np.log(x)\n", + " g = 2 - 1/x\n", + " h = 1/(x**2)\n", + " return f, g, h" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "ca26160d", + "metadata": {}, + "outputs": [], + "source": [ + "def f2(x):\n", + " f = x**3 - 6*x**2 + 4*x + 2\n", + " g = 3*x**2 - 12*x + 4\n", + " h = 6*x - 12\n", + " return f, g, h" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "1f6bfe41", + "metadata": {}, + "outputs": [], + "source": [ + "def NewtonR(fct, x0, maxiter, tol=1e-9):\n", + " x = np.zeros(maxiter)\n", + " x[0] = x0\n", + "\n", + " for k in range(maxiter-1):\n", + " f, g, h = fct(x[k])\n", + " x[k+1] = x[k] - g/h\n", + "\n", + " if abs(g) < tol:\n", + " return x[:k+1]\n", + "\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "c012277d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Ici ça marche super bien\n", + "\n", + "absc = np.linspace(0.01, 1.5, 1000)\n", + "oord = f1(absc)[0]\n", + "\n", + "x0 = 0.1\n", + "\n", + "x = NewtonR(f1, x0, 1000)\n", + "for k in range(len(x)):\n", + " f, g, h = f1(x[k])\n", + " plt.plot(x[k], f, 'ob')\n", + "\n", + "plt.plot(absc, oord, 'g')" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "087255d2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Ici ça dépend du point initial\n", + "\n", + "absc = np.linspace(-2, 5, 1000)\n", + "oord = f2(absc)[0]\n", + "\n", + "x0 = [3,0]\n", + "c = ['b', 'r']\n", + "\n", + "for i, x0 in enumerate(x0):\n", + " x = NewtonR(f2, x0, 1000)\n", + " for k in range(len(x)):\n", + " f, g, h = f2(x[k])\n", + " plt.plot(x[k], f, 'o' + c[i])\n", + "\n", + "plt.plot(absc, oord, 'g')" + ] + }, + { + "cell_type": "markdown", + "id": "f68a7951", + "metadata": {}, + "source": [ + "Examen d'implémentation | Gradient et Newton" + ] + }, + { + "cell_type": "markdown", + "id": "06964cdd", + "metadata": {}, + "source": [ + "$f(x_1,x_2)=2x_1^2-1.05x_1^4+x_1^6/6+x_1x_2+x_2^2$\n", + "\n", + "$\\nabla f(x_1,x_2)=\n", + "\\begin{pmatrix}\n", + "4x_1 - 4.2x_1^3 + x_1^5 + x_2 & x_1 + 2x_2 \\\\\n", + "\\end{pmatrix}$\n", + "\n", + "$\\nabla^2 f(x_1,x_2)=\n", + "\\begin{pmatrix}\n", + "4 - 12.6x_1^2 + 5x_1^4 & 1 \\\\\n", + "1 & 2 \\\\\n", + "\\end{pmatrix}$" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "7ba5e5c4", + "metadata": {}, + "outputs": [], + "source": [ + "def fexamen(x, nargout=2):\n", + " x1 = x[0]\n", + " x2 = x[1]\n", + " f = 2*x1**2 - 1.05*x1**4 + x1**6/6 + x1*x2 + x2**2 \n", + "\n", + " g = np.array([4*x1 - 4*1.05*x1**3 + x1**5 + x2, x1 + 2*x2])\n", + "\n", + " if nargout==3:\n", + " H = np.array([[4 - 12*1.05*x1**2 + 5*x1**4, 1],\n", + " [ 1 , 2]])\n", + " return f, g, H\n", + "\n", + " return f, g" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "7fb63347", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(np.float64(1.0), array([1., 2.]))\n" + ] + } + ], + "source": [ + "# Vérification de fexamen: OK\n", + "x = np.array([0,1])\n", + "print(fexamen(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "id": "449e09c6", + "metadata": {}, + "outputs": [], + "source": [ + "def w1(f,x,d,alpha,beta1):\n", + " f0, g0 = f(x) # à l'itéré courant\n", + " f1, g1 = f(x+alpha*d) # à l'itéré potentiel\n", + " return f1 <= f0 + alpha*beta1 * np.dot(d, g0)\n", + "\n", + "def w2(f,x,d,alpha,beta2):\n", + " f0, g0 = f(x) # à l'itéré courant\n", + " f1, g1 = f(x+alpha*d) # à l'itéré potentiel \n", + " return np.dot(d, g1) >= beta2*np.dot(d, g0)\n", + "\n", + "def wolfebissection(f,x,d,alpha,beta1=1e-3,beta2=0.9):\n", + " aleft = 0\n", + " aright = np.inf\n", + "\n", + " while True:\n", + " w_1 = w1(f,x,d,alpha,beta1)\n", + " w_2 = w2(f,x,d,alpha,beta2)\n", + "\n", + " if w_1 and w_2:\n", + " break\n", + "\n", + " elif not w_1:\n", + " aright = alpha\n", + " alpha = (aleft+aright)/2\n", + "\n", + " elif not w_2:\n", + " aleft = alpha\n", + " if aright" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x0 = np.array([0.1, 0.1])\n", + "\n", + "xg, fg, ngg = methgradient(fexamen,x0)\n", + "xn, fn, ngn = methNewton(fexamen,x0)\n", + "\n", + "plt.semilogy(fg, label=\"gradient\")\n", + "plt.semilogy(fn, label=\"Newton\")\n", + "plt.title(\"Evolution de la fonction objectif\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.semilogy(ngg, label=\"gradient\")\n", + "plt.semilogy(ngn, label=\"Newton\")\n", + "plt.title(\"Evolution de la norme du gradient\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "id": "1016c4ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avec la méthode du gradient : x=[-9.13230123e-08 9.55910628e-08]\n", + "fobj=1.7087772621488852e-14 | grad=[-2.69700986e-07 9.98591133e-08] | H=[[4. 1.]\n", + " [1. 2.]]\n", + "EigResult(eigenvalues=array([4.41421356, 1.58578644]), eigenvectors=array([[ 0.92387953, -0.38268343],\n", + " [ 0.38268343, 0.92387953]]))\n", + "Avec la méthode de Newton : x=[ 3.64930450e-08 -1.82465225e-08]\n", + "fobj=2.3305490890415854e-15 | grad=[1.27725658e-07 4.33680869e-19] | H=[[4. 1.]\n", + " [1. 2.]]\n", + "EigResult(eigenvalues=array([4.41421356, 1.58578644]), eigenvectors=array([[ 0.92387953, -0.38268343],\n", + " [ 0.38268343, 0.92387953]]))\n" + ] + } + ], + "source": [ + "print(f\"Avec la méthode du gradient : x={xg}\")\n", + "f, g, H = fexamen(xg, nargout=3)\n", + "print(f\"fobj={f} | grad={g} | H={H}\")\n", + "print(np.linalg.eig(H))\n", + "# On a un point ou le gradient vaut 0 et la matrice hessienne est definie positive\n", + "# => on a un minimum local\n", + "\n", + "print(f\"Avec la méthode de Newton : x={xn}\")\n", + "f, g, H = fexamen(xn, nargout=3)\n", + "print(f\"fobj={f} | grad={g} | H={H}\")\n", + "print(np.linalg.eig(H))\n", + "# On a un point ou le gradient vaut 0 et la matrice hessienne est indéfinie\n", + "# => on a un point selle" + ] + }, + { + "cell_type": "markdown", + "id": "bf54a678", + "metadata": {}, + "source": [ + "$f(x)=(x_1-2x_2)^4 + (x_2-3x_3)^4 + (x_3-4x_4)^4 + \\ldots + (x_n-(x_1+1))^4$\n", + "\n", + "$x_1 = 2x_2 = 2*3*4(x_1+1) => -23x_1=24 => x_1=-24/23$\n", + "\n", + "$x_2 = 3x_3 = 3*4(x_1+1) => x_2 = \\ldots$\n", + "\n", + "$\\ldots$\n", + "\n", + "$x_i = \\frac{-n!}{i(n!-1)}$" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "id": "1a83735f", + "metadata": {}, + "outputs": [], + "source": [ + "def fsize(x,nargout=2):\n", + " n = len(x)\n", + "\n", + " #Calcul de f\n", + " v = 1.0*x\n", + " v[:-1] = v[:-1]-x[1:]*np.arange(2,1+len(x))\n", + " v[-1] = x[-1]-x[0]-1\n", + " f = np.sum(v**4)\n", + "\n", + " #Calcul du gradient uniquement s'il est demandé\n", + " g = 4*v**3\n", + " g[1:] = g[1:]-4*(v[:-1]**3)*np.arange(2,1+len(x))\n", + " g[0] = g[0]-4*v[-1]**3\n", + "\n", + " #Calcul de la hessienne uniquement si elle est demandée\n", + " if nargout==3:\n", + " H = np.zeros((n,n))\n", + " for i in range(1,n):\n", + " H[i-1:i+1,i-1:i+1] = H[i-1:i+1,i-1:i+1]+ 12*v[i-1]**2*np.array([[1,-(i+1)],[-(i+1),(i+1)**2]])\n", + " H[0,0] += 12*v[-1]**2\n", + " H[0,-1] -= 12*v[-1]**2\n", + " H[-1,0] -= 12*v[-1]**2\n", + " H[-1,-1] += 12*v[-1]**2\n", + " if nargout==3:\n", + " return f, g, H\n", + " else:\n", + " return f, g" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "id": "1f5737dc", + "metadata": {}, + "outputs": [], + "source": [ + "def methgradientTime(f,x0,maxtime,maxiter=300):\n", + " start_time = time.time()\n", + " x = x0.copy()\n", + " fobj = np.zeros(maxiter)\n", + " temps = np.zeros(maxiter)\n", + "\n", + " for k in range(maxiter):\n", + " fx, g = f(x)\n", + " d = -g\n", + " alpha = wolfebissection(f,x,d,1)\n", + "\n", + " x = x+alpha*d # calcul nouvel itéré\n", + "\n", + " # sauvegarde des f et g\n", + " fx, g = f(x)\n", + " fobj[k] = fx\n", + " temps[k] = time.time() - start_time\n", + "\n", + " if temps[k] > maxtime:\n", + " break\n", + "\n", + " if np.linalg.norm(g) <= 1e-6:\n", + " break\n", + "\n", + " return x, fobj[:k+1], temps[:k+1]" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "id": "0ee9c336", + "metadata": {}, + "outputs": [], + "source": [ + "def methNewtonTime(f,x0,maxtime,maxiter=300):\n", + " start_time = time.time()\n", + " x = x0.copy()\n", + " fobj = np.zeros(maxiter)\n", + " temps = np.zeros(maxiter)\n", + "\n", + " for k in range(maxiter):\n", + " fx, g, H = f(x, nargout=3) # besoin de H\n", + " z = np.linalg.solve(H,g)\n", + "\n", + " x = x-z # calcul nouvel itéré\n", + "\n", + " # sauvegarde des f et g\n", + " fx, g = f(x)\n", + " fobj[k] = fx\n", + " temps[k] = time.time() - start_time\n", + "\n", + " if temps[k] > maxtime:\n", + " break\n", + "\n", + " # critère d'arrêt\n", + " if np.linalg.norm(g) <= 1e-6:\n", + " break\n", + "\n", + " return x, fobj[:k+1], temps[:k+1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4b1b445", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# La méthode de Newton a le temps de calculer moins d'itérés que le gradient\n", + "# à cause du coût de calcul plus élevé. En terme de temps, le gradient est meilleur.\n", + "\n", + "n = 5000\n", + "x0 = np.ones(n)\n", + "\n", + "maxtime = 15\n", + "xg, fg, tg = methgradientTime(fsize, x0, maxtime)\n", + "xn, fn, tn = methNewtonTime(fsize, x0, maxtime)\n", + "\n", + "plt.semilogy(fg, label=\"gradient\")\n", + "plt.semilogy(fn, label=\"Newton\")\n", + "plt.title(\"Evolution de la fonction objectif en fonction des itérations\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.semilogy(tg, fg, label=\"gradient\")\n", + "plt.semilogy(tn, fn, label=\"Newton\")\n", + "plt.title(\"Evolution de la norme du gradient, en fonction du temps\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "optinonlin", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/exemplenmf2.mat b/exemplenmf2.mat new file mode 100644 index 0000000..fdbe7e0 Binary files /dev/null and b/exemplenmf2.mat differ diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..ae644c7 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,13 @@ +[project] +name = "optinonlin" +version = "0.1.0" +description = "Add your description here" +readme = "README.md" +requires-python = ">=3.13" +dependencies = [ + "ipykernel>=6.30.1", + "jupyter>=1.1.1", + "matplotlib>=3.10.7", + "numpy>=2.3.3", + "scipy>=1.16.2", +] diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..b53bb6a --- /dev/null +++ b/uv.lock @@ -0,0 +1,1859 @@ +version = 1 +requires-python = ">=3.13" +resolution-markers = [ + "python_full_version >= '3.14'", + "python_full_version < '3.14'", +] + +[[package]] +name = "anyio" +version = "4.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "sniffio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097 }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321 }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657 }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393 }, + { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328 }, + { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269 }, + { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558 }, + { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364 }, + { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637 }, + { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934 }, + { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158 }, + { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597 }, + { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231 }, + { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121 }, + { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177 }, + { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090 }, + { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246 }, + { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126 }, + { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343 }, + { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777 }, + { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180 }, + { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715 }, + { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149 }, +] + +[[package]] +name = "arrow" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "types-python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/00/0f6e8fcdb23ea632c866620cc872729ff43ed91d284c866b515c6342b173/arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85", size = 131960 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/ed/e97229a566617f2ae958a6b13e7cc0f585470eac730a73e9e82c32a3cdd2/arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80", size = 66419 }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, +] + +[[package]] +name = "async-lru" +version = "2.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/4d/71ec4d3939dc755264f680f6c2b4906423a304c3d18e96853f0a595dfe97/async_lru-2.0.5.tar.gz", hash = "sha256:481d52ccdd27275f42c43a928b4a50c3bfb2d67af4e78b170e3e0bb39c66e5bb", size = 10380 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/49/d10027df9fce941cb8184e78a02857af36360d33e1721df81c5ed2179a1a/async_lru-2.0.5-py3-none-any.whl", hash = "sha256:ab95404d8d2605310d345932697371a5f40def0487c03d6d0ad9138de52c9943", size = 6069 }, +] + +[[package]] +name = "attrs" +version = "25.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615 }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537 }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/e9/df2358efd7659577435e2177bfa69cba6c33216681af51a707193dec162a/beautifulsoup4-4.14.2.tar.gz", hash = "sha256:2a98ab9f944a11acee9cc848508ec28d9228abfd522ef0fad6a02a72e0ded69e", size = 625822 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/fe/3aed5d0be4d404d12d36ab97e2f1791424d9ca39c2f754a6285d59a3b01d/beautifulsoup4-4.14.2-py3-none-any.whl", hash = "sha256:5ef6fa3a8cbece8488d66985560f97ed091e22bbc4e9c2338508a9d5de6d4515", size = 106392 }, +] + +[[package]] +name = "bleach" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406 }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "certifi" +version = "2025.10.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286 }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230 }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043 }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446 }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101 }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948 }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422 }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499 }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928 }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302 }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909 }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402 }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780 }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320 }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487 }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049 }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793 }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300 }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244 }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828 }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926 }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328 }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650 }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687 }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773 }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013 }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593 }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354 }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480 }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584 }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443 }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437 }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487 }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726 }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195 }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/2d/5fd176ceb9b2fc619e63405525573493ca23441330fcdaee6bef9460e924/charset_normalizer-3.4.3.tar.gz", hash = "sha256:6fce4b8500244f6fcb71465d4a4930d132ba9ab8e71a7859e6a5d59851068d14", size = 122371 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/65/ca/2135ac97709b400c7654b4b764daf5c5567c2da45a30cdd20f9eefe2d658/charset_normalizer-3.4.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:14c2a87c65b351109f6abfc424cab3927b3bdece6f706e4d12faaf3d52ee5efe", size = 205326 }, + { url = "https://files.pythonhosted.org/packages/71/11/98a04c3c97dd34e49c7d247083af03645ca3730809a5509443f3c37f7c99/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41d1fc408ff5fdfb910200ec0e74abc40387bccb3252f3f27c0676731df2b2c8", size = 146008 }, + { url = "https://files.pythonhosted.org/packages/60/f5/4659a4cb3c4ec146bec80c32d8bb16033752574c20b1252ee842a95d1a1e/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1bb60174149316da1c35fa5233681f7c0f9f514509b8e399ab70fea5f17e45c9", size = 159196 }, + { url = "https://files.pythonhosted.org/packages/86/9e/f552f7a00611f168b9a5865a1414179b2c6de8235a4fa40189f6f79a1753/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:30d006f98569de3459c2fc1f2acde170b7b2bd265dc1943e87e1a4efe1b67c31", size = 156819 }, + { url = "https://files.pythonhosted.org/packages/7e/95/42aa2156235cbc8fa61208aded06ef46111c4d3f0de233107b3f38631803/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:416175faf02e4b0810f1f38bcb54682878a4af94059a1cd63b8747244420801f", size = 151350 }, + { url = "https://files.pythonhosted.org/packages/c2/a9/3865b02c56f300a6f94fc631ef54f0a8a29da74fb45a773dfd3dcd380af7/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6aab0f181c486f973bc7262a97f5aca3ee7e1437011ef0c2ec04b5a11d16c927", size = 148644 }, + { url = "https://files.pythonhosted.org/packages/77/d9/cbcf1a2a5c7d7856f11e7ac2d782aec12bdfea60d104e60e0aa1c97849dc/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:fdabf8315679312cfa71302f9bd509ded4f2f263fb5b765cf1433b39106c3cc9", size = 160468 }, + { url = "https://files.pythonhosted.org/packages/f6/42/6f45efee8697b89fda4d50580f292b8f7f9306cb2971d4b53f8914e4d890/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:bd28b817ea8c70215401f657edef3a8aa83c29d447fb0b622c35403780ba11d5", size = 158187 }, + { url = "https://files.pythonhosted.org/packages/70/99/f1c3bdcfaa9c45b3ce96f70b14f070411366fa19549c1d4832c935d8e2c3/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:18343b2d246dc6761a249ba1fb13f9ee9a2bcd95decc767319506056ea4ad4dc", size = 152699 }, + { url = "https://files.pythonhosted.org/packages/a3/ad/b0081f2f99a4b194bcbb1934ef3b12aa4d9702ced80a37026b7607c72e58/charset_normalizer-3.4.3-cp313-cp313-win32.whl", hash = "sha256:6fb70de56f1859a3f71261cbe41005f56a7842cc348d3aeb26237560bfa5e0ce", size = 99580 }, + { url = "https://files.pythonhosted.org/packages/9a/8f/ae790790c7b64f925e5c953b924aaa42a243fb778fed9e41f147b2a5715a/charset_normalizer-3.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:cf1ebb7d78e1ad8ec2a8c4732c7be2e736f6e5123a4146c5b89c9d1f585f8cef", size = 107366 }, + { url = "https://files.pythonhosted.org/packages/8e/91/b5a06ad970ddc7a0e513112d40113e834638f4ca1120eb727a249fb2715e/charset_normalizer-3.4.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3cd35b7e8aedeb9e34c41385fda4f73ba609e561faedfae0a9e75e44ac558a15", size = 204342 }, + { url = "https://files.pythonhosted.org/packages/ce/ec/1edc30a377f0a02689342f214455c3f6c2fbedd896a1d2f856c002fc3062/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b89bc04de1d83006373429975f8ef9e7932534b8cc9ca582e4db7d20d91816db", size = 145995 }, + { url = "https://files.pythonhosted.org/packages/17/e5/5e67ab85e6d22b04641acb5399c8684f4d37caf7558a53859f0283a650e9/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2001a39612b241dae17b4687898843f254f8748b796a2e16f1051a17078d991d", size = 158640 }, + { url = "https://files.pythonhosted.org/packages/f1/e5/38421987f6c697ee3722981289d554957c4be652f963d71c5e46a262e135/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8dcfc373f888e4fb39a7bc57e93e3b845e7f462dacc008d9749568b1c4ece096", size = 156636 }, + { url = "https://files.pythonhosted.org/packages/a0/e4/5a075de8daa3ec0745a9a3b54467e0c2967daaaf2cec04c845f73493e9a1/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b97b8404387b96cdbd30ad660f6407799126d26a39ca65729162fd810a99aa", size = 150939 }, + { url = "https://files.pythonhosted.org/packages/02/f7/3611b32318b30974131db62b4043f335861d4d9b49adc6d57c1149cc49d4/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ccf600859c183d70eb47e05a44cd80a4ce77394d1ac0f79dbd2dd90a69a3a049", size = 148580 }, + { url = "https://files.pythonhosted.org/packages/7e/61/19b36f4bd67f2793ab6a99b979b4e4f3d8fc754cbdffb805335df4337126/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:53cd68b185d98dde4ad8990e56a58dea83a4162161b1ea9272e5c9182ce415e0", size = 159870 }, + { url = "https://files.pythonhosted.org/packages/06/57/84722eefdd338c04cf3030ada66889298eaedf3e7a30a624201e0cbe424a/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:30a96e1e1f865f78b030d65241c1ee850cdf422d869e9028e2fc1d5e4db73b92", size = 157797 }, + { url = "https://files.pythonhosted.org/packages/72/2a/aff5dd112b2f14bcc3462c312dce5445806bfc8ab3a7328555da95330e4b/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d716a916938e03231e86e43782ca7878fb602a125a91e7acb8b5112e2e96ac16", size = 152224 }, + { url = "https://files.pythonhosted.org/packages/b7/8c/9839225320046ed279c6e839d51f028342eb77c91c89b8ef2549f951f3ec/charset_normalizer-3.4.3-cp314-cp314-win32.whl", hash = "sha256:c6dbd0ccdda3a2ba7c2ecd9d77b37f3b5831687d8dc1b6ca5f56a4880cc7b7ce", size = 100086 }, + { url = "https://files.pythonhosted.org/packages/ee/7a/36fbcf646e41f710ce0a563c1c9a343c6edf9be80786edeb15b6f62e17db/charset_normalizer-3.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:73dc19b562516fc9bcf6e5d6e596df0b4eb98d87e4f79f3ae71840e6ed21361c", size = 107400 }, + { url = "https://files.pythonhosted.org/packages/8a/1f/f041989e93b001bc4e44bb1669ccdcf54d3f00e628229a85b08d330615c5/charset_normalizer-3.4.3-py3-none-any.whl", hash = "sha256:ce571ab16d890d23b5c278547ba694193a45011ff86a9162a71307ed9f86759a", size = 53175 }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, +] + +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294 }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257 }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034 }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672 }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234 }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169 }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859 }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062 }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932 }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024 }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578 }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524 }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730 }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897 }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751 }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486 }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106 }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548 }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297 }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023 }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157 }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570 }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713 }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189 }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251 }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810 }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871 }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264 }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819 }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650 }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833 }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692 }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424 }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300 }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769 }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892 }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748 }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554 }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118 }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555 }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295 }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027 }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428 }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331 }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831 }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 }, +] + +[[package]] +name = "debugpy" +version = "1.8.17" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/ad/71e708ff4ca377c4230530d6a7aa7992592648c122a2cd2b321cf8b35a76/debugpy-1.8.17.tar.gz", hash = "sha256:fd723b47a8c08892b1a16b2c6239a8b96637c62a59b94bb5dab4bac592a58a8e", size = 1644129 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/76/597e5cb97d026274ba297af8d89138dfd9e695767ba0e0895edb20963f40/debugpy-1.8.17-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:857c1dd5d70042502aef1c6d1c2801211f3ea7e56f75e9c335f434afb403e464", size = 2538386 }, + { url = "https://files.pythonhosted.org/packages/5f/60/ce5c34fcdfec493701f9d1532dba95b21b2f6394147234dce21160bd923f/debugpy-1.8.17-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:3bea3b0b12f3946e098cce9b43c3c46e317b567f79570c3f43f0b96d00788088", size = 4292100 }, + { url = "https://files.pythonhosted.org/packages/e8/95/7873cf2146577ef71d2a20bf553f12df865922a6f87b9e8ee1df04f01785/debugpy-1.8.17-cp313-cp313-win32.whl", hash = "sha256:e34ee844c2f17b18556b5bbe59e1e2ff4e86a00282d2a46edab73fd7f18f4a83", size = 5277002 }, + { url = "https://files.pythonhosted.org/packages/46/11/18c79a1cee5ff539a94ec4aa290c1c069a5580fd5cfd2fb2e282f8e905da/debugpy-1.8.17-cp313-cp313-win_amd64.whl", hash = "sha256:6c5cd6f009ad4fca8e33e5238210dc1e5f42db07d4b6ab21ac7ffa904a196420", size = 5319047 }, + { url = "https://files.pythonhosted.org/packages/de/45/115d55b2a9da6de812696064ceb505c31e952c5d89c4ed1d9bb983deec34/debugpy-1.8.17-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:045290c010bcd2d82bc97aa2daf6837443cd52f6328592698809b4549babcee1", size = 2536899 }, + { url = "https://files.pythonhosted.org/packages/5a/73/2aa00c7f1f06e997ef57dc9b23d61a92120bec1437a012afb6d176585197/debugpy-1.8.17-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:b69b6bd9dba6a03632534cdf67c760625760a215ae289f7489a452af1031fe1f", size = 4268254 }, + { url = "https://files.pythonhosted.org/packages/86/b5/ed3e65c63c68a6634e3ba04bd10255c8e46ec16ebed7d1c79e4816d8a760/debugpy-1.8.17-cp314-cp314-win32.whl", hash = "sha256:5c59b74aa5630f3a5194467100c3b3d1c77898f9ab27e3f7dc5d40fc2f122670", size = 5277203 }, + { url = "https://files.pythonhosted.org/packages/b0/26/394276b71c7538445f29e792f589ab7379ae70fd26ff5577dfde71158e96/debugpy-1.8.17-cp314-cp314-win_amd64.whl", hash = "sha256:893cba7bb0f55161de4365584b025f7064e1f88913551bcd23be3260b231429c", size = 5318493 }, + { url = "https://files.pythonhosted.org/packages/b0/d0/89247ec250369fc76db477720a26b2fce7ba079ff1380e4ab4529d2fe233/debugpy-1.8.17-py2.py3-none-any.whl", hash = "sha256:60c7dca6571efe660ccb7a9508d73ca14b8796c4ed484c2002abba714226cfef", size = 5283210 }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190 }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604 }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317 }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024 }, +] + +[[package]] +name = "fonttools" +version = "4.60.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4b/42/97a13e47a1e51a5a7142475bbcf5107fe3a68fc34aef331c897d5fb98ad0/fonttools-4.60.1.tar.gz", hash = "sha256:ef00af0439ebfee806b25f24c8f92109157ff3fac5731dc7867957812e87b8d9", size = 3559823 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/5b/cdd2c612277b7ac7ec8c0c9bc41812c43dc7b2d5f2b0897e15fdf5a1f915/fonttools-4.60.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f68576bb4bbf6060c7ab047b1574a1ebe5c50a17de62830079967b211059ebb", size = 2825777 }, + { url = "https://files.pythonhosted.org/packages/d6/8a/de9cc0540f542963ba5e8f3a1f6ad48fa211badc3177783b9d5cadf79b5d/fonttools-4.60.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:eedacb5c5d22b7097482fa834bda0dafa3d914a4e829ec83cdea2a01f8c813c4", size = 2348080 }, + { url = "https://files.pythonhosted.org/packages/2d/8b/371ab3cec97ee3fe1126b3406b7abd60c8fec8975fd79a3c75cdea0c3d83/fonttools-4.60.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b33a7884fabd72bdf5f910d0cf46be50dce86a0362a65cfc746a4168c67eb96c", size = 4903082 }, + { url = "https://files.pythonhosted.org/packages/04/05/06b1455e4bc653fcb2117ac3ef5fa3a8a14919b93c60742d04440605d058/fonttools-4.60.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2409d5fb7b55fd70f715e6d34e7a6e4f7511b8ad29a49d6df225ee76da76dd77", size = 4960125 }, + { url = "https://files.pythonhosted.org/packages/8e/37/f3b840fcb2666f6cb97038793606bdd83488dca2d0b0fc542ccc20afa668/fonttools-4.60.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c8651e0d4b3bdeda6602b85fdc2abbefc1b41e573ecb37b6779c4ca50753a199", size = 4901454 }, + { url = "https://files.pythonhosted.org/packages/fd/9e/eb76f77e82f8d4a46420aadff12cec6237751b0fb9ef1de373186dcffb5f/fonttools-4.60.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:145daa14bf24824b677b9357c5e44fd8895c2a8f53596e1b9ea3496081dc692c", size = 5044495 }, + { url = "https://files.pythonhosted.org/packages/f8/b3/cede8f8235d42ff7ae891bae8d619d02c8ac9fd0cfc450c5927a6200c70d/fonttools-4.60.1-cp313-cp313-win32.whl", hash = "sha256:2299df884c11162617a66b7c316957d74a18e3758c0274762d2cc87df7bc0272", size = 2217028 }, + { url = "https://files.pythonhosted.org/packages/75/4d/b022c1577807ce8b31ffe055306ec13a866f2337ecee96e75b24b9b753ea/fonttools-4.60.1-cp313-cp313-win_amd64.whl", hash = "sha256:a3db56f153bd4c5c2b619ab02c5db5192e222150ce5a1bc10f16164714bc39ac", size = 2266200 }, + { url = "https://files.pythonhosted.org/packages/9a/83/752ca11c1aa9a899b793a130f2e466b79ea0cf7279c8d79c178fc954a07b/fonttools-4.60.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:a884aef09d45ba1206712c7dbda5829562d3fea7726935d3289d343232ecb0d3", size = 2822830 }, + { url = "https://files.pythonhosted.org/packages/57/17/bbeab391100331950a96ce55cfbbff27d781c1b85ebafb4167eae50d9fe3/fonttools-4.60.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8a44788d9d91df72d1a5eac49b31aeb887a5f4aab761b4cffc4196c74907ea85", size = 2345524 }, + { url = "https://files.pythonhosted.org/packages/3d/2e/d4831caa96d85a84dd0da1d9f90d81cec081f551e0ea216df684092c6c97/fonttools-4.60.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e852d9dda9f93ad3651ae1e3bb770eac544ec93c3807888798eccddf84596537", size = 4843490 }, + { url = "https://files.pythonhosted.org/packages/49/13/5e2ea7c7a101b6fc3941be65307ef8df92cbbfa6ec4804032baf1893b434/fonttools-4.60.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:154cb6ee417e417bf5f7c42fe25858c9140c26f647c7347c06f0cc2d47eff003", size = 4944184 }, + { url = "https://files.pythonhosted.org/packages/0c/2b/cf9603551c525b73fc47c52ee0b82a891579a93d9651ed694e4e2cd08bb8/fonttools-4.60.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5664fd1a9ea7f244487ac8f10340c4e37664675e8667d6fee420766e0fb3cf08", size = 4890218 }, + { url = "https://files.pythonhosted.org/packages/fd/2f/933d2352422e25f2376aae74f79eaa882a50fb3bfef3c0d4f50501267101/fonttools-4.60.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:583b7f8e3c49486e4d489ad1deacfb8d5be54a8ef34d6df824f6a171f8511d99", size = 4999324 }, + { url = "https://files.pythonhosted.org/packages/38/99/234594c0391221f66216bc2c886923513b3399a148defaccf81dc3be6560/fonttools-4.60.1-cp314-cp314-win32.whl", hash = "sha256:66929e2ea2810c6533a5184f938502cfdaea4bc3efb7130d8cc02e1c1b4108d6", size = 2220861 }, + { url = "https://files.pythonhosted.org/packages/3e/1d/edb5b23726dde50fc4068e1493e4fc7658eeefcaf75d4c5ffce067d07ae5/fonttools-4.60.1-cp314-cp314-win_amd64.whl", hash = "sha256:f3d5be054c461d6a2268831f04091dc82753176f6ea06dc6047a5e168265a987", size = 2270934 }, + { url = "https://files.pythonhosted.org/packages/fb/da/1392aaa2170adc7071fe7f9cfd181a5684a7afcde605aebddf1fb4d76df5/fonttools-4.60.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:b6379e7546ba4ae4b18f8ae2b9bc5960936007a1c0e30b342f662577e8bc3299", size = 2894340 }, + { url = "https://files.pythonhosted.org/packages/bf/a7/3b9f16e010d536ce567058b931a20b590d8f3177b2eda09edd92e392375d/fonttools-4.60.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9d0ced62b59e0430b3690dbc5373df1c2aa7585e9a8ce38eff87f0fd993c5b01", size = 2375073 }, + { url = "https://files.pythonhosted.org/packages/9b/b5/e9bcf51980f98e59bb5bb7c382a63c6f6cac0eec5f67de6d8f2322382065/fonttools-4.60.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:875cb7764708b3132637f6c5fb385b16eeba0f7ac9fa45a69d35e09b47045801", size = 4849758 }, + { url = "https://files.pythonhosted.org/packages/e3/dc/1d2cf7d1cba82264b2f8385db3f5960e3d8ce756b4dc65b700d2c496f7e9/fonttools-4.60.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a184b2ea57b13680ab6d5fbde99ccef152c95c06746cb7718c583abd8f945ccc", size = 5085598 }, + { url = "https://files.pythonhosted.org/packages/5d/4d/279e28ba87fb20e0c69baf72b60bbf1c4d873af1476806a7b5f2b7fac1ff/fonttools-4.60.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:026290e4ec76583881763fac284aca67365e0be9f13a7fb137257096114cb3bc", size = 4957603 }, + { url = "https://files.pythonhosted.org/packages/78/d4/ff19976305e0c05aa3340c805475abb00224c954d3c65e82c0a69633d55d/fonttools-4.60.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f0e8817c7d1a0c2eedebf57ef9a9896f3ea23324769a9a2061a80fe8852705ed", size = 4974184 }, + { url = "https://files.pythonhosted.org/packages/63/22/8553ff6166f5cd21cfaa115aaacaa0dc73b91c079a8cfd54a482cbc0f4f5/fonttools-4.60.1-cp314-cp314t-win32.whl", hash = "sha256:1410155d0e764a4615774e5c2c6fc516259fe3eca5882f034eb9bfdbee056259", size = 2282241 }, + { url = "https://files.pythonhosted.org/packages/8a/cb/fa7b4d148e11d5a72761a22e595344133e83a9507a4c231df972e657579b/fonttools-4.60.1-cp314-cp314t-win_amd64.whl", hash = "sha256:022beaea4b73a70295b688f817ddc24ed3e3418b5036ffcd5658141184ef0d0c", size = 2345760 }, + { url = "https://files.pythonhosted.org/packages/c7/93/0dd45cd283c32dea1545151d8c3637b4b8c53cdb3a625aeb2885b184d74d/fonttools-4.60.1-py3-none-any.whl", hash = "sha256:906306ac7afe2156fcf0042173d6ebbb05416af70f6b370967b47f8f00103bbb", size = 1143175 }, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121 }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, +] + +[[package]] +name = "ipykernel" +version = "6.30.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/76/11082e338e0daadc89c8ff866185de11daf67d181901038f9e139d109761/ipykernel-6.30.1.tar.gz", hash = "sha256:6abb270161896402e76b91394fcdce5d1be5d45f456671e5080572f8505be39b", size = 166260 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/c7/b445faca8deb954fe536abebff4ece5b097b923de482b26e78448c89d1dd/ipykernel-6.30.1-py3-none-any.whl", hash = "sha256:aa6b9fb93dca949069d8b85b6c79b2518e32ac583ae9c7d37c51d119e18b3fb4", size = 117484 }, +] + +[[package]] +name = "ipython" +version = "9.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/34/29b18c62e39ee2f7a6a3bba7efd952729d8aadd45ca17efc34453b717665/ipython-9.6.0.tar.gz", hash = "sha256:5603d6d5d356378be5043e69441a072b50a5b33b4503428c77b04cb8ce7bc731", size = 4396932 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/c5/d5e07995077e48220269c28a221e168c91123ad5ceee44d548f54a057fc0/ipython-9.6.0-py3-none-any.whl", hash = "sha256:5f77efafc886d2f023442479b8149e7d86547ad0a979e9da9f045d252f648196", size = 616170 }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074 }, +] + +[[package]] +name = "ipywidgets" +version = "8.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3e/48/d3dbac45c2814cb73812f98dd6b38bbcc957a4e7bb31d6ea9c03bf94ed87/ipywidgets-8.1.7.tar.gz", hash = "sha256:15f1ac050b9ccbefd45dccfbb2ef6bed0029d8278682d569d71b8dd96bee0376", size = 116721 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/6a/9166369a2f092bd286d24e6307de555d63616e8ddb373ebad2b5635ca4cd/ipywidgets-8.1.7-py3-none-any.whl", hash = "sha256:764f2602d25471c213919b8a1997df04bef869251db4ca8efba1b76b1bd9f7bb", size = 139806 }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321 }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 }, +] + +[[package]] +name = "json5" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/12/ae/929aee9619e9eba9015207a9d2c1c54db18311da7eb4dcf6d41ad6f0eb67/json5-0.12.1.tar.gz", hash = "sha256:b2743e77b3242f8d03c143dd975a6ec7c52e2f2afe76ed934e53503dd4ad4990", size = 52191 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/e2/05328bd2621be49a6fed9e3030b1e51a2d04537d3f816d211b9cc53c5262/json5-0.12.1-py3-none-any.whl", hash = "sha256:d9c9b3bc34a5f54d43c35e11ef7cb87d8bdd098c6ace87117a7b7e83e705c1d5", size = 36119 }, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595 }, +] + +[[package]] +name = "jsonschema" +version = "4.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040 }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437 }, +] + +[[package]] +name = "jupyter" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657 }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105 }, +] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510 }, +] + +[[package]] +name = "jupyter-core" +version = "5.8.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/1b/72906d554acfeb588332eaaa6f61577705e9ec752ddb486f302dafa292d9/jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941", size = 88923 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/57/6bffd4b20b88da3800c5d691e0337761576ee688eb01299eae865689d2df/jupyter_core-5.8.1-py3-none-any.whl", hash = "sha256:c28d268fc90fb53f1338ded2eb410704c5449a358406e8a948b75706e24863d0", size = 28880 }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/c3/306d090461e4cf3cd91eceaff84bede12a8e52cd821c2d20c9a4fd728385/jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b", size = 62196 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/48/577993f1f99c552f18a0428731a755e06171f9902fa118c379eb7c04ea22/jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb", size = 19430 }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/5a/9066c9f8e94ee517133cd98dba393459a16cd48bba71a82f16a65415206c/jupyter_lsp-2.3.0.tar.gz", hash = "sha256:458aa59339dc868fb784d73364f17dbce8836e906cd75fd471a325cba02e0245", size = 54823 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/60/1f6cee0c46263de1173894f0fafcb3475ded276c472c14d25e0280c18d6d/jupyter_lsp-2.3.0-py3-none-any.whl", hash = "sha256:e914a3cb2addf48b1c7710914771aaf1819d46b2e5a79b0f917b5478ec93f34f", size = 76687 }, +] + +[[package]] +name = "jupyter-server" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/ac/e040ec363d7b6b1f11304cc9f209dac4517ece5d5e01821366b924a64a50/jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5", size = 731949 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/80/a24767e6ca280f5a49525d987bf3e4d7552bf67c8be07e8ccf20271f8568/jupyter_server-2.17.0-py3-none-any.whl", hash = "sha256:e8cb9c7db4251f51ed307e329b81b72ccf2056ff82d50524debde1ee1870e13f", size = 388221 }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/2d/2b32cdbe8d2a602f697a649798554e4f072115438e92249624e532e8aca6/jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa", size = 13656 }, +] + +[[package]] +name = "jupyterlab" +version = "4.4.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/45/b2/7dad2d0049a904d17c070226a4f78f81905f93bfe09503722d210ccf9335/jupyterlab-4.4.9.tar.gz", hash = "sha256:ea55aca8269909016d5fde2dc09b97128bc931230183fe7e2920ede5154ad9c2", size = 22966654 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/fd/ac0979ebd1b1975c266c99b96930b0a66609c3f6e5d76979ca6eb3073896/jupyterlab-4.4.9-py3-none-any.whl", hash = "sha256:394c902827350c017430a8370b9f40c03c098773084bc53930145c146d3d2cb2", size = 12292552 }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884 }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/c9/a883ce65eb27905ce77ace410d83587c82ea64dc85a48d1f7ed52bcfa68d/jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4", size = 76173 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/09/2032e7d15c544a0e3cd831c51d77a8ca57f7555b2e1b2922142eddb02a84/jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4", size = 59700 }, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/7d/160595ca88ee87ac6ba95d82177d29ec60aaa63821d3077babb22ce031a5/jupyterlab_widgets-3.0.15.tar.gz", hash = "sha256:2920888a0c2922351a9202817957a68c07d99673504d6cd37345299e971bb08b", size = 213149 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/6a/ca128561b22b60bd5a0c4ea26649e68c8556b82bc70a0c396eebc977fe86/jupyterlab_widgets-3.0.15-py3-none-any.whl", hash = "sha256:d59023d7d7ef71400d51e6fee9a88867f6e65e10a4201605d2d7f3e8f012a31c", size = 216571 }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681 }, + { url = "https://files.pythonhosted.org/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464 }, + { url = "https://files.pythonhosted.org/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961 }, + { url = "https://files.pythonhosted.org/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607 }, + { url = "https://files.pythonhosted.org/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546 }, + { url = "https://files.pythonhosted.org/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482 }, + { url = "https://files.pythonhosted.org/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720 }, + { url = "https://files.pythonhosted.org/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907 }, + { url = "https://files.pythonhosted.org/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334 }, + { url = "https://files.pythonhosted.org/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313 }, + { url = "https://files.pythonhosted.org/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970 }, + { url = "https://files.pythonhosted.org/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894 }, + { url = "https://files.pythonhosted.org/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995 }, + { url = "https://files.pythonhosted.org/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510 }, + { url = "https://files.pythonhosted.org/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903 }, + { url = "https://files.pythonhosted.org/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402 }, + { url = "https://files.pythonhosted.org/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135 }, + { url = "https://files.pythonhosted.org/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409 }, + { url = "https://files.pythonhosted.org/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763 }, + { url = "https://files.pythonhosted.org/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643 }, + { url = "https://files.pythonhosted.org/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818 }, + { url = "https://files.pythonhosted.org/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963 }, + { url = "https://files.pythonhosted.org/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639 }, + { url = "https://files.pythonhosted.org/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741 }, + { url = "https://files.pythonhosted.org/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646 }, + { url = "https://files.pythonhosted.org/packages/6b/32/6cc0fbc9c54d06c2969faa9c1d29f5751a2e51809dd55c69055e62d9b426/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386", size = 123806 }, + { url = "https://files.pythonhosted.org/packages/b2/dd/2bfb1d4a4823d92e8cbb420fe024b8d2167f72079b3bb941207c42570bdf/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552", size = 66605 }, + { url = "https://files.pythonhosted.org/packages/f7/69/00aafdb4e4509c2ca6064646cba9cd4b37933898f426756adb2cb92ebbed/kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3", size = 64925 }, + { url = "https://files.pythonhosted.org/packages/43/dc/51acc6791aa14e5cb6d8a2e28cefb0dc2886d8862795449d021334c0df20/kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58", size = 1472414 }, + { url = "https://files.pythonhosted.org/packages/3d/bb/93fa64a81db304ac8a246f834d5094fae4b13baf53c839d6bb6e81177129/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4", size = 1281272 }, + { url = "https://files.pythonhosted.org/packages/70/e6/6df102916960fb8d05069d4bd92d6d9a8202d5a3e2444494e7cd50f65b7a/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df", size = 1298578 }, + { url = "https://files.pythonhosted.org/packages/7c/47/e142aaa612f5343736b087864dbaebc53ea8831453fb47e7521fa8658f30/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6", size = 1345607 }, + { url = "https://files.pythonhosted.org/packages/54/89/d641a746194a0f4d1a3670fb900d0dbaa786fb98341056814bc3f058fa52/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5", size = 2230150 }, + { url = "https://files.pythonhosted.org/packages/aa/6b/5ee1207198febdf16ac11f78c5ae40861b809cbe0e6d2a8d5b0b3044b199/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf", size = 2325979 }, + { url = "https://files.pythonhosted.org/packages/fc/ff/b269eefd90f4ae14dcc74973d5a0f6d28d3b9bb1afd8c0340513afe6b39a/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5", size = 2491456 }, + { url = "https://files.pythonhosted.org/packages/fc/d4/10303190bd4d30de547534601e259a4fbf014eed94aae3e5521129215086/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce", size = 2294621 }, + { url = "https://files.pythonhosted.org/packages/28/e0/a9a90416fce5c0be25742729c2ea52105d62eda6c4be4d803c2a7be1fa50/kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7", size = 75417 }, + { url = "https://files.pythonhosted.org/packages/1f/10/6949958215b7a9a264299a7db195564e87900f709db9245e4ebdd3c70779/kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c", size = 66582 }, + { url = "https://files.pythonhosted.org/packages/ec/79/60e53067903d3bc5469b369fe0dfc6b3482e2133e85dae9daa9527535991/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548", size = 126514 }, + { url = "https://files.pythonhosted.org/packages/25/d1/4843d3e8d46b072c12a38c97c57fab4608d36e13fe47d47ee96b4d61ba6f/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d", size = 67905 }, + { url = "https://files.pythonhosted.org/packages/8c/ae/29ffcbd239aea8b93108de1278271ae764dfc0d803a5693914975f200596/kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c", size = 66399 }, + { url = "https://files.pythonhosted.org/packages/a1/ae/d7ba902aa604152c2ceba5d352d7b62106bedbccc8e95c3934d94472bfa3/kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122", size = 1582197 }, + { url = "https://files.pythonhosted.org/packages/f2/41/27c70d427eddb8bc7e4f16420a20fefc6f480312122a59a959fdfe0445ad/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64", size = 1390125 }, + { url = "https://files.pythonhosted.org/packages/41/42/b3799a12bafc76d962ad69083f8b43b12bf4fe78b097b12e105d75c9b8f1/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134", size = 1402612 }, + { url = "https://files.pythonhosted.org/packages/d2/b5/a210ea073ea1cfaca1bb5c55a62307d8252f531beb364e18aa1e0888b5a0/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370", size = 1453990 }, + { url = "https://files.pythonhosted.org/packages/5f/ce/a829eb8c033e977d7ea03ed32fb3c1781b4fa0433fbadfff29e39c676f32/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21", size = 2331601 }, + { url = "https://files.pythonhosted.org/packages/e0/4b/b5e97eb142eb9cd0072dacfcdcd31b1c66dc7352b0f7c7255d339c0edf00/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a", size = 2422041 }, + { url = "https://files.pythonhosted.org/packages/40/be/8eb4cd53e1b85ba4edc3a9321666f12b83113a178845593307a3e7891f44/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f", size = 2594897 }, + { url = "https://files.pythonhosted.org/packages/99/dd/841e9a66c4715477ea0abc78da039832fbb09dac5c35c58dc4c41a407b8a/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369", size = 2391835 }, + { url = "https://files.pythonhosted.org/packages/0c/28/4b2e5c47a0da96896fdfdb006340ade064afa1e63675d01ea5ac222b6d52/kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891", size = 79988 }, + { url = "https://files.pythonhosted.org/packages/80/be/3578e8afd18c88cdf9cb4cffde75a96d2be38c5a903f1ed0ceec061bd09e/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32", size = 70260 }, +] + +[[package]] +name = "lark" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/37/a13baf0135f348af608c667633cbe5d13aa2c5c15a56ae9ad3e6cba45ae3/lark-1.3.0.tar.gz", hash = "sha256:9a3839d0ca5e1faf7cfa3460e420e859b66bcbde05b634e73c369c8244c5fa48", size = 259551 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/3e/1c6b43277de64fc3c0333b0e72ab7b52ddaaea205210d60d9b9f83c3d0c7/lark-1.3.0-py3-none-any.whl", hash = "sha256:80661f261fb2584a9828a097a2432efd575af27d20be0fd35d17f0fe37253831", size = 113002 }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622 }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029 }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374 }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980 }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990 }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784 }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588 }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041 }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543 }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113 }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911 }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658 }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066 }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639 }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569 }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284 }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801 }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769 }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642 }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612 }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200 }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973 }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619 }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029 }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408 }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005 }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048 }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821 }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606 }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043 }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747 }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341 }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073 }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661 }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069 }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670 }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598 }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261 }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835 }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733 }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672 }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819 }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426 }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146 }, +] + +[[package]] +name = "matplotlib" +version = "3.10.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/e2/d2d5295be2f44c678ebaf3544ba32d20c1f9ef08c49fe47f496180e1db15/matplotlib-3.10.7.tar.gz", hash = "sha256:a06ba7e2a2ef9131c79c49e63dad355d2d878413a0376c1727c8b9335ff731c7", size = 34804865 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/9c/207547916a02c78f6bdd83448d9b21afbc42f6379ed887ecf610984f3b4e/matplotlib-3.10.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1d9d3713a237970569156cfb4de7533b7c4eacdd61789726f444f96a0d28f57f", size = 8273212 }, + { url = "https://files.pythonhosted.org/packages/bc/d0/b3d3338d467d3fc937f0bb7f256711395cae6f78e22cef0656159950adf0/matplotlib-3.10.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37a1fea41153dd6ee061d21ab69c9cf2cf543160b1b85d89cd3d2e2a7902ca4c", size = 8128713 }, + { url = "https://files.pythonhosted.org/packages/22/ff/6425bf5c20d79aa5b959d1ce9e65f599632345391381c9a104133fe0b171/matplotlib-3.10.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b3c4ea4948d93c9c29dc01c0c23eef66f2101bf75158c291b88de6525c55c3d1", size = 8698527 }, + { url = "https://files.pythonhosted.org/packages/d0/7f/ccdca06f4c2e6c7989270ed7829b8679466682f4cfc0f8c9986241c023b6/matplotlib-3.10.7-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22df30ffaa89f6643206cf13877191c63a50e8f800b038bc39bee9d2d4957632", size = 9529690 }, + { url = "https://files.pythonhosted.org/packages/b8/95/b80fc2c1f269f21ff3d193ca697358e24408c33ce2b106a7438a45407b63/matplotlib-3.10.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b69676845a0a66f9da30e87f48be36734d6748024b525ec4710be40194282c84", size = 9593732 }, + { url = "https://files.pythonhosted.org/packages/e1/b6/23064a96308b9aeceeffa65e96bcde459a2ea4934d311dee20afde7407a0/matplotlib-3.10.7-cp313-cp313-win_amd64.whl", hash = "sha256:744991e0cc863dd669c8dc9136ca4e6e0082be2070b9d793cbd64bec872a6815", size = 8122727 }, + { url = "https://files.pythonhosted.org/packages/b3/a6/2faaf48133b82cf3607759027f82b5c702aa99cdfcefb7f93d6ccf26a424/matplotlib-3.10.7-cp313-cp313-win_arm64.whl", hash = "sha256:fba2974df0bf8ce3c995fa84b79cde38326e0f7b5409e7a3a481c1141340bcf7", size = 7992958 }, + { url = "https://files.pythonhosted.org/packages/4a/f0/b018fed0b599bd48d84c08794cb242227fe3341952da102ee9d9682db574/matplotlib-3.10.7-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:932c55d1fa7af4423422cb6a492a31cbcbdbe68fd1a9a3f545aa5e7a143b5355", size = 8316849 }, + { url = "https://files.pythonhosted.org/packages/b0/b7/bb4f23856197659f275e11a2a164e36e65e9b48ea3e93c4ec25b4f163198/matplotlib-3.10.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e38c2d581d62ee729a6e144c47a71b3f42fb4187508dbbf4fe71d5612c3433b", size = 8178225 }, + { url = "https://files.pythonhosted.org/packages/62/56/0600609893ff277e6f3ab3c0cef4eafa6e61006c058e84286c467223d4d5/matplotlib-3.10.7-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:786656bb13c237bbcebcd402f65f44dd61ead60ee3deb045af429d889c8dbc67", size = 8711708 }, + { url = "https://files.pythonhosted.org/packages/d8/1a/6bfecb0cafe94d6658f2f1af22c43b76cf7a1c2f0dc34ef84cbb6809617e/matplotlib-3.10.7-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09d7945a70ea43bf9248f4b6582734c2fe726723204a76eca233f24cffc7ef67", size = 9541409 }, + { url = "https://files.pythonhosted.org/packages/08/50/95122a407d7f2e446fd865e2388a232a23f2b81934960ea802f3171518e4/matplotlib-3.10.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d0b181e9fa8daf1d9f2d4c547527b167cb8838fc587deabca7b5c01f97199e84", size = 9594054 }, + { url = "https://files.pythonhosted.org/packages/13/76/75b194a43b81583478a81e78a07da8d9ca6ddf50dd0a2ccabf258059481d/matplotlib-3.10.7-cp313-cp313t-win_amd64.whl", hash = "sha256:31963603041634ce1a96053047b40961f7a29eb8f9a62e80cc2c0427aa1d22a2", size = 8200100 }, + { url = "https://files.pythonhosted.org/packages/f5/9e/6aefebdc9f8235c12bdeeda44cc0383d89c1e41da2c400caf3ee2073a3ce/matplotlib-3.10.7-cp313-cp313t-win_arm64.whl", hash = "sha256:aebed7b50aa6ac698c90f60f854b47e48cd2252b30510e7a1feddaf5a3f72cbf", size = 8042131 }, + { url = "https://files.pythonhosted.org/packages/0d/4b/e5bc2c321b6a7e3a75638d937d19ea267c34bd5a90e12bee76c4d7c7a0d9/matplotlib-3.10.7-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d883460c43e8c6b173fef244a2341f7f7c0e9725c7fe68306e8e44ed9c8fb100", size = 8273787 }, + { url = "https://files.pythonhosted.org/packages/86/ad/6efae459c56c2fbc404da154e13e3a6039129f3c942b0152624f1c621f05/matplotlib-3.10.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07124afcf7a6504eafcb8ce94091c5898bbdd351519a1beb5c45f7a38c67e77f", size = 8131348 }, + { url = "https://files.pythonhosted.org/packages/a6/5a/a4284d2958dee4116359cc05d7e19c057e64ece1b4ac986ab0f2f4d52d5a/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c17398b709a6cce3d9fdb1595c33e356d91c098cd9486cb2cc21ea2ea418e715", size = 9533949 }, + { url = "https://files.pythonhosted.org/packages/de/ff/f3781b5057fa3786623ad8976fc9f7b0d02b2f28534751fd5a44240de4cf/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7146d64f561498764561e9cd0ed64fcf582e570fc519e6f521e2d0cfd43365e1", size = 9804247 }, + { url = "https://files.pythonhosted.org/packages/47/5a/993a59facb8444efb0e197bf55f545ee449902dcee86a4dfc580c3b61314/matplotlib-3.10.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90ad854c0a435da3104c01e2c6f0028d7e719b690998a2333d7218db80950722", size = 9595497 }, + { url = "https://files.pythonhosted.org/packages/0d/a5/77c95aaa9bb32c345cbb49626ad8eb15550cba2e6d4c88081a6c2ac7b08d/matplotlib-3.10.7-cp314-cp314-win_amd64.whl", hash = "sha256:4645fc5d9d20ffa3a39361fcdbcec731382763b623b72627806bf251b6388866", size = 8252732 }, + { url = "https://files.pythonhosted.org/packages/74/04/45d269b4268d222390d7817dae77b159651909669a34ee9fdee336db5883/matplotlib-3.10.7-cp314-cp314-win_arm64.whl", hash = "sha256:9257be2f2a03415f9105c486d304a321168e61ad450f6153d77c69504ad764bb", size = 8124240 }, + { url = "https://files.pythonhosted.org/packages/4b/c7/ca01c607bb827158b439208c153d6f14ddb9fb640768f06f7ca3488ae67b/matplotlib-3.10.7-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1e4bbad66c177a8fdfa53972e5ef8be72a5f27e6a607cec0d8579abd0f3102b1", size = 8316938 }, + { url = "https://files.pythonhosted.org/packages/84/d2/5539e66e9f56d2fdec94bb8436f5e449683b4e199bcc897c44fbe3c99e28/matplotlib-3.10.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d8eb7194b084b12feb19142262165832fc6ee879b945491d1c3d4660748020c4", size = 8178245 }, + { url = "https://files.pythonhosted.org/packages/77/b5/e6ca22901fd3e4fe433a82e583436dd872f6c966fca7e63cf806b40356f8/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d41379b05528091f00e1728004f9a8d7191260f3862178b88e8fd770206318", size = 9541411 }, + { url = "https://files.pythonhosted.org/packages/9e/99/a4524db57cad8fee54b7237239a8f8360bfcfa3170d37c9e71c090c0f409/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a74f79fafb2e177f240579bc83f0b60f82cc47d2f1d260f422a0627207008ca", size = 9803664 }, + { url = "https://files.pythonhosted.org/packages/e6/a5/85e2edf76ea0ad4288d174926d9454ea85f3ce5390cc4e6fab196cbf250b/matplotlib-3.10.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:702590829c30aada1e8cef0568ddbffa77ca747b4d6e36c6d173f66e301f89cc", size = 9594066 }, + { url = "https://files.pythonhosted.org/packages/39/69/9684368a314f6d83fe5c5ad2a4121a3a8e03723d2e5c8ea17b66c1bad0e7/matplotlib-3.10.7-cp314-cp314t-win_amd64.whl", hash = "sha256:f79d5de970fc90cd5591f60053aecfce1fcd736e0303d9f0bf86be649fa68fb8", size = 8342832 }, + { url = "https://files.pythonhosted.org/packages/04/5f/e22e08da14bc1a0894184640d47819d2338b792732e20d292bf86e5ab785/matplotlib-3.10.7-cp314-cp314t-win_arm64.whl", hash = "sha256:cb783436e47fcf82064baca52ce748af71725d0352e1d31564cbe9c95df92b9c", size = 8172585 }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, +] + +[[package]] +name = "mistune" +version = "3.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/02/a7fb8b21d4d55ac93cdcde9d3638da5dd0ebdd3a4fed76c7725e10b81cbe/mistune-3.1.4.tar.gz", hash = "sha256:b5a7f801d389f724ec702840c11d8fc48f2b33519102fc7ee739e8177b672164", size = 94588 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/f0/8282d9641415e9e33df173516226b404d367a0fc55e1a60424a152913abc/mistune-3.1.4-py3-none-any.whl", hash = "sha256:93691da911e5d9d2e23bc54472892aff676df27a75274962ff9edc210364266d", size = 53481 }, +] + +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434 }, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525 }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454 }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195 }, +] + +[[package]] +name = "notebook" +version = "7.4.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/09/f6f64ba156842ef68d3ea763fa171a2f7e7224f200a15dd4af5b83c34756/notebook-7.4.7.tar.gz", hash = "sha256:3f0a04027dfcee8a876de48fba13ab77ec8c12f72f848a222ed7f5081b9e342a", size = 13937702 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/d7/06d13087e20388926e7423d2489e728d2e59f2453039cdb0574a7c070e76/notebook-7.4.7-py3-none-any.whl", hash = "sha256:362b7c95527f7dd3c4c84d410b782872fd9c734fb2524c11dd92758527b6eda6", size = 14342894 }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307 }, +] + +[[package]] +name = "numpy" +version = "2.3.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/19/95b3d357407220ed24c139018d2518fab0a61a948e68286a25f1a4d049ff/numpy-2.3.3.tar.gz", hash = "sha256:ddc7c39727ba62b80dfdbedf400d1c10ddfa8eefbd7ec8dcb118be8b56d31029", size = 20576648 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/b9/984c2b1ee61a8b803bf63582b4ac4242cf76e2dbd663efeafcb620cc0ccb/numpy-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f5415fb78995644253370985342cd03572ef8620b934da27d77377a2285955bf", size = 20949588 }, + { url = "https://files.pythonhosted.org/packages/a6/e4/07970e3bed0b1384d22af1e9912527ecbeb47d3b26e9b6a3bced068b3bea/numpy-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d00de139a3324e26ed5b95870ce63be7ec7352171bc69a4cf1f157a48e3eb6b7", size = 14177802 }, + { url = "https://files.pythonhosted.org/packages/35/c7/477a83887f9de61f1203bad89cf208b7c19cc9fef0cebef65d5a1a0619f2/numpy-2.3.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:9dc13c6a5829610cc07422bc74d3ac083bd8323f14e2827d992f9e52e22cd6a6", size = 5106537 }, + { url = "https://files.pythonhosted.org/packages/52/47/93b953bd5866a6f6986344d045a207d3f1cfbad99db29f534ea9cee5108c/numpy-2.3.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d79715d95f1894771eb4e60fb23f065663b2298f7d22945d66877aadf33d00c7", size = 6640743 }, + { url = "https://files.pythonhosted.org/packages/23/83/377f84aaeb800b64c0ef4de58b08769e782edcefa4fea712910b6f0afd3c/numpy-2.3.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:952cfd0748514ea7c3afc729a0fc639e61655ce4c55ab9acfab14bda4f402b4c", size = 14278881 }, + { url = "https://files.pythonhosted.org/packages/9a/a5/bf3db6e66c4b160d6ea10b534c381a1955dfab34cb1017ea93aa33c70ed3/numpy-2.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5b83648633d46f77039c29078751f80da65aa64d5622a3cd62aaef9d835b6c93", size = 16636301 }, + { url = "https://files.pythonhosted.org/packages/a2/59/1287924242eb4fa3f9b3a2c30400f2e17eb2707020d1c5e3086fe7330717/numpy-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b001bae8cea1c7dfdb2ae2b017ed0a6f2102d7a70059df1e338e307a4c78a8ae", size = 16053645 }, + { url = "https://files.pythonhosted.org/packages/e6/93/b3d47ed882027c35e94ac2320c37e452a549f582a5e801f2d34b56973c97/numpy-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8e9aced64054739037d42fb84c54dd38b81ee238816c948c8f3ed134665dcd86", size = 18578179 }, + { url = "https://files.pythonhosted.org/packages/20/d9/487a2bccbf7cc9d4bfc5f0f197761a5ef27ba870f1e3bbb9afc4bbe3fcc2/numpy-2.3.3-cp313-cp313-win32.whl", hash = "sha256:9591e1221db3f37751e6442850429b3aabf7026d3b05542d102944ca7f00c8a8", size = 6312250 }, + { url = "https://files.pythonhosted.org/packages/1b/b5/263ebbbbcede85028f30047eab3d58028d7ebe389d6493fc95ae66c636ab/numpy-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f0dadeb302887f07431910f67a14d57209ed91130be0adea2f9793f1a4f817cf", size = 12783269 }, + { url = "https://files.pythonhosted.org/packages/fa/75/67b8ca554bbeaaeb3fac2e8bce46967a5a06544c9108ec0cf5cece559b6c/numpy-2.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:3c7cf302ac6e0b76a64c4aecf1a09e51abd9b01fc7feee80f6c43e3ab1b1dbc5", size = 10195314 }, + { url = "https://files.pythonhosted.org/packages/11/d0/0d1ddec56b162042ddfafeeb293bac672de9b0cfd688383590090963720a/numpy-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:eda59e44957d272846bb407aad19f89dc6f58fecf3504bd144f4c5cf81a7eacc", size = 21048025 }, + { url = "https://files.pythonhosted.org/packages/36/9e/1996ca6b6d00415b6acbdd3c42f7f03ea256e2c3f158f80bd7436a8a19f3/numpy-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:823d04112bc85ef5c4fda73ba24e6096c8f869931405a80aa8b0e604510a26bc", size = 14301053 }, + { url = "https://files.pythonhosted.org/packages/05/24/43da09aa764c68694b76e84b3d3f0c44cb7c18cdc1ba80e48b0ac1d2cd39/numpy-2.3.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:40051003e03db4041aa325da2a0971ba41cf65714e65d296397cc0e32de6018b", size = 5229444 }, + { url = "https://files.pythonhosted.org/packages/bc/14/50ffb0f22f7218ef8af28dd089f79f68289a7a05a208db9a2c5dcbe123c1/numpy-2.3.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:6ee9086235dd6ab7ae75aba5662f582a81ced49f0f1c6de4260a78d8f2d91a19", size = 6738039 }, + { url = "https://files.pythonhosted.org/packages/55/52/af46ac0795e09657d45a7f4db961917314377edecf66db0e39fa7ab5c3d3/numpy-2.3.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94fcaa68757c3e2e668ddadeaa86ab05499a70725811e582b6a9858dd472fb30", size = 14352314 }, + { url = "https://files.pythonhosted.org/packages/a7/b1/dc226b4c90eb9f07a3fff95c2f0db3268e2e54e5cce97c4ac91518aee71b/numpy-2.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da1a74b90e7483d6ce5244053399a614b1d6b7bc30a60d2f570e5071f8959d3e", size = 16701722 }, + { url = "https://files.pythonhosted.org/packages/9d/9d/9d8d358f2eb5eced14dba99f110d83b5cd9a4460895230f3b396ad19a323/numpy-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2990adf06d1ecee3b3dcbb4977dfab6e9f09807598d647f04d385d29e7a3c3d3", size = 16132755 }, + { url = "https://files.pythonhosted.org/packages/b6/27/b3922660c45513f9377b3fb42240bec63f203c71416093476ec9aa0719dc/numpy-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ed635ff692483b8e3f0fcaa8e7eb8a75ee71aa6d975388224f70821421800cea", size = 18651560 }, + { url = "https://files.pythonhosted.org/packages/5b/8e/3ab61a730bdbbc201bb245a71102aa609f0008b9ed15255500a99cd7f780/numpy-2.3.3-cp313-cp313t-win32.whl", hash = "sha256:a333b4ed33d8dc2b373cc955ca57babc00cd6f9009991d9edc5ddbc1bac36bcd", size = 6442776 }, + { url = "https://files.pythonhosted.org/packages/1c/3a/e22b766b11f6030dc2decdeff5c2fb1610768055603f9f3be88b6d192fb2/numpy-2.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:4384a169c4d8f97195980815d6fcad04933a7e1ab3b530921c3fef7a1c63426d", size = 12927281 }, + { url = "https://files.pythonhosted.org/packages/7b/42/c2e2bc48c5e9b2a83423f99733950fbefd86f165b468a3d85d52b30bf782/numpy-2.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:75370986cc0bc66f4ce5110ad35aae6d182cc4ce6433c40ad151f53690130bf1", size = 10265275 }, + { url = "https://files.pythonhosted.org/packages/6b/01/342ad585ad82419b99bcf7cebe99e61da6bedb89e213c5fd71acc467faee/numpy-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cd052f1fa6a78dee696b58a914b7229ecfa41f0a6d96dc663c1220a55e137593", size = 20951527 }, + { url = "https://files.pythonhosted.org/packages/ef/d8/204e0d73fc1b7a9ee80ab1fe1983dd33a4d64a4e30a05364b0208e9a241a/numpy-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:414a97499480067d305fcac9716c29cf4d0d76db6ebf0bf3cbce666677f12652", size = 14186159 }, + { url = "https://files.pythonhosted.org/packages/22/af/f11c916d08f3a18fb8ba81ab72b5b74a6e42ead4c2846d270eb19845bf74/numpy-2.3.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:50a5fe69f135f88a2be9b6ca0481a68a136f6febe1916e4920e12f1a34e708a7", size = 5114624 }, + { url = "https://files.pythonhosted.org/packages/fb/11/0ed919c8381ac9d2ffacd63fd1f0c34d27e99cab650f0eb6f110e6ae4858/numpy-2.3.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:b912f2ed2b67a129e6a601e9d93d4fa37bef67e54cac442a2f588a54afe5c67a", size = 6642627 }, + { url = "https://files.pythonhosted.org/packages/ee/83/deb5f77cb0f7ba6cb52b91ed388b47f8f3c2e9930d4665c600408d9b90b9/numpy-2.3.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9e318ee0596d76d4cb3d78535dc005fa60e5ea348cd131a51e99d0bdbe0b54fe", size = 14296926 }, + { url = "https://files.pythonhosted.org/packages/77/cc/70e59dcb84f2b005d4f306310ff0a892518cc0c8000a33d0e6faf7ca8d80/numpy-2.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce020080e4a52426202bdb6f7691c65bb55e49f261f31a8f506c9f6bc7450421", size = 16638958 }, + { url = "https://files.pythonhosted.org/packages/b6/5a/b2ab6c18b4257e099587d5b7f903317bd7115333ad8d4ec4874278eafa61/numpy-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e6687dc183aa55dae4a705b35f9c0f8cb178bcaa2f029b241ac5356221d5c021", size = 16071920 }, + { url = "https://files.pythonhosted.org/packages/b8/f1/8b3fdc44324a259298520dd82147ff648979bed085feeacc1250ef1656c0/numpy-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d8f3b1080782469fdc1718c4ed1d22549b5fb12af0d57d35e992158a772a37cf", size = 18577076 }, + { url = "https://files.pythonhosted.org/packages/f0/a1/b87a284fb15a42e9274e7fcea0dad259d12ddbf07c1595b26883151ca3b4/numpy-2.3.3-cp314-cp314-win32.whl", hash = "sha256:cb248499b0bc3be66ebd6578b83e5acacf1d6cb2a77f2248ce0e40fbec5a76d0", size = 6366952 }, + { url = "https://files.pythonhosted.org/packages/70/5f/1816f4d08f3b8f66576d8433a66f8fa35a5acfb3bbd0bf6c31183b003f3d/numpy-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:691808c2b26b0f002a032c73255d0bd89751425f379f7bcd22d140db593a96e8", size = 12919322 }, + { url = "https://files.pythonhosted.org/packages/8c/de/072420342e46a8ea41c324a555fa90fcc11637583fb8df722936aed1736d/numpy-2.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:9ad12e976ca7b10f1774b03615a2a4bab8addce37ecc77394d8e986927dc0dfe", size = 10478630 }, + { url = "https://files.pythonhosted.org/packages/d5/df/ee2f1c0a9de7347f14da5dd3cd3c3b034d1b8607ccb6883d7dd5c035d631/numpy-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9cc48e09feb11e1db00b320e9d30a4151f7369afb96bd0e48d942d09da3a0d00", size = 21047987 }, + { url = "https://files.pythonhosted.org/packages/d6/92/9453bdc5a4e9e69cf4358463f25e8260e2ffc126d52e10038b9077815989/numpy-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:901bf6123879b7f251d3631967fd574690734236075082078e0571977c6a8e6a", size = 14301076 }, + { url = "https://files.pythonhosted.org/packages/13/77/1447b9eb500f028bb44253105bd67534af60499588a5149a94f18f2ca917/numpy-2.3.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:7f025652034199c301049296b59fa7d52c7e625017cae4c75d8662e377bf487d", size = 5229491 }, + { url = "https://files.pythonhosted.org/packages/3d/f9/d72221b6ca205f9736cb4b2ce3b002f6e45cd67cd6a6d1c8af11a2f0b649/numpy-2.3.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:533ca5f6d325c80b6007d4d7fb1984c303553534191024ec6a524a4c92a5935a", size = 6737913 }, + { url = "https://files.pythonhosted.org/packages/3c/5f/d12834711962ad9c46af72f79bb31e73e416ee49d17f4c797f72c96b6ca5/numpy-2.3.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0edd58682a399824633b66885d699d7de982800053acf20be1eaa46d92009c54", size = 14352811 }, + { url = "https://files.pythonhosted.org/packages/a1/0d/fdbec6629d97fd1bebed56cd742884e4eead593611bbe1abc3eb40d304b2/numpy-2.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:367ad5d8fbec5d9296d18478804a530f1191e24ab4d75ab408346ae88045d25e", size = 16702689 }, + { url = "https://files.pythonhosted.org/packages/9b/09/0a35196dc5575adde1eb97ddfbc3e1687a814f905377621d18ca9bc2b7dd/numpy-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8f6ac61a217437946a1fa48d24c47c91a0c4f725237871117dea264982128097", size = 16133855 }, + { url = "https://files.pythonhosted.org/packages/7a/ca/c9de3ea397d576f1b6753eaa906d4cdef1bf97589a6d9825a349b4729cc2/numpy-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:179a42101b845a816d464b6fe9a845dfaf308fdfc7925387195570789bb2c970", size = 18652520 }, + { url = "https://files.pythonhosted.org/packages/fd/c2/e5ed830e08cd0196351db55db82f65bc0ab05da6ef2b72a836dcf1936d2f/numpy-2.3.3-cp314-cp314t-win32.whl", hash = "sha256:1250c5d3d2562ec4174bce2e3a1523041595f9b651065e4a4473f5f48a6bc8a5", size = 6515371 }, + { url = "https://files.pythonhosted.org/packages/47/c7/b0f6b5b67f6788a0725f744496badbb604d226bf233ba716683ebb47b570/numpy-2.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b37a0b2e5935409daebe82c1e42274d30d9dd355852529eab91dab8dcca7419f", size = 13112576 }, + { url = "https://files.pythonhosted.org/packages/06/b9/33bba5ff6fb679aa0b1f8a07e853f002a6b04b9394db3069a1270a7784ca/numpy-2.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:78c9f6560dc7e6b3990e32df7ea1a50bbd0e2a111e05209963f5ddcab7073b0b", size = 10545953 }, +] + +[[package]] +name = "optinonlin" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "ipykernel" }, + { name = "jupyter" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "scipy" }, +] + +[package.metadata] +requires-dist = [ + { name = "ipykernel", specifier = ">=6.30.1" }, + { name = "jupyter", specifier = ">=1.1.1" }, + { name = "matplotlib", specifier = ">=3.10.7" }, + { name = "numpy", specifier = ">=2.3.3" }, + { name = "scipy", specifier = ">=1.16.2" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469 }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663 }, +] + +[[package]] +name = "parso" +version = "0.8.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668 }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 }, +] + +[[package]] +name = "pillow" +version = "11.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/93/0952f2ed8db3a5a4c7a11f91965d6184ebc8cd7cbb7941a260d5f018cd2d/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1c627742b539bba4309df89171356fcb3cc5a9178355b2727d1b74a6cf155fbd", size = 2128328 }, + { url = "https://files.pythonhosted.org/packages/4b/e8/100c3d114b1a0bf4042f27e0f87d2f25e857e838034e98ca98fe7b8c0a9c/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:30b7c02f3899d10f13d7a48163c8969e4e653f8b43416d23d13d1bbfdc93b9f8", size = 2170652 }, + { url = "https://files.pythonhosted.org/packages/aa/86/3f758a28a6e381758545f7cdb4942e1cb79abd271bea932998fc0db93cb6/pillow-11.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f", size = 2227443 }, + { url = "https://files.pythonhosted.org/packages/01/f4/91d5b3ffa718df2f53b0dc109877993e511f4fd055d7e9508682e8aba092/pillow-11.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c", size = 5278474 }, + { url = "https://files.pythonhosted.org/packages/f9/0e/37d7d3eca6c879fbd9dba21268427dffda1ab00d4eb05b32923d4fbe3b12/pillow-11.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd", size = 4686038 }, + { url = "https://files.pythonhosted.org/packages/ff/b0/3426e5c7f6565e752d81221af9d3676fdbb4f352317ceafd42899aaf5d8a/pillow-11.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e", size = 5864407 }, + { url = "https://files.pythonhosted.org/packages/fc/c1/c6c423134229f2a221ee53f838d4be9d82bab86f7e2f8e75e47b6bf6cd77/pillow-11.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1", size = 7639094 }, + { url = "https://files.pythonhosted.org/packages/ba/c9/09e6746630fe6372c67c648ff9deae52a2bc20897d51fa293571977ceb5d/pillow-11.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805", size = 5973503 }, + { url = "https://files.pythonhosted.org/packages/d5/1c/a2a29649c0b1983d3ef57ee87a66487fdeb45132df66ab30dd37f7dbe162/pillow-11.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8", size = 6642574 }, + { url = "https://files.pythonhosted.org/packages/36/de/d5cc31cc4b055b6c6fd990e3e7f0f8aaf36229a2698501bcb0cdf67c7146/pillow-11.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2", size = 6084060 }, + { url = "https://files.pythonhosted.org/packages/d5/ea/502d938cbaeec836ac28a9b730193716f0114c41325db428e6b280513f09/pillow-11.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:45dfc51ac5975b938e9809451c51734124e73b04d0f0ac621649821a63852e7b", size = 6721407 }, + { url = "https://files.pythonhosted.org/packages/45/9c/9c5e2a73f125f6cbc59cc7087c8f2d649a7ae453f83bd0362ff7c9e2aee2/pillow-11.3.0-cp313-cp313-win32.whl", hash = "sha256:a4d336baed65d50d37b88ca5b60c0fa9d81e3a87d4a7930d3880d1624d5b31f3", size = 6273841 }, + { url = "https://files.pythonhosted.org/packages/23/85/397c73524e0cd212067e0c969aa245b01d50183439550d24d9f55781b776/pillow-11.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bce5c4fd0921f99d2e858dc4d4d64193407e1b99478bc5cacecba2311abde51", size = 6978450 }, + { url = "https://files.pythonhosted.org/packages/17/d2/622f4547f69cd173955194b78e4d19ca4935a1b0f03a302d655c9f6aae65/pillow-11.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580", size = 2423055 }, + { url = "https://files.pythonhosted.org/packages/dd/80/a8a2ac21dda2e82480852978416cfacd439a4b490a501a288ecf4fe2532d/pillow-11.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e", size = 5281110 }, + { url = "https://files.pythonhosted.org/packages/44/d6/b79754ca790f315918732e18f82a8146d33bcd7f4494380457ea89eb883d/pillow-11.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d", size = 4689547 }, + { url = "https://files.pythonhosted.org/packages/49/20/716b8717d331150cb00f7fdd78169c01e8e0c219732a78b0e59b6bdb2fd6/pillow-11.3.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced", size = 5901554 }, + { url = "https://files.pythonhosted.org/packages/74/cf/a9f3a2514a65bb071075063a96f0a5cf949c2f2fce683c15ccc83b1c1cab/pillow-11.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c", size = 7669132 }, + { url = "https://files.pythonhosted.org/packages/98/3c/da78805cbdbee9cb43efe8261dd7cc0b4b93f2ac79b676c03159e9db2187/pillow-11.3.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8", size = 6005001 }, + { url = "https://files.pythonhosted.org/packages/6c/fa/ce044b91faecf30e635321351bba32bab5a7e034c60187fe9698191aef4f/pillow-11.3.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59", size = 6668814 }, + { url = "https://files.pythonhosted.org/packages/7b/51/90f9291406d09bf93686434f9183aba27b831c10c87746ff49f127ee80cb/pillow-11.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe", size = 6113124 }, + { url = "https://files.pythonhosted.org/packages/cd/5a/6fec59b1dfb619234f7636d4157d11fb4e196caeee220232a8d2ec48488d/pillow-11.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83e1b0161c9d148125083a35c1c5a89db5b7054834fd4387499e06552035236c", size = 6747186 }, + { url = "https://files.pythonhosted.org/packages/49/6b/00187a044f98255225f172de653941e61da37104a9ea60e4f6887717e2b5/pillow-11.3.0-cp313-cp313t-win32.whl", hash = "sha256:2a3117c06b8fb646639dce83694f2f9eac405472713fcb1ae887469c0d4f6788", size = 6277546 }, + { url = "https://files.pythonhosted.org/packages/e8/5c/6caaba7e261c0d75bab23be79f1d06b5ad2a2ae49f028ccec801b0e853d6/pillow-11.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:857844335c95bea93fb39e0fa2726b4d9d758850b34075a7e3ff4f4fa3aa3b31", size = 6985102 }, + { url = "https://files.pythonhosted.org/packages/f3/7e/b623008460c09a0cb38263c93b828c666493caee2eb34ff67f778b87e58c/pillow-11.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e", size = 2424803 }, + { url = "https://files.pythonhosted.org/packages/73/f4/04905af42837292ed86cb1b1dabe03dce1edc008ef14c473c5c7e1443c5d/pillow-11.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d9da3df5f9ea2a89b81bb6087177fb1f4d1c7146d583a3fe5c672c0d94e55e12", size = 5278520 }, + { url = "https://files.pythonhosted.org/packages/41/b0/33d79e377a336247df6348a54e6d2a2b85d644ca202555e3faa0cf811ecc/pillow-11.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0b275ff9b04df7b640c59ec5a3cb113eefd3795a8df80bac69646ef699c6981a", size = 4686116 }, + { url = "https://files.pythonhosted.org/packages/49/2d/ed8bc0ab219ae8768f529597d9509d184fe8a6c4741a6864fea334d25f3f/pillow-11.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0743841cabd3dba6a83f38a92672cccbd69af56e3e91777b0ee7f4dba4385632", size = 5864597 }, + { url = "https://files.pythonhosted.org/packages/b5/3d/b932bb4225c80b58dfadaca9d42d08d0b7064d2d1791b6a237f87f661834/pillow-11.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2465a69cf967b8b49ee1b96d76718cd98c4e925414ead59fdf75cf0fd07df673", size = 7638246 }, + { url = "https://files.pythonhosted.org/packages/09/b5/0487044b7c096f1b48f0d7ad416472c02e0e4bf6919541b111efd3cae690/pillow-11.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41742638139424703b4d01665b807c6468e23e699e8e90cffefe291c5832b027", size = 5973336 }, + { url = "https://files.pythonhosted.org/packages/a8/2d/524f9318f6cbfcc79fbc004801ea6b607ec3f843977652fdee4857a7568b/pillow-11.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93efb0b4de7e340d99057415c749175e24c8864302369e05914682ba642e5d77", size = 6642699 }, + { url = "https://files.pythonhosted.org/packages/6f/d2/a9a4f280c6aefedce1e8f615baaa5474e0701d86dd6f1dede66726462bbd/pillow-11.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7966e38dcd0fa11ca390aed7c6f20454443581d758242023cf36fcb319b1a874", size = 6083789 }, + { url = "https://files.pythonhosted.org/packages/fe/54/86b0cd9dbb683a9d5e960b66c7379e821a19be4ac5810e2e5a715c09a0c0/pillow-11.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:98a9afa7b9007c67ed84c57c9e0ad86a6000da96eaa638e4f8abe5b65ff83f0a", size = 6720386 }, + { url = "https://files.pythonhosted.org/packages/e7/95/88efcaf384c3588e24259c4203b909cbe3e3c2d887af9e938c2022c9dd48/pillow-11.3.0-cp314-cp314-win32.whl", hash = "sha256:02a723e6bf909e7cea0dac1b0e0310be9d7650cd66222a5f1c571455c0a45214", size = 6370911 }, + { url = "https://files.pythonhosted.org/packages/2e/cc/934e5820850ec5eb107e7b1a72dd278140731c669f396110ebc326f2a503/pillow-11.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:a418486160228f64dd9e9efcd132679b7a02a5f22c982c78b6fc7dab3fefb635", size = 7117383 }, + { url = "https://files.pythonhosted.org/packages/d6/e9/9c0a616a71da2a5d163aa37405e8aced9a906d574b4a214bede134e731bc/pillow-11.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:155658efb5e044669c08896c0c44231c5e9abcaadbc5cd3648df2f7c0b96b9a6", size = 2511385 }, + { url = "https://files.pythonhosted.org/packages/1a/33/c88376898aff369658b225262cd4f2659b13e8178e7534df9e6e1fa289f6/pillow-11.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:59a03cdf019efbfeeed910bf79c7c93255c3d54bc45898ac2a4140071b02b4ae", size = 5281129 }, + { url = "https://files.pythonhosted.org/packages/1f/70/d376247fb36f1844b42910911c83a02d5544ebd2a8bad9efcc0f707ea774/pillow-11.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f8a5827f84d973d8636e9dc5764af4f0cf2318d26744b3d902931701b0d46653", size = 4689580 }, + { url = "https://files.pythonhosted.org/packages/eb/1c/537e930496149fbac69efd2fc4329035bbe2e5475b4165439e3be9cb183b/pillow-11.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ee92f2fd10f4adc4b43d07ec5e779932b4eb3dbfbc34790ada5a6669bc095aa6", size = 5902860 }, + { url = "https://files.pythonhosted.org/packages/bd/57/80f53264954dcefeebcf9dae6e3eb1daea1b488f0be8b8fef12f79a3eb10/pillow-11.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c96d333dcf42d01f47b37e0979b6bd73ec91eae18614864622d9b87bbd5bbf36", size = 7670694 }, + { url = "https://files.pythonhosted.org/packages/70/ff/4727d3b71a8578b4587d9c276e90efad2d6fe0335fd76742a6da08132e8c/pillow-11.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c96f993ab8c98460cd0c001447bff6194403e8b1d7e149ade5f00594918128b", size = 6005888 }, + { url = "https://files.pythonhosted.org/packages/05/ae/716592277934f85d3be51d7256f3636672d7b1abfafdc42cf3f8cbd4b4c8/pillow-11.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:41342b64afeba938edb034d122b2dda5db2139b9a4af999729ba8818e0056477", size = 6670330 }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7fe6cddcc8827b01b1a9766f5fdeb7418680744f9082035bdbabecf1d57f/pillow-11.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:068d9c39a2d1b358eb9f245ce7ab1b5c3246c7c8c7d9ba58cfa5b43146c06e50", size = 6114089 }, + { url = "https://files.pythonhosted.org/packages/8b/f5/06bfaa444c8e80f1a8e4bff98da9c83b37b5be3b1deaa43d27a0db37ef84/pillow-11.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a1bc6ba083b145187f648b667e05a2534ecc4b9f2784c2cbe3089e44868f2b9b", size = 6748206 }, + { url = "https://files.pythonhosted.org/packages/f0/77/bc6f92a3e8e6e46c0ca78abfffec0037845800ea38c73483760362804c41/pillow-11.3.0-cp314-cp314t-win32.whl", hash = "sha256:118ca10c0d60b06d006be10a501fd6bbdfef559251ed31b794668ed569c87e12", size = 6377370 }, + { url = "https://files.pythonhosted.org/packages/4a/82/3a721f7d69dca802befb8af08b7c79ebcab461007ce1c18bd91a5d5896f9/pillow-11.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8924748b688aa210d79883357d102cd64690e56b923a186f35a82cbc10f997db", size = 7121500 }, + { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835 }, +] + +[[package]] +name = "platformdirs" +version = "4.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/23/e8/21db9c9987b0e728855bd57bff6984f67952bea55d6f75e055c46b5383e8/platformdirs-4.4.0.tar.gz", hash = "sha256:ca753cf4d81dc309bc67b0ea38fd15dc97bc30ce419a7f58d13eb3bf14c4febf", size = 21634 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/4b/2028861e724d3bd36227adfa20d3fd24c3fc6d52032f4a93c133be5d17ce/platformdirs-4.4.0-py3-none-any.whl", hash = "sha256:abd01743f24e5287cd7a5db3752faf1a2d65353f38ec26d98e25a6db65958c85", size = 18654 }, +] + +[[package]] +name = "prometheus-client" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/23/53/3edb5d68ecf6b38fcbcc1ad28391117d2a322d9a1a3eff04bfdb184d8c3b/prometheus_client-0.23.1.tar.gz", hash = "sha256:6ae8f9081eaaaf153a2e959d2e6c4f4fb57b12ef76c8c7980202f1e57b48b2ce", size = 80481 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/db/14bafcb4af2139e046d03fd00dea7873e48eafe18b7d2797e73d6681f210/prometheus_client-0.23.1-py3-none-any.whl", hash = "sha256:dd1913e6e76b59cfe44e7a4b83e01afc9873c1bdfd2ed8739f1e76aeca115f99", size = 61145 }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431 }, +] + +[[package]] +name = "psutil" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/31/4723d756b59344b643542936e37a31d1d3204bcdc42a7daa8ee9eb06fb50/psutil-7.1.0.tar.gz", hash = "sha256:655708b3c069387c8b77b072fc429a57d0e214221d01c0a772df7dfedcb3bcd2", size = 497660 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/62/ce4051019ee20ce0ed74432dd73a5bb087a6704284a470bb8adff69a0932/psutil-7.1.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:76168cef4397494250e9f4e73eb3752b146de1dd950040b29186d0cce1d5ca13", size = 245242 }, + { url = "https://files.pythonhosted.org/packages/38/61/f76959fba841bf5b61123fbf4b650886dc4094c6858008b5bf73d9057216/psutil-7.1.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:5d007560c8c372efdff9e4579c2846d71de737e4605f611437255e81efcca2c5", size = 246682 }, + { url = "https://files.pythonhosted.org/packages/88/7a/37c99d2e77ec30d63398ffa6a660450b8a62517cabe44b3e9bae97696e8d/psutil-7.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22e4454970b32472ce7deaa45d045b34d3648ce478e26a04c7e858a0a6e75ff3", size = 287994 }, + { url = "https://files.pythonhosted.org/packages/9d/de/04c8c61232f7244aa0a4b9a9fbd63a89d5aeaf94b2fc9d1d16e2faa5cbb0/psutil-7.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c70e113920d51e89f212dd7be06219a9b88014e63a4cec69b684c327bc474e3", size = 291163 }, + { url = "https://files.pythonhosted.org/packages/f4/58/c4f976234bf6d4737bc8c02a81192f045c307b72cf39c9e5c5a2d78927f6/psutil-7.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7d4a113425c037300de3ac8b331637293da9be9713855c4fc9d2d97436d7259d", size = 293625 }, + { url = "https://files.pythonhosted.org/packages/79/87/157c8e7959ec39ced1b11cc93c730c4fb7f9d408569a6c59dbd92ceb35db/psutil-7.1.0-cp37-abi3-win32.whl", hash = "sha256:09ad740870c8d219ed8daae0ad3b726d3bf9a028a198e7f3080f6a1888b99bca", size = 244812 }, + { url = "https://files.pythonhosted.org/packages/bf/e9/b44c4f697276a7a95b8e94d0e320a7bf7f3318521b23de69035540b39838/psutil-7.1.0-cp37-abi3-win_amd64.whl", hash = "sha256:57f5e987c36d3146c0dd2528cd42151cf96cd359b9d67cfff836995cc5df9a3d", size = 247965 }, + { url = "https://files.pythonhosted.org/packages/26/65/1070a6e3c036f39142c2820c4b52e9243246fcfc3f96239ac84472ba361e/psutil-7.1.0-cp37-abi3-win_arm64.whl", hash = "sha256:6937cb68133e7c97b6cc9649a570c9a18ba0efebed46d8c5dae4c07fa1b67a07", size = 244971 }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 }, +] + +[[package]] +name = "pycparser" +version = "2.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140 }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217 }, +] + +[[package]] +name = "pyparsing" +version = "3.2.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/181488fc2b9d093e3972d2a472855aae8a03f000592dbfce716a512b3359/pyparsing-3.2.5.tar.gz", hash = "sha256:2df8d5b7b2802ef88e8d016a2eb9c7aeaa923529cd251ed0fe4608275d4105b6", size = 1099274 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890 }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, +] + +[[package]] +name = "python-json-logger" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/29/bf/eca6a3d43db1dae7070f70e160ab20b807627ba953663ba07928cdd3dc58/python_json_logger-4.0.0.tar.gz", hash = "sha256:f58e68eb46e1faed27e0f574a55a0455eecd7b8a5b88b85a784519ba3cff047f", size = 17683 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548 }, +] + +[[package]] +name = "pywin32" +version = "311" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700 }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700 }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318 }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714 }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800 }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540 }, +] + +[[package]] +name = "pywinpty" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/bb/a7cc2967c5c4eceb6cc49cfe39447d4bfc56e6c865e7c2249b6eb978935f/pywinpty-3.0.2.tar.gz", hash = "sha256:1505cc4cb248af42cb6285a65c9c2086ee9e7e574078ee60933d5d7fa86fb004", size = 30669 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/19/b757fe28008236a4a713e813283721b8a40aa60cd7d3f83549f2e25a3155/pywinpty-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:18f78b81e4cfee6aabe7ea8688441d30247b73e52cd9657138015c5f4ee13a51", size = 2050057 }, + { url = "https://files.pythonhosted.org/packages/cb/44/cbae12ecf6f4fa4129c36871fd09c6bef4f98d5f625ecefb5e2449765508/pywinpty-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:663383ecfab7fc382cc97ea5c4f7f0bb32c2f889259855df6ea34e5df42d305b", size = 2049874 }, + { url = "https://files.pythonhosted.org/packages/ca/15/f12c6055e2d7a617d4d5820e8ac4ceaff849da4cb124640ef5116a230771/pywinpty-3.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:28297cecc37bee9f24d8889e47231972d6e9e84f7b668909de54f36ca785029a", size = 2050386 }, + { url = "https://files.pythonhosted.org/packages/de/24/c6907c5bb06043df98ad6a0a0ff5db2e0affcecbc3b15c42404393a3f72a/pywinpty-3.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:34b55ae9a1b671fe3eae071d86618110538e8eaad18fcb1531c0830b91a82767", size = 2049834 }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669 }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252 }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081 }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159 }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626 }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613 }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115 }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427 }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090 }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246 }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814 }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809 }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454 }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355 }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175 }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228 }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194 }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429 }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912 }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108 }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641 }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901 }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132 }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261 }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272 }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923 }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062 }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341 }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279 }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645 }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574 }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995 }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070 }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121 }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550 }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184 }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480 }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993 }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436 }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301 }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197 }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275 }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469 }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961 }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282 }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468 }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394 }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964 }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029 }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541 }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197 }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175 }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427 }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929 }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193 }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388 }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316 }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472 }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401 }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170 }, +] + +[[package]] +name = "referencing" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775 }, +] + +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738 }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490 }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242 }, +] + +[[package]] +name = "rfc3987-syntax" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046 }, +] + +[[package]] +name = "rpds-py" +version = "0.27.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e9/dd/2c0cbe774744272b0ae725f44032c77bdcab6e8bcf544bffa3b6e70c8dba/rpds_py-0.27.1.tar.gz", hash = "sha256:26a1c73171d10b7acccbded82bf6a586ab8203601e565badc74bbbf8bc5a10f8", size = 27479 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/77/610aeee8d41e39080c7e14afa5387138e3c9fa9756ab893d09d99e7d8e98/rpds_py-0.27.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e4b9fcfbc021633863a37e92571d6f91851fa656f0180246e84cbd8b3f6b329b", size = 361741 }, + { url = "https://files.pythonhosted.org/packages/3a/fc/c43765f201c6a1c60be2043cbdb664013def52460a4c7adace89d6682bf4/rpds_py-0.27.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1441811a96eadca93c517d08df75de45e5ffe68aa3089924f963c782c4b898cf", size = 345574 }, + { url = "https://files.pythonhosted.org/packages/20/42/ee2b2ca114294cd9847d0ef9c26d2b0851b2e7e00bf14cc4c0b581df0fc3/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55266dafa22e672f5a4f65019015f90336ed31c6383bd53f5e7826d21a0e0b83", size = 385051 }, + { url = "https://files.pythonhosted.org/packages/fd/e8/1e430fe311e4799e02e2d1af7c765f024e95e17d651612425b226705f910/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d78827d7ac08627ea2c8e02c9e5b41180ea5ea1f747e9db0915e3adf36b62dcf", size = 398395 }, + { url = "https://files.pythonhosted.org/packages/82/95/9dc227d441ff2670651c27a739acb2535ccaf8b351a88d78c088965e5996/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae92443798a40a92dc5f0b01d8a7c93adde0c4dc965310a29ae7c64d72b9fad2", size = 524334 }, + { url = "https://files.pythonhosted.org/packages/87/01/a670c232f401d9ad461d9a332aa4080cd3cb1d1df18213dbd0d2a6a7ab51/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c46c9dd2403b66a2a3b9720ec4b74d4ab49d4fabf9f03dfdce2d42af913fe8d0", size = 407691 }, + { url = "https://files.pythonhosted.org/packages/03/36/0a14aebbaa26fe7fab4780c76f2239e76cc95a0090bdb25e31d95c492fcd/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2efe4eb1d01b7f5f1939f4ef30ecea6c6b3521eec451fb93191bf84b2a522418", size = 386868 }, + { url = "https://files.pythonhosted.org/packages/3b/03/8c897fb8b5347ff6c1cc31239b9611c5bf79d78c984430887a353e1409a1/rpds_py-0.27.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:15d3b4d83582d10c601f481eca29c3f138d44c92187d197aff663a269197c02d", size = 405469 }, + { url = "https://files.pythonhosted.org/packages/da/07/88c60edc2df74850d496d78a1fdcdc7b54360a7f610a4d50008309d41b94/rpds_py-0.27.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4ed2e16abbc982a169d30d1a420274a709949e2cbdef119fe2ec9d870b42f274", size = 422125 }, + { url = "https://files.pythonhosted.org/packages/6b/86/5f4c707603e41b05f191a749984f390dabcbc467cf833769b47bf14ba04f/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a75f305c9b013289121ec0f1181931975df78738cdf650093e6b86d74aa7d8dd", size = 562341 }, + { url = "https://files.pythonhosted.org/packages/b2/92/3c0cb2492094e3cd9baf9e49bbb7befeceb584ea0c1a8b5939dca4da12e5/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:67ce7620704745881a3d4b0ada80ab4d99df390838839921f99e63c474f82cf2", size = 592511 }, + { url = "https://files.pythonhosted.org/packages/10/bb/82e64fbb0047c46a168faa28d0d45a7851cd0582f850b966811d30f67ad8/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d992ac10eb86d9b6f369647b6a3f412fc0075cfd5d799530e84d335e440a002", size = 557736 }, + { url = "https://files.pythonhosted.org/packages/00/95/3c863973d409210da7fb41958172c6b7dbe7fc34e04d3cc1f10bb85e979f/rpds_py-0.27.1-cp313-cp313-win32.whl", hash = "sha256:4f75e4bd8ab8db624e02c8e2fc4063021b58becdbe6df793a8111d9343aec1e3", size = 221462 }, + { url = "https://files.pythonhosted.org/packages/ce/2c/5867b14a81dc217b56d95a9f2a40fdbc56a1ab0181b80132beeecbd4b2d6/rpds_py-0.27.1-cp313-cp313-win_amd64.whl", hash = "sha256:f9025faafc62ed0b75a53e541895ca272815bec18abe2249ff6501c8f2e12b83", size = 232034 }, + { url = "https://files.pythonhosted.org/packages/c7/78/3958f3f018c01923823f1e47f1cc338e398814b92d83cd278364446fac66/rpds_py-0.27.1-cp313-cp313-win_arm64.whl", hash = "sha256:ed10dc32829e7d222b7d3b93136d25a406ba9788f6a7ebf6809092da1f4d279d", size = 222392 }, + { url = "https://files.pythonhosted.org/packages/01/76/1cdf1f91aed5c3a7bf2eba1f1c4e4d6f57832d73003919a20118870ea659/rpds_py-0.27.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:92022bbbad0d4426e616815b16bc4127f83c9a74940e1ccf3cfe0b387aba0228", size = 358355 }, + { url = "https://files.pythonhosted.org/packages/c3/6f/bf142541229374287604caf3bb2a4ae17f0a580798fd72d3b009b532db4e/rpds_py-0.27.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:47162fdab9407ec3f160805ac3e154df042e577dd53341745fc7fb3f625e6d92", size = 342138 }, + { url = "https://files.pythonhosted.org/packages/1a/77/355b1c041d6be40886c44ff5e798b4e2769e497b790f0f7fd1e78d17e9a8/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb89bec23fddc489e5d78b550a7b773557c9ab58b7946154a10a6f7a214a48b2", size = 380247 }, + { url = "https://files.pythonhosted.org/packages/d6/a4/d9cef5c3946ea271ce2243c51481971cd6e34f21925af2783dd17b26e815/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e48af21883ded2b3e9eb48cb7880ad8598b31ab752ff3be6457001d78f416723", size = 390699 }, + { url = "https://files.pythonhosted.org/packages/3a/06/005106a7b8c6c1a7e91b73169e49870f4af5256119d34a361ae5240a0c1d/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6f5b7bd8e219ed50299e58551a410b64daafb5017d54bbe822e003856f06a802", size = 521852 }, + { url = "https://files.pythonhosted.org/packages/e5/3e/50fb1dac0948e17a02eb05c24510a8fe12d5ce8561c6b7b7d1339ab7ab9c/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08f1e20bccf73b08d12d804d6e1c22ca5530e71659e6673bce31a6bb71c1e73f", size = 402582 }, + { url = "https://files.pythonhosted.org/packages/cb/b0/f4e224090dc5b0ec15f31a02d746ab24101dd430847c4d99123798661bfc/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0dc5dceeaefcc96dc192e3a80bbe1d6c410c469e97bdd47494a7d930987f18b2", size = 384126 }, + { url = "https://files.pythonhosted.org/packages/54/77/ac339d5f82b6afff1df8f0fe0d2145cc827992cb5f8eeb90fc9f31ef7a63/rpds_py-0.27.1-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:d76f9cc8665acdc0c9177043746775aa7babbf479b5520b78ae4002d889f5c21", size = 399486 }, + { url = "https://files.pythonhosted.org/packages/d6/29/3e1c255eee6ac358c056a57d6d6869baa00a62fa32eea5ee0632039c50a3/rpds_py-0.27.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:134fae0e36022edad8290a6661edf40c023562964efea0cc0ec7f5d392d2aaef", size = 414832 }, + { url = "https://files.pythonhosted.org/packages/3f/db/6d498b844342deb3fa1d030598db93937a9964fcf5cb4da4feb5f17be34b/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb11a4f1b2b63337cfd3b4d110af778a59aae51c81d195768e353d8b52f88081", size = 557249 }, + { url = "https://files.pythonhosted.org/packages/60/f3/690dd38e2310b6f68858a331399b4d6dbb9132c3e8ef8b4333b96caf403d/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:13e608ac9f50a0ed4faec0e90ece76ae33b34c0e8656e3dceb9a7db994c692cd", size = 587356 }, + { url = "https://files.pythonhosted.org/packages/86/e3/84507781cccd0145f35b1dc32c72675200c5ce8d5b30f813e49424ef68fc/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dd2135527aa40f061350c3f8f89da2644de26cd73e4de458e79606384f4f68e7", size = 555300 }, + { url = "https://files.pythonhosted.org/packages/e5/ee/375469849e6b429b3516206b4580a79e9ef3eb12920ddbd4492b56eaacbe/rpds_py-0.27.1-cp313-cp313t-win32.whl", hash = "sha256:3020724ade63fe320a972e2ffd93b5623227e684315adce194941167fee02688", size = 216714 }, + { url = "https://files.pythonhosted.org/packages/21/87/3fc94e47c9bd0742660e84706c311a860dcae4374cf4a03c477e23ce605a/rpds_py-0.27.1-cp313-cp313t-win_amd64.whl", hash = "sha256:8ee50c3e41739886606388ba3ab3ee2aae9f35fb23f833091833255a31740797", size = 228943 }, + { url = "https://files.pythonhosted.org/packages/70/36/b6e6066520a07cf029d385de869729a895917b411e777ab1cde878100a1d/rpds_py-0.27.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:acb9aafccaae278f449d9c713b64a9e68662e7799dbd5859e2c6b3c67b56d334", size = 362472 }, + { url = "https://files.pythonhosted.org/packages/af/07/b4646032e0dcec0df9c73a3bd52f63bc6c5f9cda992f06bd0e73fe3fbebd/rpds_py-0.27.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b7fb801aa7f845ddf601c49630deeeccde7ce10065561d92729bfe81bd21fb33", size = 345676 }, + { url = "https://files.pythonhosted.org/packages/b0/16/2f1003ee5d0af4bcb13c0cf894957984c32a6751ed7206db2aee7379a55e/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe0dd05afb46597b9a2e11c351e5e4283c741237e7f617ffb3252780cca9336a", size = 385313 }, + { url = "https://files.pythonhosted.org/packages/05/cd/7eb6dd7b232e7f2654d03fa07f1414d7dfc980e82ba71e40a7c46fd95484/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b6dfb0e058adb12d8b1d1b25f686e94ffa65d9995a5157afe99743bf7369d62b", size = 399080 }, + { url = "https://files.pythonhosted.org/packages/20/51/5829afd5000ec1cb60f304711f02572d619040aa3ec033d8226817d1e571/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed090ccd235f6fa8bb5861684567f0a83e04f52dfc2e5c05f2e4b1309fcf85e7", size = 523868 }, + { url = "https://files.pythonhosted.org/packages/05/2c/30eebca20d5db95720ab4d2faec1b5e4c1025c473f703738c371241476a2/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bf876e79763eecf3e7356f157540d6a093cef395b65514f17a356f62af6cc136", size = 408750 }, + { url = "https://files.pythonhosted.org/packages/90/1a/cdb5083f043597c4d4276eae4e4c70c55ab5accec078da8611f24575a367/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:12ed005216a51b1d6e2b02a7bd31885fe317e45897de81d86dcce7d74618ffff", size = 387688 }, + { url = "https://files.pythonhosted.org/packages/7c/92/cf786a15320e173f945d205ab31585cc43969743bb1a48b6888f7a2b0a2d/rpds_py-0.27.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:ee4308f409a40e50593c7e3bb8cbe0b4d4c66d1674a316324f0c2f5383b486f9", size = 407225 }, + { url = "https://files.pythonhosted.org/packages/33/5c/85ee16df5b65063ef26017bef33096557a4c83fbe56218ac7cd8c235f16d/rpds_py-0.27.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0b08d152555acf1f455154d498ca855618c1378ec810646fcd7c76416ac6dc60", size = 423361 }, + { url = "https://files.pythonhosted.org/packages/4b/8e/1c2741307fcabd1a334ecf008e92c4f47bb6f848712cf15c923becfe82bb/rpds_py-0.27.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:dce51c828941973a5684d458214d3a36fcd28da3e1875d659388f4f9f12cc33e", size = 562493 }, + { url = "https://files.pythonhosted.org/packages/04/03/5159321baae9b2222442a70c1f988cbbd66b9be0675dd3936461269be360/rpds_py-0.27.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:c1476d6f29eb81aa4151c9a31219b03f1f798dc43d8af1250a870735516a1212", size = 592623 }, + { url = "https://files.pythonhosted.org/packages/ff/39/c09fd1ad28b85bc1d4554a8710233c9f4cefd03d7717a1b8fbfd171d1167/rpds_py-0.27.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ce0cac322b0d69b63c9cdb895ee1b65805ec9ffad37639f291dd79467bee675", size = 558800 }, + { url = "https://files.pythonhosted.org/packages/c5/d6/99228e6bbcf4baa764b18258f519a9035131d91b538d4e0e294313462a98/rpds_py-0.27.1-cp314-cp314-win32.whl", hash = "sha256:dfbfac137d2a3d0725758cd141f878bf4329ba25e34979797c89474a89a8a3a3", size = 221943 }, + { url = "https://files.pythonhosted.org/packages/be/07/c802bc6b8e95be83b79bdf23d1aa61d68324cb1006e245d6c58e959e314d/rpds_py-0.27.1-cp314-cp314-win_amd64.whl", hash = "sha256:a6e57b0abfe7cc513450fcf529eb486b6e4d3f8aee83e92eb5f1ef848218d456", size = 233739 }, + { url = "https://files.pythonhosted.org/packages/c8/89/3e1b1c16d4c2d547c5717377a8df99aee8099ff050f87c45cb4d5fa70891/rpds_py-0.27.1-cp314-cp314-win_arm64.whl", hash = "sha256:faf8d146f3d476abfee026c4ae3bdd9ca14236ae4e4c310cbd1cf75ba33d24a3", size = 223120 }, + { url = "https://files.pythonhosted.org/packages/62/7e/dc7931dc2fa4a6e46b2a4fa744a9fe5c548efd70e0ba74f40b39fa4a8c10/rpds_py-0.27.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:ba81d2b56b6d4911ce735aad0a1d4495e808b8ee4dc58715998741a26874e7c2", size = 358944 }, + { url = "https://files.pythonhosted.org/packages/e6/22/4af76ac4e9f336bfb1a5f240d18a33c6b2fcaadb7472ac7680576512b49a/rpds_py-0.27.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:84f7d509870098de0e864cad0102711c1e24e9b1a50ee713b65928adb22269e4", size = 342283 }, + { url = "https://files.pythonhosted.org/packages/1c/15/2a7c619b3c2272ea9feb9ade67a45c40b3eeb500d503ad4c28c395dc51b4/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9e960fc78fecd1100539f14132425e1d5fe44ecb9239f8f27f079962021523e", size = 380320 }, + { url = "https://files.pythonhosted.org/packages/a2/7d/4c6d243ba4a3057e994bb5bedd01b5c963c12fe38dde707a52acdb3849e7/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:62f85b665cedab1a503747617393573995dac4600ff51869d69ad2f39eb5e817", size = 391760 }, + { url = "https://files.pythonhosted.org/packages/b4/71/b19401a909b83bcd67f90221330bc1ef11bc486fe4e04c24388d28a618ae/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fed467af29776f6556250c9ed85ea5a4dd121ab56a5f8b206e3e7a4c551e48ec", size = 522476 }, + { url = "https://files.pythonhosted.org/packages/e4/44/1a3b9715c0455d2e2f0f6df5ee6d6f5afdc423d0773a8a682ed2b43c566c/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2729615f9d430af0ae6b36cf042cb55c0936408d543fb691e1a9e36648fd35a", size = 403418 }, + { url = "https://files.pythonhosted.org/packages/1c/4b/fb6c4f14984eb56673bc868a66536f53417ddb13ed44b391998100a06a96/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b207d881a9aef7ba753d69c123a35d96ca7cb808056998f6b9e8747321f03b8", size = 384771 }, + { url = "https://files.pythonhosted.org/packages/c0/56/d5265d2d28b7420d7b4d4d85cad8ef891760f5135102e60d5c970b976e41/rpds_py-0.27.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:639fd5efec029f99b79ae47e5d7e00ad8a773da899b6309f6786ecaf22948c48", size = 400022 }, + { url = "https://files.pythonhosted.org/packages/8f/e9/9f5fc70164a569bdd6ed9046486c3568d6926e3a49bdefeeccfb18655875/rpds_py-0.27.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fecc80cb2a90e28af8a9b366edacf33d7a91cbfe4c2c4544ea1246e949cfebeb", size = 416787 }, + { url = "https://files.pythonhosted.org/packages/d4/64/56dd03430ba491db943a81dcdef115a985aac5f44f565cd39a00c766d45c/rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42a89282d711711d0a62d6f57d81aa43a1368686c45bc1c46b7f079d55692734", size = 557538 }, + { url = "https://files.pythonhosted.org/packages/3f/36/92cc885a3129993b1d963a2a42ecf64e6a8e129d2c7cc980dbeba84e55fb/rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:cf9931f14223de59551ab9d38ed18d92f14f055a5f78c1d8ad6493f735021bbb", size = 588512 }, + { url = "https://files.pythonhosted.org/packages/dd/10/6b283707780a81919f71625351182b4f98932ac89a09023cb61865136244/rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f39f58a27cc6e59f432b568ed8429c7e1641324fbe38131de852cd77b2d534b0", size = 555813 }, + { url = "https://files.pythonhosted.org/packages/04/2e/30b5ea18c01379da6272a92825dd7e53dc9d15c88a19e97932d35d430ef7/rpds_py-0.27.1-cp314-cp314t-win32.whl", hash = "sha256:d5fa0ee122dc09e23607a28e6d7b150da16c662e66409bbe85230e4c85bb528a", size = 217385 }, + { url = "https://files.pythonhosted.org/packages/32/7d/97119da51cb1dd3f2f3c0805f155a3aa4a95fa44fe7d78ae15e69edf4f34/rpds_py-0.27.1-cp314-cp314t-win_amd64.whl", hash = "sha256:6567d2bb951e21232c2f660c24cf3470bb96de56cdcb3f071a83feeaff8a2772", size = 230097 }, +] + +[[package]] +name = "scipy" +version = "1.16.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4c/3b/546a6f0bfe791bbb7f8d591613454d15097e53f906308ec6f7c1ce588e8e/scipy-1.16.2.tar.gz", hash = "sha256:af029b153d243a80afb6eabe40b0a07f8e35c9adc269c019f364ad747f826a6b", size = 30580599 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/27/c5b52f1ee81727a9fc457f5ac1e9bf3d6eab311805ea615c83c27ba06400/scipy-1.16.2-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:84f7bf944b43e20b8a894f5fe593976926744f6c185bacfcbdfbb62736b5cc70", size = 36604856 }, + { url = "https://files.pythonhosted.org/packages/32/a9/15c20d08e950b540184caa8ced675ba1128accb0e09c653780ba023a4110/scipy-1.16.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:5c39026d12edc826a1ef2ad35ad1e6d7f087f934bb868fc43fa3049c8b8508f9", size = 28864626 }, + { url = "https://files.pythonhosted.org/packages/4c/fc/ea36098df653cca26062a627c1a94b0de659e97127c8491e18713ca0e3b9/scipy-1.16.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e52729ffd45b68777c5319560014d6fd251294200625d9d70fd8626516fc49f5", size = 20855689 }, + { url = "https://files.pythonhosted.org/packages/dc/6f/d0b53be55727f3e6d7c72687ec18ea6d0047cf95f1f77488b99a2bafaee1/scipy-1.16.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:024dd4a118cccec09ca3209b7e8e614931a6ffb804b2a601839499cb88bdf925", size = 23512151 }, + { url = "https://files.pythonhosted.org/packages/11/85/bf7dab56e5c4b1d3d8eef92ca8ede788418ad38a7dc3ff50262f00808760/scipy-1.16.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7a5dc7ee9c33019973a470556081b0fd3c9f4c44019191039f9769183141a4d9", size = 33329824 }, + { url = "https://files.pythonhosted.org/packages/da/6a/1a927b14ddc7714111ea51f4e568203b2bb6ed59bdd036d62127c1a360c8/scipy-1.16.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c2275ff105e508942f99d4e3bc56b6ef5e4b3c0af970386ca56b777608ce95b7", size = 35681881 }, + { url = "https://files.pythonhosted.org/packages/c1/5f/331148ea5780b4fcc7007a4a6a6ee0a0c1507a796365cc642d4d226e1c3a/scipy-1.16.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:af80196eaa84f033e48444d2e0786ec47d328ba00c71e4299b602235ffef9acb", size = 36006219 }, + { url = "https://files.pythonhosted.org/packages/46/3a/e991aa9d2aec723b4a8dcfbfc8365edec5d5e5f9f133888067f1cbb7dfc1/scipy-1.16.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9fb1eb735fe3d6ed1f89918224e3385fbf6f9e23757cacc35f9c78d3b712dd6e", size = 38682147 }, + { url = "https://files.pythonhosted.org/packages/a1/57/0f38e396ad19e41b4c5db66130167eef8ee620a49bc7d0512e3bb67e0cab/scipy-1.16.2-cp313-cp313-win_amd64.whl", hash = "sha256:fda714cf45ba43c9d3bae8f2585c777f64e3f89a2e073b668b32ede412d8f52c", size = 38520766 }, + { url = "https://files.pythonhosted.org/packages/1b/a5/85d3e867b6822d331e26c862a91375bb7746a0b458db5effa093d34cdb89/scipy-1.16.2-cp313-cp313-win_arm64.whl", hash = "sha256:2f5350da923ccfd0b00e07c3e5cfb316c1c0d6c1d864c07a72d092e9f20db104", size = 25451169 }, + { url = "https://files.pythonhosted.org/packages/09/d9/60679189bcebda55992d1a45498de6d080dcaf21ce0c8f24f888117e0c2d/scipy-1.16.2-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:53d8d2ee29b925344c13bda64ab51785f016b1b9617849dac10897f0701b20c1", size = 37012682 }, + { url = "https://files.pythonhosted.org/packages/83/be/a99d13ee4d3b7887a96f8c71361b9659ba4ef34da0338f14891e102a127f/scipy-1.16.2-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:9e05e33657efb4c6a9d23bd8300101536abd99c85cca82da0bffff8d8764d08a", size = 29389926 }, + { url = "https://files.pythonhosted.org/packages/bf/0a/130164a4881cec6ca8c00faf3b57926f28ed429cd6001a673f83c7c2a579/scipy-1.16.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:7fe65b36036357003b3ef9d37547abeefaa353b237e989c21027b8ed62b12d4f", size = 21381152 }, + { url = "https://files.pythonhosted.org/packages/47/a6/503ffb0310ae77fba874e10cddfc4a1280bdcca1d13c3751b8c3c2996cf8/scipy-1.16.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:6406d2ac6d40b861cccf57f49592f9779071655e9f75cd4f977fa0bdd09cb2e4", size = 23914410 }, + { url = "https://files.pythonhosted.org/packages/fa/c7/1147774bcea50d00c02600aadaa919facbd8537997a62496270133536ed6/scipy-1.16.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ff4dc42bd321991fbf611c23fc35912d690f731c9914bf3af8f417e64aca0f21", size = 33481880 }, + { url = "https://files.pythonhosted.org/packages/6a/74/99d5415e4c3e46b2586f30cdbecb95e101c7192628a484a40dd0d163811a/scipy-1.16.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:654324826654d4d9133e10675325708fb954bc84dae6e9ad0a52e75c6b1a01d7", size = 35791425 }, + { url = "https://files.pythonhosted.org/packages/1b/ee/a6559de7c1cc710e938c0355d9d4fbcd732dac4d0d131959d1f3b63eb29c/scipy-1.16.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63870a84cd15c44e65220eaed2dac0e8f8b26bbb991456a033c1d9abfe8a94f8", size = 36178622 }, + { url = "https://files.pythonhosted.org/packages/4e/7b/f127a5795d5ba8ece4e0dce7d4a9fb7cb9e4f4757137757d7a69ab7d4f1a/scipy-1.16.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:fa01f0f6a3050fa6a9771a95d5faccc8e2f5a92b4a2e5440a0fa7264a2398472", size = 38783985 }, + { url = "https://files.pythonhosted.org/packages/3e/9f/bc81c1d1e033951eb5912cd3750cc005943afa3e65a725d2443a3b3c4347/scipy-1.16.2-cp313-cp313t-win_amd64.whl", hash = "sha256:116296e89fba96f76353a8579820c2512f6e55835d3fad7780fece04367de351", size = 38631367 }, + { url = "https://files.pythonhosted.org/packages/d6/5e/2cc7555fd81d01814271412a1d59a289d25f8b63208a0a16c21069d55d3e/scipy-1.16.2-cp313-cp313t-win_arm64.whl", hash = "sha256:98e22834650be81d42982360382b43b17f7ba95e0e6993e2a4f5b9ad9283a94d", size = 25787992 }, + { url = "https://files.pythonhosted.org/packages/8b/ac/ad8951250516db71619f0bd3b2eb2448db04b720a003dd98619b78b692c0/scipy-1.16.2-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:567e77755019bb7461513c87f02bb73fb65b11f049aaaa8ca17cfaa5a5c45d77", size = 36595109 }, + { url = "https://files.pythonhosted.org/packages/ff/f6/5779049ed119c5b503b0f3dc6d6f3f68eefc3a9190d4ad4c276f854f051b/scipy-1.16.2-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:17d9bb346194e8967296621208fcdfd39b55498ef7d2f376884d5ac47cec1a70", size = 28859110 }, + { url = "https://files.pythonhosted.org/packages/82/09/9986e410ae38bf0a0c737ff8189ac81a93b8e42349aac009891c054403d7/scipy-1.16.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:0a17541827a9b78b777d33b623a6dcfe2ef4a25806204d08ead0768f4e529a88", size = 20850110 }, + { url = "https://files.pythonhosted.org/packages/0d/ad/485cdef2d9215e2a7df6d61b81d2ac073dfacf6ae24b9ae87274c4e936ae/scipy-1.16.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:d7d4c6ba016ffc0f9568d012f5f1eb77ddd99412aea121e6fa8b4c3b7cbad91f", size = 23497014 }, + { url = "https://files.pythonhosted.org/packages/a7/74/f6a852e5d581122b8f0f831f1d1e32fb8987776ed3658e95c377d308ed86/scipy-1.16.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9702c4c023227785c779cba2e1d6f7635dbb5b2e0936cdd3a4ecb98d78fd41eb", size = 33401155 }, + { url = "https://files.pythonhosted.org/packages/d9/f5/61d243bbc7c6e5e4e13dde9887e84a5cbe9e0f75fd09843044af1590844e/scipy-1.16.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d1cdf0ac28948d225decdefcc45ad7dd91716c29ab56ef32f8e0d50657dffcc7", size = 35691174 }, + { url = "https://files.pythonhosted.org/packages/03/99/59933956331f8cc57e406cdb7a483906c74706b156998f322913e789c7e1/scipy-1.16.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:70327d6aa572a17c2941cdfb20673f82e536e91850a2e4cb0c5b858b690e1548", size = 36070752 }, + { url = "https://files.pythonhosted.org/packages/c6/7d/00f825cfb47ee19ef74ecf01244b43e95eae74e7e0ff796026ea7cd98456/scipy-1.16.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5221c0b2a4b58aa7c4ed0387d360fd90ee9086d383bb34d9f2789fafddc8a936", size = 38701010 }, + { url = "https://files.pythonhosted.org/packages/e4/9f/b62587029980378304ba5a8563d376c96f40b1e133daacee76efdcae32de/scipy-1.16.2-cp314-cp314-win_amd64.whl", hash = "sha256:f5a85d7b2b708025af08f060a496dd261055b617d776fc05a1a1cc69e09fe9ff", size = 39360061 }, + { url = "https://files.pythonhosted.org/packages/82/04/7a2f1609921352c7fbee0815811b5050582f67f19983096c4769867ca45f/scipy-1.16.2-cp314-cp314-win_arm64.whl", hash = "sha256:2cc73a33305b4b24556957d5857d6253ce1e2dcd67fa0ff46d87d1670b3e1e1d", size = 26126914 }, + { url = "https://files.pythonhosted.org/packages/51/b9/60929ce350c16b221928725d2d1d7f86cf96b8bc07415547057d1196dc92/scipy-1.16.2-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:9ea2a3fed83065d77367775d689401a703d0f697420719ee10c0780bcab594d8", size = 37013193 }, + { url = "https://files.pythonhosted.org/packages/2a/41/ed80e67782d4bc5fc85a966bc356c601afddd175856ba7c7bb6d9490607e/scipy-1.16.2-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7280d926f11ca945c3ef92ba960fa924e1465f8d07ce3a9923080363390624c4", size = 29390172 }, + { url = "https://files.pythonhosted.org/packages/c4/a3/2f673ace4090452696ccded5f5f8efffb353b8f3628f823a110e0170b605/scipy-1.16.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:8afae1756f6a1fe04636407ef7dbece33d826a5d462b74f3d0eb82deabefd831", size = 21381326 }, + { url = "https://files.pythonhosted.org/packages/42/bf/59df61c5d51395066c35836b78136accf506197617c8662e60ea209881e1/scipy-1.16.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:5c66511f29aa8d233388e7416a3f20d5cae7a2744d5cee2ecd38c081f4e861b3", size = 23915036 }, + { url = "https://files.pythonhosted.org/packages/91/c3/edc7b300dc16847ad3672f1a6f3f7c5d13522b21b84b81c265f4f2760d4a/scipy-1.16.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:efe6305aeaa0e96b0ccca5ff647a43737d9a092064a3894e46c414db84bc54ac", size = 33484341 }, + { url = "https://files.pythonhosted.org/packages/26/c7/24d1524e72f06ff141e8d04b833c20db3021020563272ccb1b83860082a9/scipy-1.16.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f3a337d9ae06a1e8d655ee9d8ecb835ea5ddcdcbd8d23012afa055ab014f374", size = 35790840 }, + { url = "https://files.pythonhosted.org/packages/aa/b7/5aaad984eeedd56858dc33d75efa59e8ce798d918e1033ef62d2708f2c3d/scipy-1.16.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bab3605795d269067d8ce78a910220262711b753de8913d3deeaedb5dded3bb6", size = 36174716 }, + { url = "https://files.pythonhosted.org/packages/fd/c2/e276a237acb09824822b0ada11b028ed4067fdc367a946730979feacb870/scipy-1.16.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b0348d8ddb55be2a844c518cd8cc8deeeb8aeba707cf834db5758fc89b476a2c", size = 38790088 }, + { url = "https://files.pythonhosted.org/packages/c6/b4/5c18a766e8353015439f3780f5fc473f36f9762edc1a2e45da3ff5a31b21/scipy-1.16.2-cp314-cp314t-win_amd64.whl", hash = "sha256:26284797e38b8a75e14ea6631d29bda11e76ceaa6ddb6fdebbfe4c4d90faf2f9", size = 39457455 }, + { url = "https://files.pythonhosted.org/packages/97/30/2f9a5243008f76dfc5dee9a53dfb939d9b31e16ce4bd4f2e628bfc5d89d2/scipy-1.16.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d2a4472c231328d4de38d5f1f68fdd6d28a615138f842580a8a321b5845cf779", size = 26448374 }, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/3a/aec9b02217bb79b87bbc1a21bc6abc51e3d5dcf65c30487ac96c0908c722/Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf", size = 17394 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072 }, +] + +[[package]] +name = "setuptools" +version = "80.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486 }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, +] + +[[package]] +name = "soupsieve" +version = "2.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679 }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, +] + +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154 }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610 }, +] + +[[package]] +name = "tornado" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/ce/1eb500eae19f4648281bb2186927bb062d2438c2e5093d1360391afd2f90/tornado-6.5.2.tar.gz", hash = "sha256:ab53c8f9a0fa351e2c0741284e06c7a45da86afb544133201c5cc8578eb076a0", size = 510821 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/48/6a7529df2c9cc12efd2e8f5dd219516184d703b34c06786809670df5b3bd/tornado-6.5.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2436822940d37cde62771cff8774f4f00b3c8024fe482e16ca8387b8a2724db6", size = 442563 }, + { url = "https://files.pythonhosted.org/packages/f2/b5/9b575a0ed3e50b00c40b08cbce82eb618229091d09f6d14bce80fc01cb0b/tornado-6.5.2-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:583a52c7aa94ee046854ba81d9ebb6c81ec0fd30386d96f7640c96dad45a03ef", size = 440729 }, + { url = "https://files.pythonhosted.org/packages/1b/4e/619174f52b120efcf23633c817fd3fed867c30bff785e2cd5a53a70e483c/tornado-6.5.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0fe179f28d597deab2842b86ed4060deec7388f1fd9c1b4a41adf8af058907e", size = 444295 }, + { url = "https://files.pythonhosted.org/packages/95/fa/87b41709552bbd393c85dd18e4e3499dcd8983f66e7972926db8d96aa065/tornado-6.5.2-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b186e85d1e3536d69583d2298423744740986018e393d0321df7340e71898882", size = 443644 }, + { url = "https://files.pythonhosted.org/packages/f9/41/fb15f06e33d7430ca89420283a8762a4e6b8025b800ea51796ab5e6d9559/tornado-6.5.2-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e792706668c87709709c18b353da1f7662317b563ff69f00bab83595940c7108", size = 443878 }, + { url = "https://files.pythonhosted.org/packages/11/92/fe6d57da897776ad2e01e279170ea8ae726755b045fe5ac73b75357a5a3f/tornado-6.5.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:06ceb1300fd70cb20e43b1ad8aaee0266e69e7ced38fa910ad2e03285009ce7c", size = 444549 }, + { url = "https://files.pythonhosted.org/packages/9b/02/c8f4f6c9204526daf3d760f4aa555a7a33ad0e60843eac025ccfd6ff4a93/tornado-6.5.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:74db443e0f5251be86cbf37929f84d8c20c27a355dd452a5cfa2aada0d001ec4", size = 443973 }, + { url = "https://files.pythonhosted.org/packages/ae/2d/f5f5707b655ce2317190183868cd0f6822a1121b4baeae509ceb9590d0bd/tornado-6.5.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b5e735ab2889d7ed33b32a459cac490eda71a1ba6857b0118de476ab6c366c04", size = 443954 }, + { url = "https://files.pythonhosted.org/packages/e8/59/593bd0f40f7355806bf6573b47b8c22f8e1374c9b6fd03114bd6b7a3dcfd/tornado-6.5.2-cp39-abi3-win32.whl", hash = "sha256:c6f29e94d9b37a95013bb669616352ddb82e3bfe8326fccee50583caebc8a5f0", size = 445023 }, + { url = "https://files.pythonhosted.org/packages/c7/2a/f609b420c2f564a748a2d80ebfb2ee02a73ca80223af712fca591386cafb/tornado-6.5.2-cp39-abi3-win_amd64.whl", hash = "sha256:e56a5af51cc30dd2cae649429af65ca2f6571da29504a07995175df14c18f35f", size = 445427 }, + { url = "https://files.pythonhosted.org/packages/5e/4f/e1f65e8f8c76d73658b33d33b81eed4322fb5085350e4328d5c956f0c8f9/tornado-6.5.2-cp39-abi3-win_arm64.whl", hash = "sha256:d6c33dc3672e3a1f3618eb63b7ef4683a7688e7b9e6e8f0d9aa5726360a004af", size = 444456 }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20250822" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/0a/775f8551665992204c756be326f3575abba58c4a3a52eef9909ef4536428/types_python_dateutil-2.9.0.20250822.tar.gz", hash = "sha256:84c92c34bd8e68b117bff742bc00b692a1e8531262d4507b33afcc9f7716cd53", size = 16084 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/d9/a29dfa84363e88b053bf85a8b7f212a04f0d7343a4d24933baa45c06e08b/types_python_dateutil-2.9.0.20250822-py3-none-any.whl", hash = "sha256:849d52b737e10a6dc6621d2bd7940ec7c65fcb69e6aa2882acf4e56b2b508ddc", size = 17892 }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614 }, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140 }, +] + +[[package]] +name = "urllib3" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795 }, +] + +[[package]] +name = "wcwidth" +version = "0.2.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286 }, +] + +[[package]] +name = "webcolors" +version = "24.11.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/29/061ec845fb58521848f3739e466efd8250b4b7b98c1b6c5bf4d40b419b7e/webcolors-24.11.1.tar.gz", hash = "sha256:ecb3d768f32202af770477b8b65f318fa4f566c22948673a977b00d589dd80f6", size = 45064 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/e8/c0e05e4684d13459f93d312077a9a2efbe04d59c393bc2b8802248c908d4/webcolors-24.11.1-py3-none-any.whl", hash = "sha256:515291393b4cdf0eb19c155749a096f779f7d909f7cceea072791cb9095b92e9", size = 14934 }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774 }, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826 }, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/41/53/2e0253c5efd69c9656b1843892052a31c36d37ad42812b5da45c62191f7e/widgetsnbextension-4.0.14.tar.gz", hash = "sha256:a3629b04e3edb893212df862038c7232f62973373869db5084aed739b437b5af", size = 1097428 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/51/5447876806d1088a0f8f71e16542bf350918128d0a69437df26047c8e46f/widgetsnbextension-4.0.14-py3-none-any.whl", hash = "sha256:4875a9eaf72fbf5079dc372a51a9f268fc38d46f767cbf85c43a36da5cb9b575", size = 2196503 }, +]