diff --git a/MOMENTUM.ipynb b/MOMENTUM.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..be9559f1e4f8c83bce24b55c30e9995b5a573dcb
--- /dev/null
+++ b/MOMENTUM.ipynb
@@ -0,0 +1,818 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "id": "S8m41xZ_qRRd"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "from itertools import permutations\n",
+        "\n",
+        "def unpack_params(params, shapes, dtypes):\n",
+        "    \"\"\"Unpack params back into matrices with given shapes and dtypes.\"\"\"\n",
+        "    idx = 0\n",
+        "    matrices = []\n",
+        "    for shape, dtype in zip(shapes, dtypes):\n",
+        "        size = np.prod(shape)\n",
+        "        values = params[idx:idx + size]\n",
+        "        matrix = values.reshape(shape).astype(dtype)\n",
+        "        matrices.append(matrix)\n",
+        "        idx += size\n",
+        "    return matrices\n",
+        "\n",
+        "def sample_uniform_frequencies_1d(n, bound=0.5):\n",
+        "    # Calculer le nombre de points dans chaque dimension\n",
+        "    N = 2 * n + 1\n",
+        "    # Générer une grille uniforme de points entre -0.5 et 0.5\n",
+        "    #bound = 8\n",
+        "    grid_1d = np.linspace(-bound, bound, N)\n",
+        "    return grid_1d\n",
+        "\n",
+        "class Gauss1D():\n",
+        "\n",
+        "  def __init__(self, n=0, sigma=1):\n",
+        "    self.n = n\n",
+        "    self.sigma = sigma\n",
+        "\n",
+        "    self.g_ = np.array([])\n",
+        "    self.g()\n",
+        "\n",
+        "  def fourier(self, w):\n",
+        "    return np.exp(-2 * (w * self.sigma * np.pi)**2)\n",
+        "\n",
+        "  def g(self):\n",
+        "    if len(self.g_) == 0:\n",
+        "      freqs = sample_uniform_frequencies_1d(self.n)\n",
+        "      self.g_ = np.array([self.fourier(f) for f in freqs])\n",
+        "    return self.g_\n",
+        "\n",
+        "  def compute(self, t):\n",
+        "    t_array = np.array(t)\n",
+        "    return (1/(self.sigma*np.sqrt(2*np.pi))) * np.exp(-t_array**2/(2* self.sigma**2))\n",
+        "\n",
+        "  def computeK(self, t):\n",
+        "    t = np.array(t)\n",
+        "    freqs = sample_uniform_frequencies_1d(self.n)\n",
+        "    if len(t.shape) == 0:\n",
+        "        return np.sum(np.abs(self.g())**2 * np.exp(2j * np.pi * freqs * t))\n",
+        "    V = np.exp(2j * np.pi * np.outer(freqs, t))\n",
+        "    return np.sum(np.abs(self.g())**2 * V.T, axis=1).reshape(t.shape)\n",
+        "\n",
+        "  def computeK_p(self, t):\n",
+        "      t = np.array(t)\n",
+        "      freqs = sample_uniform_frequencies_1d(self.n)\n",
+        "      if len(t.shape) == 0:\n",
+        "          return np.sum(2j * np.pi * freqs * np.abs(self.g())**2 * np.exp(2j * np.pi * freqs * t))\n",
+        "      V = np.exp(2j * np.pi * np.outer(freqs, t))\n",
+        "      return np.sum(np.abs(self.g())**2 * (2j * np.pi * freqs) * V.T, axis=1).reshape(t.shape)\n",
+        "\n",
+        "  def computeK_pp(self, t):\n",
+        "      t = np.array(t)\n",
+        "      freqs = sample_uniform_frequencies_1d(self.n)\n",
+        "      if len(t.shape) == 0:\n",
+        "          return np.sum((2j * np.pi * freqs)**2 * np.abs(self.g())**2 * np.exp(2j * np.pi * freqs * t))\n",
+        "      V = np.exp(2j * np.pi * np.outer(freqs, t))\n",
+        "      return np.sum(np.abs(self.g())**2 * (2j * np.pi * freqs)**2 * V.T, axis=1).reshape(t.shape)\n",
+        "\n",
+        "  def computeK_pp0(self):\n",
+        "      return self.computeK_pp(0)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def compute_z(a, tau, g, freqs):\n",
+        "    r = len(tau)\n",
+        "    z = np.zeros(len(freqs), dtype=complex)  # Initialize z with complex numbers\n",
+        "\n",
+        "    for k in range(len(freqs)):  # Loop over dimension len(freqs)\n",
+        "        z[k] = np.sum([a[j] * g[k] * np.exp(2j * np.pi * tau[j] * freqs[k]) for j in range(r)])\n",
+        "\n",
+        "    return z\n",
+        "\n",
+        "def grad_approx_perso(kernel, theta_pred, data_observed, freqs):\n",
+        "\n",
+        "        r = int(len(theta_pred)/2)\n",
+        "        a = theta_pred[:r]\n",
+        "        tau = theta_pred[r:]\n",
+        "        grad = np.zeros(2*r, dtype=complex)\n",
+        "\n",
+        "        tau_matrix = np.tile(tau, (r,1)).T\n",
+        "        tau_diff_matrix = tau_matrix - tau_matrix.T\n",
+        "\n",
+        "        k_matrix = np.array([kernel.computeK(tau_diff_matrix)])[0]\n",
+        "        kp_matrix = np.array([kernel.computeK_p(tau_diff_matrix)])[0]\n",
+        "\n",
+        "        kernel_g = np.conj(kernel.g()).reshape(-1,1)\n",
+        "        exp_term = np.exp(-2j*np.pi*np.outer(tau,freqs))\n",
+        "        freqs = freqs.reshape(-1,1)\n",
+        "\n",
+        "        for j in range(r):\n",
+        "            grad[j] = np.sum(theta_pred[:r]*k_matrix[j]) - np.sum(kernel_g*data_observed*(exp_term[j].reshape(-1,1)))\n",
+        "            grad[j+r] = np.real(np.conj(a[j]) * np.sum(theta_pred[:r]*kp_matrix[j])) - np.real(np.conj(a[j]) * np.sum(kernel_g*data_observed*-2j*np.pi*freqs*(exp_term[j].reshape(-1,1))))\n",
+        "\n",
+        "        return grad"
+      ],
+      "metadata": {
+        "id": "MvJ7fszZqW2J"
+      },
+      "execution_count": 13,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def add_noise(y_current, snr_db):\n",
+        "    # Calcul de la puissance du signal\n",
+        "    signal_power = np.mean(np.abs(y_current)**2)\n",
+        "\n",
+        "    # Conversion du SNR de dB à linéaire\n",
+        "    snr_linear = 10**(snr_db/10)\n",
+        "\n",
+        "    # Calcul de la puissance du bruit\n",
+        "    noise_power = signal_power / snr_linear\n",
+        "\n",
+        "    # Génération du bruit (pour un signal complexe)\n",
+        "    noise = np.sqrt(noise_power/2) * (np.random.randn(*y_current.shape) + 1j*np.random.randn(*y_current.shape))\n",
+        "\n",
+        "    # Signal bruité\n",
+        "    y_noisy = y_current + noise\n",
+        "    return y_noisy"
+      ],
+      "metadata": {
+        "id": "X-SAhA-dqZjT"
+      },
+      "execution_count": 14,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Loss function\n",
+        "def MSE_loss(params, y_current):\n",
+        "    shapes = [(r), (r)]  # Add dtype if needed\n",
+        "    dtypes = [complex, complex]\n",
+        "    a, tau = unpack_params(params, shapes, dtypes)\n",
+        "    z = compute_z(a, tau, g_star, freqs).reshape(-1,1)\n",
+        "    return 0.5 * np.linalg.norm(y_current - z) ** 2\n",
+        "\n",
+        "# Preconditioned gradient descent function\n",
+        "def preconditioned_gradient_descent(loss_func, initial_point, y_current, learning_rate=0.01, momentum=0.9, max_iters=200):\n",
+        "    point = np.array(initial_point, dtype=float)\n",
+        "    velocity = np.zeros_like(point)\n",
+        "    loss_values = []\n",
+        "    for i in range(max_iters):\n",
+        "        gradient = grad_approx_perso(kernel, point, y_current, freqs).real\n",
+        "        a = point[:r]\n",
+        "        velocity = momentum * velocity - learning_rate * P_k(a) @ gradient\n",
+        "        point = point + velocity\n",
+        "        #point[:r] = np.abs(point[:r])\n",
+        "        loss = loss_func(point, y_current)\n",
+        "        loss_values.append(loss)\n",
+        "    return point, loss_values"
+      ],
+      "metadata": {
+        "id": "9Y6nP2VTq9v0"
+      },
+      "execution_count": 15,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "n=7\n",
+        "N=2*n+1\n",
+        "\n",
+        "freqs = sample_uniform_frequencies_1d(n)\n",
+        "\n",
+        "tau_star = np.array([-6, -3, 5])  # Moyennes des gaussiennes\n",
+        "a_star = np.array([0.1, 0.1, 0.8])   # Amplitudes/proportions des gaussiennes\n",
+        "sigma=1\n",
+        "theta_star = np.concatenate((a_star, tau_star))\n",
+        "r = len(tau_star)\n",
+        "kernel = Gauss1D(n, sigma)\n",
+        "\n",
+        "g_star = kernel.fourier(freqs) + 0j\n",
+        "y_star = compute_z(a_star, tau_star, g_star, freqs)\n",
+        "\n",
+        "S_err = lambda theta : np.max([np.abs(theta[:r] - theta_star[:r])/np.abs(theta_star[:r]), np.sqrt(np.abs(kernel.computeK_pp0()))*np.abs(theta[r:] - theta_star[r:])])\n",
+        "\n",
+        "F_second = np.abs(kernel.computeK_pp0())\n",
+        "def P_k(a):\n",
+        "  return np.diag(np.concatenate( [np.ones(len(a)), (1/F_second) * (np.abs(a)**-2)] ))"
+      ],
+      "metadata": {
+        "id": "epjWi6jMqb1W"
+      },
+      "execution_count": 16,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "initial_point = theta_star + np.random.randn(2*r) * 0.1\n",
+        "y_current = y_star\n",
+        "\n",
+        "# --- Define the S_infty norm error as loss function ---\n",
+        "# This loss function ignores the second argument (y_current) since the error is computed only from theta.\n",
+        "S_err_wrapper = lambda theta, y: np.max([\n",
+        "    np.abs(theta[:r] - theta_star[:r]) / np.abs(theta_star[:r]),\n",
+        "    np.sqrt(np.abs(kernel.computeK_pp0())) * np.abs(theta[r:] - theta_star[r:])\n",
+        "])\n",
+        "\n",
+        "\n",
+        "# --- Save the original preconditioner ---\n",
+        "P_k_original = P_k\n",
+        "\n",
+        "# --- Define an identity preconditioner to simulate \"no preconditioning\" ---\n",
+        "def identity_P_k(a):\n",
+        "    return np.eye(2*len(a))\n",
+        "\n",
+        "# --- Experiment parameters ---\n",
+        "max_iters = 200\n",
+        "\n",
+        "# --- Experiment 1: Vanilla (no momentum, no preconditioning) ---\n",
+        "# Override P_k to be the identity.\n",
+        "P_k = identity_P_k\n",
+        "theta_vanilla, loss_vanilla = preconditioned_gradient_descent(\n",
+        "    S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "    learning_rate=0.3, momentum=0, max_iters=max_iters\n",
+        ")\n",
+        "\n",
+        "# --- Experiment 2: Gradient descent with momentum (momentum, no preconditioning) ---\n",
+        "P_k = identity_P_k  # still no preconditioning\n",
+        "theta_momentum, loss_momentum = preconditioned_gradient_descent(\n",
+        "    S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "    learning_rate=0.3, momentum=0.7, max_iters=max_iters\n",
+        ")\n",
+        "\n",
+        "# --- Experiment 3: Preconditioned gradient descent (no momentum, with preconditioning) ---\n",
+        "P_k = P_k_original  # restore the original preconditioner\n",
+        "theta_preconditioned, loss_preconditioned = preconditioned_gradient_descent(\n",
+        "    S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "    learning_rate=0.1, momentum=0, max_iters=max_iters\n",
+        ")\n",
+        "\n",
+        "# --- Experiment 4: Momentum + Preconditioning (momentum, with preconditioning) ---\n",
+        "P_k = P_k_original\n",
+        "theta_mom_prec, loss_mom_prec = preconditioned_gradient_descent(\n",
+        "    S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "    learning_rate=0.1, momentum=0.2, max_iters=max_iters\n",
+        ")\n",
+        "\n",
+        "print(\"theta_vanilla:\", theta_vanilla)\n",
+        "print(\"theta_momentum:\", theta_momentum)\n",
+        "print(\"theta_preconditioned:\", theta_preconditioned)\n",
+        "print(\"theta_mom_prec:\", theta_mom_prec)\n",
+        "\n",
+        "\n",
+        "# --- Plotting the evolution of S_infty error ---\n",
+        "iters = np.arange(max_iters)\n",
+        "\n",
+        "plt.figure(figsize=(8, 6))\n",
+        "\n",
+        "# Récupération du cycle de couleurs par défaut\n",
+        "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n",
+        "# Définition des linestyles et des markers pour chaque tracé\n",
+        "linestyles = ['-', '--', '-.', ':']\n",
+        "#markers = ['o', 's', '^', 'd']\n",
+        "\n",
+        "# Tracés individuels avec semilogy (permettant de voir les différences de style)\n",
+        "plt.semilogy(iters, loss_vanilla, linestyle=linestyles[0], color=colors[0],\n",
+        "             label=\"Descente gradient vanilla\")\n",
+        "plt.semilogy(iters, loss_momentum, linestyle=linestyles[1], color=colors[1],\n",
+        "             label=\"Descente gradient à momentum\")\n",
+        "plt.semilogy(iters, loss_preconditioned, linestyle=linestyles[2], color=colors[2],\n",
+        "             label=\"Descente préconditionnée\")\n",
+        "plt.semilogy(iters, loss_mom_prec, linestyle=linestyles[3], color=colors[3],\n",
+        "             label=\"Momentum + préconditionnement\")\n",
+        "\n",
+        "plt.xlabel(\"Itérations\")\n",
+        "plt.ylabel(\"Erreur S∞ (échelle logarithmique)\")\n",
+        "plt.title(\"Comparaison des algorithmes de descente\")\n",
+        "plt.legend()\n",
+        "plt.grid(True)\n",
+        "\n",
+        "plt.show()\n",
+        "\n",
+        "# --- Restore the original preconditioner if needed ---\n",
+        "P_k = P_k_original"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 633
+        },
+        "id": "d7xVKOISqz94",
+        "outputId": "6e4c7064-c065-497b-ffb0-70ea4f22985a"
+      },
+      "execution_count": 17,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "theta_vanilla: [ 0.09925046  0.10044822  0.79965786 -6.02632194 -3.05299735  4.9990702 ]\n",
+            "theta_momentum: [ 0.09991618  0.10017148  0.79984399 -6.01033117 -3.00873512  4.99955006]\n",
+            "theta_preconditioned: [ 0.1         0.10000064  0.79999936 -6.0000362  -3.00002304  4.99999712]\n",
+            "theta_mom_prec: [ 0.1         0.10000006  0.79999994 -6.00000344 -3.00000219  4.99999973]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x600 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAr8AAAIjCAYAAAAKvXPWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA9O1JREFUeJzs3Xd4FFX3wPHv7GZ30xvpIRAINbQgvQgoHRQQC4hKAMEWbOir2BB8/flaEYQgAoqKDaUrXQRBQQUxFOkQOoQSSC+b3fn9MWSTTYEQkmwSzud55snundmZs5MNnNyce6+iqqqKEEIIIYQQNwGdowMQQgghhBCiokjyK4QQQgghbhqS/AohhBBCiJuGJL9CCCGEEOKmIcmvEEIIIYS4aUjyK4QQQgghbhqS/AohhBBCiJuGJL9CCCGEEOKmIcmvEEIIIYS4aUjyK4Qod+Hh4YwYMcLRYVyXbt260a1bN0eHUSRHxzZixAjCw8NLfKy7u3v5BuRg13M/qsJ1hKjuJPkV4gYcPnyYRx99lLp16+Ls7IynpyedOnVi6tSpZGRkODo8ISpEeno6EydOZMOGDY4ORVQxp0+fZuLEicTFxTk6FHETcXJ0AEJUVcuXL+fee+/FZDIxfPhwmjZtSnZ2Nr/99hv/+c9/+Pfff5k1a5ajw6wU9u/fj04nv2tXF7Nnz8Zqtdqep6enM2nSJIBK21suKqfTp08zadIkwsPDiYqKcnQ44iYhya8QpRAfH8/QoUOpXbs2v/zyC8HBwbZ9MTExHDp0iOXLlzswwvJjtVrJzs7G2dm5xK8xmUzlGJGoKGlpabi5uWEwGBwdihBClJp0xQhRCu+++y6pqal8+umndolvrnr16vH000/bnufk5PDf//6XiIgITCYT4eHhvPzyy2RlZdm9Ljw8nDvuuIMNGzbQunVrXFxcaNasme3PyYsWLaJZs2Y4OzvTqlUr/vnnH7vX59ZXHjlyhN69e+Pm5kZISAhvvPEGqqraHfv+++/TsWNHatSogYuLC61atWLBggWF3ouiKIwdO5avv/6aJk2aYDKZWLVq1XWdo2DNr9lsZtKkSdSvXx9nZ2dq1KhB586dWbt2rd3rfvnlF2699Vbc3Nzw9vZm4MCB7N271+6YiRMnoigKhw4dYsSIEXh7e+Pl5cXIkSNJT08vFEtRZs2aRUREBC4uLrRt25ZNmzYVeVxWVhavv/469erVw2QyERYWxgsvvFDo+7h27Vo6d+6Mt7c37u7uNGzYkJdffvmaccydO5fbb7+dgIAATCYTkZGRfPzxxyV6D8eOHWPAgAG4ubkREBDAs88+y+rVq1EUpVA5wg8//ECrVq1wcXHBz8+PBx98kFOnTtkdk/tZOnz4MP369cPDw4MHHnjAti+39vTo0aP4+/sDMGnSJBRFQVEUJk6caHe+U6dOMWjQINzd3fH39+f555/HYrHY9h89ehRFUXj//feJjY2lbt26uLq60qtXL06cOIGqqvz3v/+lZs2auLi4MHDgQBITEwvdh5UrV9o+Mx4eHvTv359///3X7pizZ88ycuRIatasiclkIjg4mIEDB3L06NFr3uclS5bQtGlTnJ2dadq0KYsXLy7yOKvVypQpU2jSpAnOzs4EBgby6KOPcunSpWteozyus23bNnr37o2fnx8uLi7UqVOHUaNGFTrX1KlTbf/G+Pv706dPH7Zt22Z33FdffWX7/Pj6+jJ06FBOnDhhd0y3bt1o2rQpe/bs4bbbbsPV1ZXQ0FDeffdd2zEbNmygTZs2AIwcOdL22fn8889tx/z555/06dMHLy8vXF1d6dq1K7///nuJ7qEQxVKFENctNDRUrVu3bomPj46OVgH1nnvuUWNjY9Xhw4ergDpo0CC742rXrq02bNhQDQ4OVidOnKh++OGHamhoqOru7q5+9dVXaq1atdS3335bffvtt1UvLy+1Xr16qsVisbuOs7OzWr9+ffWhhx5Sp0+frt5xxx0qoL722mt216pZs6b6xBNPqNOnT1cnT56stm3bVgXUn376ye44QG3cuLHq7++vTpo0SY2NjVX/+eef6zpH7dq11ejoaNvzl19+WVUURR0zZow6e/Zs9YMPPlDvv/9+9e2337Yds3btWtXJyUlt0KCB+u6776qTJk1S/fz8VB8fHzU+Pt523Ouvv64CasuWLdXBgwerM2bMUEePHq0C6gsvvHDN782cOXNUQO3YsaP60Ucfqc8884zq7e2t1q1bV+3atavtOIvFovbq1Ut1dXVVn3nmGfWTTz5Rx44dqzo5OakDBw60Hbd7927VaDSqrVu3VqdOnarOnDlTff7559UuXbpcM5Y2bdqoI0aMUD/88EN12rRpaq9evVRAnT59ut1xXbt2tYstNTVVrVu3ruri4qKOHz9enTJlitq2bVu1RYsWKqCuX7/eduzcuXNVQG3Tpo364YcfquPHj1ddXFzU8PBw9dKlS7bjoqOjVZPJpEZERKjR0dHqzJkz1S+//NK2r3bt2rZrf/zxxyqg3nXXXeq8efPUefPmqTt27LAd6+zsrDZp0kQdNWqU+vHHH6t33323CqgzZsywXS8+Pl4F1KioKDUyMlKdPHmy+uqrr6pGo1Ft3769+vLLL9u+R0899ZSqKIo6cuRIu/vy5ZdfqoqiqH369FGnTZumvvPOO2p4eLjq7e1t95np2LGj6uXlpb766qvqnDlz1Lfeeku97bbb1F9//fWq35/Vq1erOp1Obdq0qTp58mT1lVdeUb28vNQmTZrY7keu0aNHq05OTuqYMWPUmTNnqi+++KLq5uamtmnTRs3Ozq7Q6yQkJKg+Pj5qgwYN1Pfee0+dPXu2+sorr6iNGze2O9eIESNUQO3bt686ZcoU9f3331cHDhyoTps2zXbMm2++qSqKog4ZMkSdMWOG7eey4Oena9euakhIiBoWFqY+/fTT6owZM9Tbb79dBdQVK1aoqqqqZ8+eVd944w0VUB955BHbZ+fw4cOqqqrqunXrVKPRqHbo0EH94IMP1A8//FBt3ry5ajQa1T///POq91CIq5HkV4jrlJSUpAJ2Cc/VxMXFqYA6evRou/bnn39eBdRffvnF1la7dm0VUDdv3mxrW716tQqoLi4u6rFjx2ztn3zySaHEJjfJfvLJJ21tVqtV7d+/v2o0GtXz58/b2tPT0+3iyc7OVps2barefvvtdu2AqtPp1H///bfQeyvpOQomvy1atFD79+9f6Hz5RUVFqQEBAerFixdtbTt27FB1Op06fPhwW1tu8jtq1Ci71991111qjRo1rnqN7OxsNSAgQI2KilKzsrJs7bNmzVIBuwRz3rx5qk6nUzdt2mR3jpkzZ6qA+vvvv6uqqqoffvihCtjd65IqeD9VVVV79+5d6BetgsnvBx98oALqkiVLbG0ZGRlqo0aN7D4jue+3adOmakZGhu3Yn376SQXUCRMm2NpyP0vjx48vFFP+5FdVVfX8+fMqoL7++utFHguob7zxhl17y5Yt1VatWtme5ya//v7+6uXLl23tL730kgqoLVq0UM1ms639/vvvV41Go5qZmamqqqqmpKSo3t7e6pgxY+yuc/bsWdXLy8vWfunSJRVQ33vvvUKxXktUVJQaHBxsF9+aNWtUwO5+bNq0SQXUr7/+2u71q1atKrK9vK+zePFiFVC3bt1a7DV/+eUXFVCfeuqpQvusVquqqqp69OhRVa/Xq//3f/9nt3/Xrl2qk5OTXXvXrl1VwPYLk6qqalZWlhoUFKTefffdtratW7eqgDp37txC16xfv77au3dv2/VVVfsZqVOnjtqzZ89i34sQ1yJlD0Jcp+TkZAA8PDxKdPyKFSsAGDdunF37c889B1CoNjgyMpIOHTrYnrdr1w6A22+/nVq1ahVqP3LkSKFrjh071vY4t2whOzubn3/+2dbu4uJie3zp0iWSkpK49dZb2b59e6Hzde3alcjIyELt13OO/Ly9vfn33385ePBgkfvPnDlDXFwcI0aMwNfX19bevHlzevbsabun+T322GN2z2+99VYuXrxo+34VZdu2bZw7d47HHnsMo9Foax8xYgReXl52x/7www80btyYRo0aceHCBdt2++23A7B+/XrbewNYunSp3aCwksh/P5OSkrhw4QJdu3blyJEjJCUlFfu6VatWERoayoABA2xtzs7OjBkzpsj3+8QTT9jVbPfv359GjRoVWaf++OOPX9d7KE5R35+iPrv33nuv3b3P/Zw/+OCDODk52bVnZ2fbyjXWrl3L5cuXuf/+++2+P3q9nnbt2tm+Py4uLhiNRjZs2FDiEgTI+0xGR0fbxdezZ89CPxs//PADXl5e9OzZ0y6WVq1a4e7ubouloq6T+5n86aefMJvNRV534cKFKIrC66+/XmifoiiAVnZltVq577777K4XFBRE/fr1C70vd3d3HnzwQdtzo9FI27Zti/y+FxQXF8fBgwcZNmwYFy9etF0rLS2N7t27s3Hjxuv++RIilwx4E+I6eXp6ApCSklKi448dO4ZOp6NevXp27UFBQXh7e3Ps2DG79vwJLmD7DzAsLKzI9oL/get0OurWrWvX1qBBAwC7msaffvqJN998k7i4OLua1dz/6PKrU6dOke/tes6R3xtvvMHAgQNp0KABTZs2pU+fPjz00EM0b94cwHZPGjZsWOi1jRs3ZvXq1bbBV7kK3jcfHx9Auz+537OCcq9Tv359u3aDwVDoHh48eJC9e/fa6lsLOnfuHABDhgxhzpw5jB49mvHjx9O9e3cGDx7MPffcc80ZL37//Xdef/11tmzZUqheOSkpqVBCnv99REREFLrvBT9zV7uvjRo14rfffrNrc3JyombNmleNuSRy60fz8/HxKTL5LO3nP/cXqdxfRgrK/QyYTCbeeecdnnvuOQIDA2nfvj133HEHw4cPJygoqNj3UNxnBbT7mf8XvoMHD5KUlERAQECR58r9rFTUdbp27crdd9/NpEmT+PDDD+nWrRuDBg1i2LBhtsGohw8fJiQkxO6XzYIOHjyIqqpFxgYUGghZs2bNQp9JHx8fdu7cWew18l8LIDo6uthjkpKSbD/nQlwPSX6FuE6enp6EhISwe/fu63rdtRLCXHq9/rra1QID2Upi06ZNDBgwgC5dujBjxgyCg4MxGAzMnTuXb775ptDx+XskS3uO/Lp06cLhw4dZunQpa9asYc6cOXz44YfMnDmT0aNHX/f7gbK9P0WxWq00a9aMyZMnF7k/NzlzcXFh48aNrF+/nuXLl7Nq1Srmz5/P7bffzpo1a4qN8/Dhw3Tv3p1GjRoxefJkwsLCMBqNrFixgg8//NAhvVwmk6lMpqgr7j1fz7HX+v7m3p958+YVmcTm7zV+5plnuPPOO1myZAmrV6/mtdde43//+x+//PILLVu2LHGsxbFarQQEBPD1118Xub+4X6DK6zqKorBgwQL++OMPfvzxR1avXs2oUaP44IMP+OOPP0q8CInVakVRFFauXFnk96PgeW7kZzL3+/nee+8VOwVadV88RZQfSX6FKIU77riDWbNmsWXLFrsShaLUrl0bq9XKwYMHady4sa09ISGBy5cvU7t27TKNzWq1cuTIEVtvL8CBAwcAbCP0Fy5ciLOzM6tXr7abhmzu3Lklvs6NnsPX15eRI0cycuRIUlNT6dKlCxMnTmT06NG2e7J///5Cr9u3bx9+fn52vb6llXudgwcP2vUYms1m4uPjadGiha0tIiKCHTt20L1792v+IqPT6ejevTvdu3dn8uTJvPXWW7zyyiusX7+eHj16FPmaH3/8kaysLJYtW2bX+3m1P5Hnfx979uxBVVW72A4dOlTk+92/f3+hHtL9+/eX+rNY0l/sylNERAQAAQEBxd7jgsc/99xzPPfccxw8eJCoqCg++OADvvrqqyKPz/9ZKajg5zQiIoKff/6ZTp06FfmL49WU53Xat29P+/bt+b//+z+++eYbHnjgAb777jtGjx5NREQEq1evJjExsdje34iICFRVpU6dOnb/vtyI4j47ud9PT0/PEn0/hbgeUvMrRCm88MILuLm5MXr0aBISEgrtP3z4MFOnTgWgX79+AEyZMsXumNwexP79+5d5fNOnT7c9VlWV6dOnYzAY6N69O6D1yCiKUmiqqSVLlpT4GjdyjosXL9o9d3d3p169erbSieDgYKKiovjiiy+4fPmy7bjdu3ezZs0a2z29Ua1bt8bf35+ZM2eSnZ1ta//888/trgtw3333cerUKWbPnl3oPBkZGaSlpQEUOf1Wbs9VwSnR8svtJcvfK5aUlFSiXyZ69+7NqVOnWLZsma0tMzOzUKytW7cmICCAmTNn2sWycuVK9u7dW+rPoqurK0Che1aRevfujaenJ2+99VaRda3nz58HtAU5MjMz7fZFRETg4eFx1e9P/s9k/vrrtWvXsmfPHrtj77vvPiwWC//9738LnScnJ+eq96k8rnPp0qVCva0FP5N33303qqraFivJL/e1gwcPRq/XM2nSpELnU1W10M91SeT+ElvwnrRq1YqIiAjef/99UlNTC70u9/spRGlIz68QpRAREcE333zDkCFDaNy4sd0Kb5s3b+aHH36wzWvbokULoqOjmTVrFpcvX6Zr16789ddffPHFFwwaNIjbbrutTGNzdnZm1apVREdH065dO1auXMny5ct5+eWXbX8G7d+/P5MnT6ZPnz4MGzaMc+fOERsbS7169UpUj3ej54iMjKRbt260atUKX19ftm3bxoIFC+wG6r333nv07duXDh068PDDD5ORkcG0adPw8vIqNIdsaRkMBt58800effRRbr/9doYMGUJ8fDxz584tVPP70EMP8f333/PYY4+xfv16OnXqhMViYd++fXz//fesXr2a1q1b88Ybb7Bx40b69+9P7dq1OXfuHDNmzKBmzZp07ty52Fh69eqF0Wjkzjvv5NFHHyU1NZXZs2cTEBDAmTNnrvo+Hn30UaZPn87999/P008/TXBwMF9//bVtUFtu75rBYOCdd95h5MiRdO3alfvvv5+EhASmTp1KeHg4zz77bKnuo4uLC5GRkcyfP58GDRrg6+tL06ZNadq0aanOVxqenp58/PHHPPTQQ9xyyy0MHToUf39/jh8/zvLly+nUqRPTp0/nwIEDdO/enfvuu4/IyEicnJxYvHgxCQkJDB069KrX+N///kf//v3p3Lkzo0aNIjExkWnTptGkSRO7BK1r1648+uij/O9//yMuLo5evXphMBg4ePAgP/zwA1OnTuWee+6psOt88cUXzJgxg7vuuouIiAhSUlKYPXs2np6etl8kb7vtNh566CE++ugjDh48SJ8+fbBarWzatInbbruNsWPHEhERwZtvvslLL73E0aNHGTRoEB4eHsTHx7N48WIeeeQRnn/++ev6vkVERODt7c3MmTPx8PDAzc2Ndu3aUadOHebMmUPfvn1p0qQJI0eOJDQ0lFOnTrF+/Xo8PT358ccfr+taQtg4YooJIaqLAwcOqGPGjFHDw8NVo9Goenh4qJ06dVKnTZtmm4JJVVXVbDarkyZNUuvUqaMaDAY1LCxMfemll+yOUVVtSrCipgAD1JiYGLu23Kmh8k/ZFB0drbq5uamHDx+2zUkbGBiovv7663bzAauqqn766adq/fr1VZPJpDZq1EidO3eubdqwa137es9RcKqzN998U23btq3q7e2turi4qI0aNVL/7//+r9D8pz///LPaqVMn1cXFRfX09FTvvPNOdc+ePXbH5F6v4NRiufPZ5p/ftTgzZsxQ69Spo5pMJrV169bqxo0bC00npqraVGHvvPOO2qRJE9VkMqk+Pj5qq1at1EmTJqlJSUmqqmpzkw4cOFANCQlRjUajGhISot5///3qgQMHrhnHsmXL1ObNm6vOzs5qeHi4+s4776ifffZZofdRVGxHjhxR+/fvr7q4uKj+/v7qc889py5cuFAF1D/++MPu2Pnz56stW7ZUTSaT6uvrqz7wwAPqyZMn7Y7J/SwVpeBUZ6qqqps3b1ZbtWqlGo1Gu2nPijtPwc9JUZ9nVVXV9evXq4D6ww8/2LXnfn8LTt+1fv16tXfv3qqXl5fq7OysRkREqCNGjFC3bdumqqqqXrhwQY2JiVEbNWqkurm5qV5eXmq7du3U77//vsj3WtDChQvVxo0bqyaTSY2MjFQXLVpU5P1QVW3KvFatWqkuLi6qh4eH2qxZM/WFF15QT58+XaHX2b59u3r//fertWrVUk0mkxoQEKDecccdtnuSKycnR33vvffURo0aqUajUfX391f79u2r/v3334Vi69y5s+rm5qa6ubmpjRo1UmNiYtT9+/fbjunatavapEmTQrEW9R6WLl2qRkZGqk5OToWmPfvnn3/UwYMHqzVq1FBNJpNau3Zt9b777lPXrVt3zXsoRHEUVS2j0SBCCIcbMWIECxYsKPLPhOLmM2XKFJ599llOnjxJaGioo8MRQohKQWp+hRCiGsjIyLB7npmZySeffEL9+vUl8RVCiHyk5lcIIaqBwYMHU6tWLaKiokhKSuKrr75i3759xU6DJYQQNytJfoUQohro3bs3c+bM4euvv8ZisRAZGcl3333HkCFDHB2aEEJUKlLzK4QQQgghbhpS8yuEEEIIIW4akvwKIYQQQoibhtT8XoPVauX06dN4eHhUiiU8hRBCCCGEPVVVSUlJISQkBJ3u6n27kvxew+nTpwkLC3N0GEIIIYQQ4hpOnDhBzZo1r3qMJL/X4OHhAWg309PTs9yvZzabWbNmjW2ZSpFH7k3x5N4UT+5N8eTeFE3uS/Hk3hRP7k3xKuLeJCcnExYWZsvbrkaS32vILXXw9PSssOTX1dUVT09P+eEpQO5N8eTeFE/uTfHk3hRN7kvx5N4UT+5N8Sry3pSkRFUGvAkhhBBCiJuGJL9CCCGEEOKmIcmvEEIIIYS4aUjyK4QQQgghbhqS/AohhBBCiJvGTZH8/vTTTzRs2JD69eszZ84cR4cjhBBCCCEcpNpPdZaTk8O4ceNYv349Xl5etGrVirvuuosaNWo4OjQhhBBCCFHBqn3P719//UWTJk0IDQ3F3d2dvn37smbNGkeHJYQQQgghHKDSJ78bN27kzjvvJCQkBEVRWLJkSaFjYmNjCQ8Px9nZmXbt2vHXX3/Z9p0+fZrQ0FDb89DQUE6dOlURoQshhBBCiEqm0pc9pKWl0aJFC0aNGsXgwYML7Z8/fz7jxo1j5syZtGvXjilTptC7d2/2799PQEDAdV8vKyuLrKws2/Pk5GRAW53EbDaX/o2UUO41KuJaVY3cm+LJvSme3Jviyb0pmtyX4sm9KZ7cm+JVxL25nnMrqqqq5RZJGVMUhcWLFzNo0CBbW7t27WjTpg3Tp08HwGq1EhYWxpNPPsn48ePZvHkz7733HosXLwbgmWeeoW3btgwbNqzIa0ycOJFJkyYVav/mm29wdXUt+zclhBBCCCFuSHp6OsOGDSMpKQlPT8+rHlulk9/s7GxcXV1ZsGCBXUIcHR3N5cuXWbp0KTk5OTRu3JgNGzbYBrxt3ry52AFvRfX8hoWFceHChWvezLJgNptZu3YtPXv2lLXBC5B7Uzy5N8WTe1M8uTdFk/tSPLk3xZN7U7yKuDfJycn4+fmVKPmt9GUPV3PhwgUsFguBgYF27YGBgezbtw8AJycnPvjgA2677TasVisvvPDCVWd6MJlMmEymQu0Gg6FCP8wVfb2qRO5N8eTeFE/uTfHk3hRN7kvx5N4UT+5N8crz3lzPeat08ltSAwYMYMCAAY4OQwghhBBCOFiln+3havz8/NDr9SQkJNi1JyQkEBQUdEPnjo2NJTIykjZt2tzQeYQQQgghROVRpZNfo9FIq1atWLduna3NarWybt06OnTocEPnjomJYc+ePWzduvVGwxRCCCGEEJVEpS97SE1N5dChQ7bn8fHxxMXF4evrS61atRg3bhzR0dG0bt2atm3bMmXKFNLS0hg5cqQDoy4jmclw8SCE3AKK4uhohBBCCCGqvEqf/G7bto3bbrvN9nzcuHGANqPD559/zpAhQzh//jwTJkzg7NmzREVFsWrVqkKD4Kqkz/vB2V1w/3fQsK+joxFCCCGEqPIqffLbrVs3rjUb29ixYxk7dmyZXjc2NpbY2FgsFkuZnve6nN2lfY37WpJfIYQQQogyUKVrfstTpar5tchqMUIIIYQQZUGS36rAVP6LawghhBBC3AwqfdnDzeafpXPI/OEbfj66kb46J7DmQI/XHR2WEEIIIUS1IMlvJZN8YA/Nd1xgr9NWeH89ZCWDW4CjwxJCCCGEqBYk+S2Gowa81ejYhW+P/cL5WmYGBzev0GsLIYQQQlR3UvNbDEcNeIto15slHfX8VjOVC2e2wxd3wry7KjQGIYQQQojqSnp+KxkXJxd8db5ctF7kwOYP8IvfCE7OoKqy0IUQQgghxA2Snt9KKNwcQO0ElYOHftUacjLBnO7YoIQQQgghqgHp+a2Exnwej+85C6sHmsAlRWtMuwBGN8cGJoQQQghRxUnPbzFiY2OJjIykTZs2FX7tbB9vklzhgprvd5P0CxUehxBCCCFEdSPJbzEcucLb8YeGMeZpJ36KNJCVW+abnljhcQghhBBCVDeS/FZCXk4+eCpGLIrCYYNBa0yTnl8hhBBCiBslyW8lpCgKDZ3cAdhvNIJrDW2lNyGEEEIIcUNkwFslpE9JYciPqXTJtLB/RGe463tHhySEEEIIUS1Iz28lpOp01NqRTrv9KoeQuX2FEEIIIcqK9PwWw1HLGwNYXV3RPTqcrUo890TeUeHXF0IIIYSoriT5LUZMTAwxMTEkJyfj5eVVsRdXFOqOfZ6GBgOc/Bs+vwM8Q2HwJxUbhxBCCCFENSPJbyWl+/sz0OnAPRCObgLfuo4OSQghhBCiypPkt7Ja9y6XzycR3yUGnclIi7SLjo5ICCGEEKLKkwFvldSlf82cWeXPtq9+YJa3F2QlgcXs6LCEEEIIIao0SX4rIZ01G6NLFqrJit7kTA2LVduRLr2/QgghhBA3QsoeKiGDJQOPmpk0DjtL5IREeL+BtiPtAngEOTY4IYQQQogqTHp+KyEnSzqKAorRA3R6cPPTdqTLEsdCCCGEEDdCkt9ixMbGEhkZSZs2bSr82gZLhvbA2RMA1d2fDFc/yMmu8FiEEEIIIaoTSX6LERMTw549e9i6dWuFX9vJqiW/5/8xsmPoQMYkJPLcLb2hQa8Kj0UIIYQQojqR5LcSuuwSTs6DS8hUGmKMO4D76ST2XNyDqqqODk0IIYQQokqTAW+VUI6TG2rtzviMccL5rgT+PfFfLmZe5Fz6OQLdAh0dnhBCCCFElSU9v5WY+6234n/XPXgEawnvvz+/5OCIhBBCCCGqNkl+KyHf1P3otn0GJ/8GoImLlvzuubTfkWEJIYQQQlR5kvxWQsGX/0a/+gXU3YvJ3L+ftqfcAfjXkubgyIQQQgghqjap+a2EDFdme8jJdCJ+4CAi9DqU5xX26HJQVRVFURwcoRBCCCFE1SQ9v5WQkyVd+xoYjN7fD1P9CDyyVBJ1CgmpZxwcnRBCCCFE1SXJbyWUu8iF4upNg02biFiwgBBdDgA7jq1zZGhCCCGEEFWaJL/FcOwKb1rPLyYP7auTkRYW7eHOvQsg9Txs/xIOrK7w2IQQQgghqjJJfovh0BXeCixvDNCi4WAAdpgMsPM7WPYkbImt8NiEEEIIIaoySX4robyeX0+SV6/h2IiRNN6hJcJ7ko6QXa+ntv/Y75Bx2TFBCiGEEEJUQZL8VkJb64wl554vwbcOlkuXSP/jD0wHTuBj8sFsNXNQbwG/hmDNgUM/OzpcIYQQQogqQ6Y6q4QS3RuiNuwHBgNuHdoT8u47GOtGMC0wh1D3UPxc/KBRP/htP+xbDs3ucXTIQgghhBBVgiS/lZyxdm2MtWsD0CL/job94LcPtZ7fnGxwMjokPiGEEEKIqkTKHiqbjEuEn1+Hsnfp1Y8LbQ1uAZCVDMd+q5jYhBBCCCGqOEl+K5vLx2lx8gv0a162NWUdOkTK+vWYExOZuWMmj6x5hISM89CwDyg6SNhjf474jbDkCbh0rIKDF0IIIYSo3KTsoZJRspK1B6a8ac5OPf8fsvbtI2zWJ6xLWse+xH3sOL+DXl1fhO6vg5ufdqDVCr99AOvfAtUKTs5wx2QHvAshhBBCiMpJkt/KJisFANXkiXKlyblhQxSdDhQdDzZ+kIycDJr5NQP34LzXqSp8NRiOrM9rO7hGa1cUhBBCCCGEJL+VT27Pb74FLkLeedv2eGBxr0v4F45t1np7e/8frH4Vkk5o7UFNyy9eIYQQQogqRJLfSqaosocScQ+AbuOhQR8IjISjv0NOFqiWsg9SCCGEEKKKkuS3ssnMTX49ij3kePJx/jjzBy0DWlLfp77W6B4At47LO+jeueUYpBBCCCFE1STJbyXzb/xJmgOrD2fy49d/42p0IiwjkTYLZ2JQIOmtj5h/7EP+OPczIxo/wjOt66HXSU2vEEIIIURJSPJbjNjYWGJjY7FYKrZsYI1zb6Zn+3PiQgB7z58FoEZGEr3278Si6BjyxV/ofTxwDoY529YybVFdPJyd8HIx4OViwNvVcOWxES8XA7WUs3gZQfFviLeLAc98x7ibnFBkMJwQQgghbiKS/BYjJiaGmJgYkpOT8fLyqrDrdu/UiaQM6Na0GWarQmpWDpdSMljv9gSnTV408/EiISuSNBajdzkBipmUTEjJzOHkpQy7cz2sX84ww9f8ZGlHjPnpQtfS6xRb0uyZ+zVfIp3bprXntmn7PZwN0uMshBBCiCpHkt9KpmmoJ8f9Vfq1qonBYMjbMaCZ7aGqqnT/YRbnM84ze4w/dT1akJRhJindTFKGmcvp2SRl5OB2IQ32fc3tTrtoH+zOxUy4fOW4bIsVi1UlMS2bxLTsUsXqYXLKS5pdnAolyl6uhZNmzyv7nQ36G71VQgghhBDXTZLfKkhRFFoHtWZl/EoOJMfRs26nog+0RsD7L+GafoHvLj8AQc0gsiVqWFsy691BUmYOlzOybUlzUoaZ5Mwc7euVTWvLtz8jhwyzVgqSkpVDSlYOpy5nFH39qzA56YroXXay74XOn0i7GHA1QGaOlvwLIYQQQpSGJL9VhDkhgcx/96D39sb1lpa0CWrDyviVbD27tfgX6XTaDBDr3oDsFDi+GY5vRtm/HJcmg3AxORHk5QwH1oB/LfBroL3mGrJyLCRn5NiSYluSnC95TkrPS5ptyXO6mZSsHFQVsnKsnEvJ4lxK1nXeCSde2ra22JIMz4K9zwUSbA9nJwx6WdVbCCGEuFlJ8ltFJP+0nHPvvYdnv7643tKStkFtAdh5fieZOZk4OzkX/cIOMdD2UbhwAM7EwcltecshA1gtsPBhbXENFx8Ia6dttTpASEswFD6vyUmPv4cefw/Tdb8Pq1UlJSvHLmHOnyAnZ+Tk64W273FOysjGbFGxqnA53czldPN1Xx/AzajP61kulCgXKN9wtU+mnQ06GSQohBBCVGGS/FYRpnoRmCIbYwitCUAtj1oEuARwLuMcO8/vpG1w2+JfrHfSFr4IjISoYfb7Mi5BcAstKc64BAdWaRuA3gitR0Hfd8rsfejyDbILu87XZmdns/SnlXToejvpOdgS57wkOqdAIm3fI52alQNAWraFtGwLp5Myrzt+o15n62G+atJccCChiwEPkxM6GSQohBBCOJQkv1WEe9euuHftanueW/e7In4FWxO2Xj35vRo3PxjxE1jMcHYnHP9D2078CakJ4Oydd2zaBZjbF8LaQs222le/hiUqlSgLiqJg1EOgp7P9YMASyrFYSc7MKbaWOX+Pc+Ge6RwsVpVsi5ULqdlcSL3+QYKKYj9IsPDgQCe7HumCibTRSco1hBBCiBslyW8V1iaoDSviV/DXmb+IiYq5sZPpDRDaSts6xICqwqV4cHLJO+b4H1r5xIUD8M9XWpvJU3tNWFuIHKT1LldSTnodvm5GfN2M1/1aVVVJy7bYJcQFk+OCCXP+BDvTbEVV0Y4rYlq6knA26OySZs8rgwQ9XQy4G/WcOq2Q9vdJfNyc7XqmPV2cZGo6IYQQ4gpJfquw9sHtAdhxfgcp2Sl4GItfEvm6KQr41rVvq3Mr3P8dnPgLTm6FU39rtcJH1mubT5285PfiYTi6Sesh9m9UYb3D5UVRFNxNTribnAj1drn2CwrIHSRYsCzDPpHOKaJHOm+QYKbZSqY5i4Tk4gYJ6ll6bE+xMbibnGzJsqctgXYqlEh7FbFPSjaEEEJUF5L8ViEJb79Dyrp1BDw3Ds8+fajpUZM6XnWIT4pny+kt9ArvVb4BOHtBw77aBmDJgXP/XkmGt0Gt9nnHHlgFq1/WHufvHa7ZFmq20gbX3URuZJCgxaqSmpljlxSnZNony5fTsth7+BgeNQJIzbLYkunkTDPp2drUdKlZWt1zaWqdFUVLnotKjO1m2yiQSOcm025GvQwUFEIIUSlI8luFWC5fxnziBNlHj9raBkYM5HTqaWp61Kz4gPRO2mC54BbQdoz9PvdACL+1cO9wrjG/aAkxQFYKGNyqfO9wedHrFG3WCdfiBwmazWZWrIinX79bCtVDmy1WUgrUOucmxskFZtrIa8s7PitHK9lIycwhJTMHuP6SDZ1Cod7mIhPp/Pvy7XcxSPIshBCibEjyW4X4jojG+567MUZE2NoebvawAyO6imb3aFvB3uGTf8HlExCQrzZ43Ruw47t8vcNttMeuvo6Lvxox3ECtM0Cm2aIlz/kS47xZNAonzUkZZlLyJdVlMT2dk06xW4K7yLKNAvu8ruxzlX/lhBBC5CP/LVQhzo0aOTqE61dU73DGZTDkq5s9s7Po3uEa9bRE+M6PwKl0iZu4cc4GPc6G0pVsqKpKVo71Kr3OxSfS+WfZyLnBpbidFD3/3bUhX9JcYHaNIuqf8++TmTaEEKL6kOS3Gsix5rDrwi5yrDm0CWrj6HCuzcXb/vmI5XBuj9YrfPJv7evFQ9qWk2WX+DY+/T26X7ZBrXZaYuwRWLGxi+uiKIoteQ7wLGYhlqtQVZX0bItdYpy7emD+8ozkAjXQ+Y9XVchRlVJPUQfaTBu5ifHVep+LHCwoqwoKIUSlIslvFaKqKqm//or5+Am877sXnbOWTCw5tIRJWyYR5R/FvH7zHBxlKeidILi5trUZrbWlJ+bVC+dSVcIvrEef8BNsudLmVQvC2miJcK322qp0otpQFAU3kxNuJieCva7/9VaryuW0TJauXEOr9reSnqMWqmkuqjc6dyaOlCsLo+TOtHH9y3Fr3Iz6IpNlD2cnW5uHs6HAYyfbMSYnfamuK4QQojBJfquY0/95AWtKCm4d2mOqXx+ATiGd8DR6EuoRilW1olOqQS+Tqy/U72nfZs3h39ChtPDNRnd6u9ZbnHRc23Yv1AbYjfgp7/i9P0FAY23KNhksdVPS6RQ8nJ3wNUHjYI/rXhyl4EwbtgS5mMGBBRPptCszbeSuKnimFDNtAJicdHbJskf+nmfb4ytJs0vuMXmPXWW2DSGEsJHktwpRFAX3rl1Rs7Lskrlg92A2DtmIXlfNe4f0Bo7X6ErTfv3QGQyQmQynt2tzDhecai09EeY/oD128clbwCO0tfbVrYZj3oOoUkoy08bV5J9pw650I990dSmZeQl0/oGFKZk5tp7nrBwr51OyOF/Knmf9lV8CbInzla/uJj0Xz+o49MshvN2cCyXQuT3R7iYnnKR0QwhRTUjyW8WEvv9eke3VPvEtirMn1O2mbQWlX9TmFD6zAzIuwaGftS1Xp6eh5xvaY6sFLNn2g/CEKAM3OtNG/p7n5ExzvkQ6x5Y8a+35H+fYHZtjVbFY1avMtqHj1zNHrhlLbulGXqlGycs2PJ0NOBtuwn+jhBCV0k2R/N51111s2LCB7t27s2DBAkeHU25UVWVf4j7qetfFpL/+kfnVil99GL0WcrIhYbdWP3zqb62H+OJB+9Xrzu6EOT0gsKnWK1zzSu9wjfoy97BwqPw9z6WhqioZuVPV2QYD5vUyX07L4p9/9xMQWovUbOuVdvtjMswFSzdK916Mel2+koy8sg2Pa5Rt5CbSbkZZZVAIUTZuiuT36aefZtSoUXzxxReODqXMqKpaqIbv4TUPs/XsVqbeNpXba91+1ddnnzhB1oED6H19cW1ZjQeJORkh9BZtI99Ua/l7ys/sBGsOnInTtm2fau0mT20AXdcXILxzxcYtRBlQFAVXoxOuRicCi5htw2w2syJ1L/36RRZbD12wdKPoxzm2sg775Dlvee5si/WGZtzQXVllsHDSbJ9AF9cTLbNuCCFy3RTJb7du3diwYYOjwygTmfsPcPKpJ1H0TkSsWG63r5FvI7ae3cqaY2vskt+0zZtJWb8Bvycex8lHW1Y4Y8dOTj//PM5RLajz3XcAXMy4yC+P3oWabWbDrV4cDdZh0psw6U24Gdzwd/UnwCWAYPdg6njVoa5XXfxd/KveQJqCU63dMhwibtN6hXN7iE/HaTNNxP8Ktz6Xd+yBNRD3VV7tcEgUGN0qMHghKtaNlm5YrSqp2Tm2RPmqiXQRCXRyZt5CKVqSXbpVBgFcjfprlm14ODvhZlDYf0kh+PhlfD2cbT3RzgZd1fv3TghRiMOT340bN/Lee+/x999/c+bMGRYvXsygQYPsjomNjeW9997j7NmztGjRgmnTptG2bVvHBOxgem9vzMeOo7i4YM3MtE13BtCrdi/m7ZnH+uPryczJxNlJ25fwzrtk7d+PS9MmeA0cCMBvTvHoazlj9UqjzpXXexg9CNx3Hv9k+L5ZCifctX/kaySp1LyosjJcwVrgz44+Jh/+d+v/6BTaqfzffHlRFPCupW1NB2ttlhxtNolTf1/pNb4i/lfYs1TbABS9tlpd6C1auUTjAYWTayFuYjqdYhs8F+p9/XX1toVSCtY1F0igCw4WzJ9I5866kZ5tIT3bQkJySQYO6pm57y+7FoNesfUi5x846JHvq+eVfbltBY+R2mchHM/hyW9aWhotWrRg1KhRDB48uND++fPnM27cOGbOnEm7du2YMmUKvXv3Zv/+/QQEBAAQFRVFTk5OodeuWbOGkJCQcn8PFckQGEDo1Km4dWhvl/gCNPdvTpBbEJcuneH307/TvVZ3ALwGDSLr0CH0tWvZjnWObMwzD+RQz9uJflfajHojvDKWtL3HefH+ARhc3Mi2ZKObtwi3+UtJbFuf38Z24mTqSY4mHeVEygkuZV0i0DVvoYkFBxaw4MACBtcfzH0N7yv3+1Fu8s89nF+ze8HNL6+XOOUMJOzStu1fQN3b8pLfw79A2gUIuUWrMZb6YSGum91CKR6lO0fOldKNlHyDB6+WSCdlZHPqXCIYXUnN0tqsKpgtN7bSIGi1zx7XSJCLasvtqZZ5n4W4cQ5Pfvv27Uvfvn2L3T958mTGjBnDyJEjAZg5cybLly/ns88+Y/z48QDExcWVWTxZWVlkZeX1CiQna4ssmM1mzOaiRkqXrdxrXO1aLrffhhWwFnHMkNQmNJtxki3ZX9LlkS4AxPduyvt+q+ih/E20uSkAHQI7MLnLZFr6t7S7Vod+j2DLhq+45LODSz4+NLpzOG1baj3HqtlM0q/rOd4sgDC3MNs5/jrzF/9e/JdOwZ1sbWnmNDad2kTHkI54Gj1Ld2Mo2b0pd/5NtK3dlefJZ1BO/41yejvKxYNYXAPhSnz6P2ehO7ASANXkiRrcAjW4JWpwFGpIS/CsWWbzD1eKe1NJyb0p3s10b9yNCu5GA8Ge1x48aDabWbt2LT17tsdgMKCqKmnZlisJdN40dLkJtW3LMtsep+bbn5yZQ1p2Xu3zxbRsLt5IAu2kw8PklJdEm5xwz58wX3me+zgv2b6STJucSr1k9830mblecm+KVxH35nrOraiqqpZbJNdJURS7sofs7GxcXV1ZsGCBXSlEdHQ0ly9fZunSpSU+94YNG5g+ffo1Z3uYOHEikyZNKtT+zTff4OrqWuLrOYr7/M8J2b6PuAgdh6KH8I85joM5BwHwVDwZ5zkOJ6UUv/NYLKCq4KS91n3HTkK++YaMsDBOxDxhS+IuWy9zNOcoNfU18dP7AfBv9r98m/4tOnTUc6pHM2MzIg2RmJTqPSNFgzNLCEzZiVf6MfSq/Q+lRTGwvMUnqFe+F57px8gyeJFl8HZApEKI8mZVIcsCGRbIzLny1aKQkQOZV9ozchTtsa1NsR2bYYEsS9nVGxsUFWcncNGDsx6cnVTbYxcncNHb77e1XXnsrIdS5s9ClIv09HSGDRtGUlISnp5X72hzeM/v1Vy4cAGLxUJgYKBde2BgIPv27SvxeXr06MGOHTtIS0ujZs2a/PDDD3To0KHIY1966SXGjRtne56cnExYWBi9evW65s0sC3k9Dj2vuhpV+pY/SJo/H7du3fAcNNDWbu3Rg49euJ1vb0nDnPEDAAoKAyMG8kTzJ/Bz8SuTOJMzM7ng7U3IHf1p1r+/rd2SkoLew/5vk8bjRv7a9ReHkw5zIOcAB3IO8JP+JzqHdKZP7T50Culkq0++mpLem8pD60K3WnOwnt+HcvoflDNx6M78g2J0o2//AbYjnWbdinJ+L6pHsNYznNtDHBylrXZ3DVXv3lQcuTfFk3tTtMp6XyxWlbSsAr3OVx6nZubO/5y/LfdxXo90bv2zWVUwmyHF9nv59SfWzoa8Hmh3Zyc8TIYieqNzn+ftc8/XI12dZuCorJ+byqAi7k3uX+pLolInv2Xl559/vvZBV5hMJkymwj2SBoOhQj/M17pezoH9pK1bh5qaiu/gu1D0+twX4vnIKMxx0wlwDWBgxEAG1RtELc9axZ6rNGoMGYLPwIGoORb0V+LM3L+fo0Pvx2fIEAJefME2KrpvRF/6RvQlPimeVfGrWBG/gqPJR1l3Yh3rTqzDw+BBv7r9uKv+XUT6Rl5zNHVFfy9unAFqttS2KxRVRZf7Pi052tRrig4l5QxKyhm4Ui4BaHXEw5fkPTdngqHoXxaq3r2pOHJviif3pmiV7b4YAGeTkRtZnzL/win2ZRx5AwRzSzVSCh5z5XXpVxLoTLOVTHM250s5fR1oCXSh+uZ8tc/F1UXnP6ayrT5Y2T43lUl53pvrOW+lTn79/PzQ6/UkJCTYtSckJBAUFFSu146NjSU2NhaLxVKu1yktz759sSSn4NGrF8eio3Hv3JkaY8ag6PWMaT6GPnX6UNO9Zrmu/FZwwF3yipWoGRmYE84WmcDW8arD41GP81iLx9iXuI+VR1eyMn4lZ9POMn//fObvn09Dn4bcVf8u7qh7B14mr3KL3eHy3x+9Ezz+O2SlagtunNoOp//Rlm5OPALuAXnHWi3wXj3wDNHmIA69RRtQV6Nhxb8HIUSVc6MLp5jNZn5cvoJbb+tJpoV8SXTuqoP5a6Lz9UbnS6STM/IWT9ES6CzOlXLpbgAXg77AoMDcBDmvxjl/e/76aHeT1l7aGmhRNVXq5NdoNNKqVSvWrVtnq/m1Wq2sW7eOsWPHluu1Y2JiiImJITk5GS+vypeEGUJDCRj3LMkrVpCx7W+y9h/Aa9AgDEFB6BQdtT1rV3hM/s88jWubNhhC82bYsKSmkvjFF/hGR6N3dwe02u7GNRrTuEZjnrnlGf488yeLDy1m3bF17L+0n7f/ehudouP+RvdX+HtwKJM71O6obbkyLkF2et7zi4chOwUu7Ne2ndoczU46J7qZQtD5n4KOT1Rw4EKIm4leAW/XG+vBM1usWllGEb3QhXqlizkm02wFIMNsIcNsuaEE2uSks0+Qc8s5THmJtHuh/fY91AYqzRAqcQ0OT35TU1M5dOiQ7Xl8fDxxcXH4+vpSq1Ytxo0bR3R0NK1bt6Zt27ZMmTKFtLQ02+wPNzuPvn0Jzs5G5+qKoZx7w69FURTcO9vP93txzhwuzvyEtM1bCP/6q0Kv0Sk6OoR0oENIB5Kyklh+ZDnL45fTr07elBMbT27kUuYlutfsXu7vodJx8dG2XP4N4PmDV3qG/7nSS7wdJe08XhnHsWRcyjs2+TTMG6wtxBEcpX0NbKol2UII4UAGvQ4fNyM+pVw8BfJWHyycNOfN/Zy/rCN/D3XubBy5JRxZOVaybmAFQtD+oOes0/POno12ibF7vlk4chNl9wK90fnbpRe6/Dk8+d22bRu33Xab7XnuYLPo6Gg+//xzhgwZwvnz55kwYQJnz54lKiqKVatWFRoEd7NSFAXvAouCVCYuzVtgDA+nxsgRtrbcCUYKlkZ4mbwY1ngYwxoPszs2Ni6WPRf3cD7qPP74V0jclZp7ADTorW0Aqoo58Rjbf/qMWyIHYSt0OR0H5/dq245vrzQq4NcAgltAq2hZtlkIUWXd6OqDoM0BnZZlsSXOqVl5yXFu3XNqgaQ52TaYMC+htlhVVFWboSMjKROSMksdU3G90LnJcXG90Pnb3Yx6WY3wKhye/Hbr1o1rzbY2duzYci9zKKiy1/xWFR6334b7rZ1tU6QBpPz8M4lffEHQyy/jHBl51ddbVAs9a/ckzZzGgLoD2HJ0CwDbE7ZjtpppG9RWfsAVBTxDOevdSktsc9VqD0O/hTM74Eyc9jXlTF7JRL0eecee+hu2xGo9xMEttE1WqhNCVHNOeh1errpS10CD1kmTabZyKTWDn9as45Z2ncjMocCc0PmS6ArqhdYS5fy9zPl6oW090cWXcVTnXmiHJ7+VVWWv+a1KlHx1YaqqcmHGx2Tt3UvyypXXTH6ddE6Mbjaah5s+bLeK39TtU9l+bjuNfRsT3SSaXuG9MOhkdK0dV19o1E/bcqUk5CXDtfNN93dsC+xeqG25fOpoSXBIFDS9B7zDKipyIYSoMhRFwcWox8nDRKALtKjpVap66Py90HmLpBTobS7QQ52/Fzo3uc650gudm2DfCK0XOl8JRxG90B7OhrxFVYronXYzVr4VCSX5FRVKURTCPp7BhU8+we+xx2ztlpQUdK6ueVO2FfG6XGarmfo+9dmbuJe9iXsZv2k8U7ZP4cHGD3J3/btxN0pNa7E8AsGjFzToZd9etyvc/lpeD/Hl43ApXtv2LIHanfOS3yMbtOWdc+uI3cpm7mghhLiZlWUvtN1qg7lJc/6EOt9KhAVLPgr3QmdxIbX0gwl/HteF2j7Xnsu/IknyKyqcISiI4Ndft2s789oEso8fI+TNN6/ZG2zQGXi1/auMjRrL9we+55u933A27Szvb3ufmTtmcm+DexnWeBhBbo4dAFilBDXTtlzpifblEkFN8/btWQbbPs177hmqJcJBzSC4uTYvsbHyr4YohBDVTW4vtItRT4DHtY8vTu580PZLdufNAZ1aoGQj/8wcBXuh3U2V76+ykvwKh8s5f560zZuxpqaCruT1Rd7O3jzS/BGim0Sz/MhyPv/3c+KT4pn771zm7ZlH3zp9GdF0BA18Glz7ZMKeqy9E3KZtBdXuCJlJWmJ88RAkn9K2/cu1/S/E5yW/B1ZDxmUtKa5RX5vTWAghRKV2o/NBg9YLnZVjxajXYbHcWPlFWZP/iYohA94qjpO/PxGrVpK2eQvOjRrZ2jP3H8AUURfF6eofU5PexOD6gxlUbxCbTm7i838/Z1vCNn488iM/HvmRbmHdGNNsDM39m5f3W7k5NLtH2wAyk+HsLq13+OwuSD1rvxzzHx/DkfXaYydnCIjUEuGgK1toq+v6hUcIIUTVoCgKzgatlLGypVKS/BZDBrxVLCdfX7zu6G97nnP+PMceeghDzVDCPp6JITDgKq/W6BQdXcO60jWsK7sv7Oaz3Z/x87Gf2XBiA15GL0l+y4OzJ4R30rai1GwD5gxI2A3Zqdqqdae3X3mtN7x4NO/YvT9pPcZBLcDtRhZwFUIIIYonya+olLIOHwZAQcGphu81ji6sqV9TJnebTHxSPJ/u+pSHmz1s2xefFM+x5GN0rdlVpkkrb7e/ArwCVqs2eO7MDm0J57O7wORhv8zzmlfg0lHtsWfolTrk5ldqiVuAT8WvWiiEEKL6keRXVEpu7dsTsWI5luQUW9mDarXicujQNeeFzq+OVx3e7PymXdvMHTNZEb+ChyIf4oU2L5Rp3KIYOh3UiNC2poML77daIKQlKDpIPJJXR3xglbY/pCU8siHv+L0/gU84+DcEfeUbTCGEEKLykuRXVFpOfn44+eVNo5WyZAlhs+eQcPIUYR9OLtU5VVUl1D0UN4Mbd9S9w9aelJWEi5MLRn3pVwoSN0Cnh3s/1x5npcDZ3Vd6iHfCmZ0Q2jrv2Jws+CEarDmgN0FAY23Z5qCmeV/zLwkthBBC5CPJr6gyLJcvo+r1mJo0KfU5FEXhqVueYnSz0bga8qbjmrp9KhtPbuThZg8zuP5gTHpTWYQsSsPkoS3AkX8RjvzSL0JYO610Iiv5ynRscXn7m94D91yZis1qQdmzBPfMC1rvMtJLLIQQNztJfoshsz1UPj6jRrFNr6feA8NsbVnx8VhTUnBpfn2D2fInvmaLmc2nN5OQnsBbf77FnF1zeLjpw9zd4G5JgisjzxAYuQJUVasRPrtLG1B3djck7LKfkzgxHqfFo+kOqAcnab3EQU0hsBkENtEeO8uAViGEuJlI8lsMme2hcjL7++fVAKsqZye8Tvq2bQRNnIjPkPtKdU6D3sDSQUtZdHARc3bN4Vz6Of731//4dNenjGo2irvr342zU+VanUagDZbzraNtkQPy2vPXhGenYA25BeuZ3TjlZNjPNgHQ5YUrg/KAjEtw5FdtgJ1PHZmCTQghqilJfkWVpWZm4hQchOLiglunYqbaKiGT3sT9je7n7vp3s/jgYubsnsPZtLO8/dfbWhLcdBT3NLhHkuCqIP8MEiEtsYxcw4rlP9GvfSMMF/dBwr9Xeol3269qd2KrVksMYHDV5iS21RE3076aZOlsIYSo6iT5FVWWzsWF0HffxZyQgCEw0Naesn49LlFROPlc/6Ano97IkEZDuKv+XSw5tIQ5u+ZwJu0M72x9h093f8rIJiO5t+G9uDi5lOVbEeVN0UGNehDUGJrclddecOaQkJZwbi+Y0+HUNm3LNWgmRN2vPU6M18otgpqCd7j0EgshRBVy3cmv1Wrl119/ZdOmTRw7doz09HT8/f1p2bIlPXr0ICwsrDziFKJY+RPfrCNHOPX0M+g8PKjzw/cYQkJKdU6j3sh9De/jrnp3seTwEubsnMPptNO8t+09Ptv9GS+0eYF+dfuV1VsQjpK/l7hBL22z5GjTrSXsutJD/O+VXuJ8tcQHVsGq8dpjgxsENNJ6igObaF9DW0kvsRBCVFIlTn4zMjL44IMP+Pjjj0lMTCQqKoqQkBBcXFw4dOgQS5YsYcyYMfTq1YsJEybQvn378oxbiCKpWVkYaoVhCA7BKTj4hs9n0Bu4t8G9DIoYxLLDy5i9azanUk/JlGjVmd4J/BtoW9O7iz7G6K4tvHFuH5jT4NTf2pbr4bUQ1lZ7fGIrXNivJcX+jbRV7IQQQjhMiZPfBg0a0KFDB2bPnk3Pnj0xGApPGXTs2DG++eYbhg4dyiuvvMKYMWPKNNiKJLM9VE3OjRtTZ9EirGlpttXb1OxskteuxbNfv1Kv6GbQG7i7wd0MqDeAdcfXcXut2237FhxYQJo5jSENh0hN8M3iloe0zZIDiYe13uFzeyBhj/Y1oHHesbt+gL8+ufJEAd+6EBgJAU20r/V6gNHNIW9DCCFuRiVOftesWUPjxo2vekzt2rV56aWXeP755zl+/PgNB+dIMttD1aUzGtEZ83pmL8yZw4WPppG6bh2hk0u3OEYug85An/A+tufp5nQ+2v4Rl7Iu4ePsw4CIAVd5tah29E7aKnP+DYEiVq4D8KsPdbpoiXH6BS1ZTjwMe3/U9v/ncF7y++9iSDqVlxy7B9iXZgghhLhhJU5+r5X45mcwGIiIiChVQEKUNb2nF4qzM+63dy/zcxv0Bp5p9Qwr41fSr05eDfCRpCOEuYdhkKV3Rdsx2gaQes6+lzj5FLjlrWLIP1/DobV5z11r2NcSRw2T5ZyFEOIGlXq2h02bNvHJJ59w+PBhFixYQGhoKPPmzaNOnTp07ty5LGMU4ob4PvgAHj174hTgb2vL3LMH9E44N2xwQ+c26AwMrj+YwfXzev2yLdk8tvYxdIqOR5s/yp0Rd+Kkk4lVBFpPrnsARNxW9P56PcDgrCXGiUe01eyObtI2kxfcMjzv2N+maEtBBzTWthr1wEkWZRFCiGsp1f/ICxcu5KGHHuKBBx7gn3/+ISsrC4CkpCTeeustVqxYUaZBCnGjDIEBtsdqdjanX3yRrPijhH44Gc+ePcv0WkeTj5JtyeZi5kUmbJ7AnF1zeKzFY/Sr0w+9Tl+m1xLVTPvHtA0gO10bKJdbR6xa7Usgtn+plU/kUvRQI0IbVBfSEm4dV7GxCyFEFVGqySnffPNNZs6cyezZs+0GvnXq1Int27df5ZVCOJ41IwNDrdroPT1xbd26zM/fwKcBK+9eyfOtn8fH5MPxlOO8/NvLDF42mFVHV2FVrWV+TVENGV21JLblA9D7/6DP/+z3t38cWo2AsHZar7BqgQsHYO8y2LPE/tj5D8IPI+HXd2HPMrhwUBusJ4QQN6FS9fzu37+fLl26FGr38vLi8uXLNxqTEOVK7+VFzenTyDl3zm4hjJQNG3Dr2NFusFxpuTi5EN0kmnsb3Ms3+75h7u65HEk6wn9+/Q+zfGYR0yKG22vdXurZJ4Sw1RGDtlhHyhmth/jcPjB55O2zmGH/KrCa4d98r9ebcKpRn8ZKHaCf/bnkcymEqMZKlfwGBQVx6NAhwsPD7dp/++036tatWxZxCVGuFEWxWxwjfft2Tj7+BMaIutSZPx+dW9lMPeVqcGV0s9EMaTiEr/Z8xZd7vuTgpYM8s+EZGvs2ZmzLsdwaeqskweLGKAp4hmhbvR6F9w/9Bs7v1VavO7cXzu+HnAyUc7tx884377DVCu/XA68wrY7Yv1FeTbFXmCTFQohqoVTJ75gxY3j66af57LPPUBSF06dPs2XLFp5//nlee+21so7RIWSe35uLNT0DfY0auDRvUWaJb34eRg8ej3qcYY2H8cW/X/D13q/Zm7iXmHUxNPdrzpud36SOV50yv64Q6A15q9flslrh8lFyzuzmSNw+bBXxl49pg+zSL8KZOPvzGN2h9Ujo9ab2XFUh+bSWcEtSLISoQkqV/I4fPx6r1Ur37t1JT0+nS5cumEwmnn/+eZ588smyjtEhZJ7fm4t7507U/XEZij5vQJolNY3sQwdxiYoqs+t4mbx46paneCjyIebunsu3+77lSNIRfJ19y+waQlyTTge+dVE9wkg8pOa1e9eCsX8X6CXep9UIZ6dC/pUNU87Ch5FavXHuXMf+jfIee9bUriOEEJVMqZJfRVF45ZVX+M9//sOhQ4dITU0lMjISd3dZy15UXfnrfwHOffA+l7+bT8Bz46gxenSZXsvH2YdxrccxvMlw9iXuw8uk/YKlqiofbPuAnuE9aeHfokyvKcQ16fTgV0/bGt+Z124xw8XD9ivRXTqqzTCRlQQn/9K2/Do9DT3f0B5npUD8Ri059gnXriOEEA5yQ5OPGo1GIiMjyyoWISoN1WpFzcoGVcW5adNyu46fix+dQ/Pmxd58ejNf7PmC7/Z/x8/3/Iy3s3e5XVuIEtMbIKCRfVvtDvDKGbh4SOsdPn/gytf9Wptfvjm0z+yE74ZdOZdJm5PY1lvcUJuxwjOk4t6PEOKmVqrk97bbbrvqAJ1ffvml1AEJURkoOh0hb/0fNUaOwFS/vq09c/9+jGFh6Fxdr/Lq0qvrVZe76t2Fl8nLLvFNSEsg0C2w+BcK4QhOJm31ucAm9u2WHG3qtVxWMwS30BLknAw496+25eo/Gdo8rD0+fwB2fqf1Evs10DZj+fy8CSFuTqVKfqMK1ECazWbi4uLYvXs30dHRZRGXEJVC/sTXkpzMiUceRTEYCJv1CaZymNkk2D2YNzq9garm1WHuPL+T4SuHc2fEnTze4nFC3KWHTFRyeifs/nup2w0e3agNtEs6bt9LfGE/BDXLO/bEn7Dpg3wnU8A7LC8ZbvmgNvuEEEKUUqmS3w8//LDI9okTJ5KamnpDAQlRWZlPnwa9DkWvxxAcXK7Xyv+Xld9P/45FtbDk0BJ+OvIT99S/h0eaP4K/q/9VziBEJaTTaTW/PuH2s0/kV6MetBqpLdhxbi9kJMLl49p2cI02lVtu8rtvOfw1Ky8x9m+ofXXzlxkohBDFuqGa34IefPBB2rZty/vvv1+WpxWiUnBu1Ii6y5aRc+4cOhcXW3vm/v04N2xYbtd9vMXjdAzpyLR/pvHnmT/5bv93LDm0hPsb38+oJqOkLlhUL7U7aFuutAtaD3FuT3H+EotTf8ORDdqWn7OXlgTfMQWCrtTsZ6dps1XoDQghbm5lmvxu2bIFZ2fnsjylEJWK3t0dfb5ZTZLXruXUk0/hff9QgiZMKLfFKlr4t2BOrzn8deYvPvrnI3ac38Hc3XP5Yf8PDI8cztAGQ8vlukI4nJuftoV3Kryv+VDwqaOVTpzfr/UWXzoGmUlwciuY8s1AtHkabHwffOuCX/28emK/BtpzZ8+Ke09CCIcqVfI7ePBgu+eqqnLmzBm2bdtWbRa5EKIksvbtB0Dv4Vkhq7S1DW7LvKB5bDq1iY+2f8T+S/uZsWMG3+z7hnZKO27LuQ2DQXq2xE3Cv4G25WfOhMTDWjLsFZbXnnhEG3h34UqdcUFPbocaEQAop//BP3k3JLcA39pSQiFENVOq5Lfgog86nY6GDRvyxhtv0KtXMXVcVYys8CZKwv/Jsbh16oRzk7wp/3IuXULR69F7lk9PkqIodKnZhc6hnVlzbA2x/8RyNPkoq1nN3z/+zSPNH2Fow6GyZLK4ORmci56BYtBMuP01rXf4wsErX688Tr+oLfBxhW7bbDoe/h6mvQsGtytzH+frJW7YT5vpQghRJZUq+Z07d25Zx1HpyApvoqRcb2lpe6yqKmcnTCBjx05C3n8Pt7Zty+26OkVHn/A+9KjVg6UHlzLlrylcyLjA76d+5/5G95fbdYWoknQ6bdYI7zCo191+X1aKXS2w6h5IiikYd/N5FHManNmhbQCKDl45m/faP2ZC0gn7Mgq3GhXwhoQQpVWmNb9C3Owsly+TdfAQOYmJ5dbzW5CTzokBdQfAXsisn0nr4Na2fefSz7H93HZ61e6FTpGlZoUoksnD7qn19tf5JbMN/Xr3xJB6yr6XODvVvtd398LCq9u5+ObNPnHn1LyyCVWVEgohKoFSJb8+Pj4l/pNqYmJiaS4hRJXk5ONDnSWLSf/7b5wb5a2IlXP+PE7+5Ts1mZPixH0N7rOr+Z21cxbz989nS/0tTOo4qVyvL0S1ozdcGRxXH+hf9DGtR0Foq7zkOOm4Nj3biT8g+bR9sjtvECSd0s5Xo96Vr/Wlt1iIClaq5Pe1117jzTffpHfv3nTooE1Js2XLFlavXs1rr72Gr69vmQYpRFWic3bGvVPeyHTz2bMcuXMAHj16EPTaq+W2OlxRgtyCcDO4cUfdO2xtOdYcnHTyRx8hykTU/dqWKzsNLh7WkmGL2f7YhD2Qdg4uHix8noBIeGJL3vNjm8HFR5udQuqLhShTpfof8Pfff+eNN95g7NixtrannnqK6dOn8/PPP7NkyZKyik+IKi/t99+xpqaSdeQwiqli/xMb3Ww0QxoOwcOY92fdGXEz2Hl+J0/e8iQt/FtUaDxCVHtGNwhurm0FPbJe6x2+eOjK14NXeotPaNO55bfgYUg5DSjgHgAeQeARrH0NbAptx+Qdm3EJTF5aXbMQ4ppKlfyuXr2ad955p1B7nz59GD9+/A0HJUR14n333RjDw9H7+KDo9QCoVivW9Az07m7lfv38iW9mTibfH/iepKwk/lzxJ11rduXJlk/S0Lf8FukQQlzhVVPbIm6zb89O1+YmzmUxa0luVgpkp0BqgrblDroLv9U++Z3eVkuAPYLybcHa5t8QGhVTsiHETapUyW+NGjVYunQpzz33nF370qVLqVFD6paEKMi1VSu755fnz+fCJ7MIfvNN3DsXMXl/OXF2cub7O75n5o6ZLDu8jF9P/sqvJ3+ld3hvYqJiqONVp8JiEUJcYXTVtlx6g9ZLrKraCncppyHlLKScgeQz4BmSd6wlR5uqTbVoPchJJ+zPHX6rffI7tYU2Y0VuL3JukuwRpJVYhN5Svu9ViEqgVMnvpEmTGD16NBs2bKBdu3YA/Pnnn6xatYrZs2eXaYBCVDeq1cql738g5+xZso8cgQpMfgFC3EN4o9MbjGo6ihlxM1h5dCWrj65m7bG1DIgYwOMtHifEPeTaJxJClC9FAXd/bQsupkRJ76RNvZZ2TkuQk/MlyilnrwzWu8Ji1lbAQ9UW/SioTheI/jHv+Wd9wckIHiG2RFlx9ccn7Yh2bt+wwucQogooVfI7YsQIGjduzEcffcSiRYsAaNy4Mb/99pstGRZCFE3R6Qj/5msu//ADPg8+YGu3ZmejMxorLI5wr3De7fouDzd7mOlx09lwYgNLDi1h+ZHl3NfwPkY3G42fi981zyOEcDAnY15JxdUoenjqnyuJ8Rn73uSUsxAclXesxQzHNxe+FNAFsGZvgBH5EuUFo8DorvVKe4ZoCbNnCHgGg7O3TPEmKpVSD/lu164dX3/9dVnGIsRNQ+figu/w4bbnqsXC8ZGjMNWtS8CLL6B3d6+wWBr6NmTa7dPYcX4H07ZP48+zf/L13q9ZdHARDzZ+kBFNR+BprJg5i4UQ5UinA9862nZNCgxfWiBBPoM1+QyZ5+Nxzr90dE62Nt9xcer1gAfz7d/wjjaThWdwXpLsHgA6fanfmhDXo8TJb3JyMp5XJu1PTk6+6rGeFTS5vxDVRfrWbWT8/TdZe/fi99ijFZr85mrh34I5vefwx5k/+Gj7R+y6sIvZu2YT6h7K3Q3urvB4hBAOpHeCut0KNVvMZtauWEG/fv3Im1tChTs/ulJ2cepKsnxa2zISwS3fHOc5WbDhrcLXU/RaaUWj/tDvvbz2f5doM2Hk9iYbnMvuPYqbVomTXx8fH86cOUNAQADe3t5FLnKhqiqKomCxWMo0SCGqO7f27aj15RdYLlzAEBpqa1ctFtsMERWlfXB72vVrxy8nfmHJoSUMqDfAtu9I0hHC3MMw5FsKVghxk3MyQavooveZMyAnM++5JRvaPZaXHOeWX6gWLXHOSs07NicLfihwXhcf8AzVBulF3AYdYvL2ndsHHoFSZiGuqcTJ7y+//GJbvGL9+vXlFpAQNyu3tm3tnmcdPMjJJ58i6PUJuF1ZTKaiKIpC91rd6V6ru63NbDHzxM9PADDt9mnU96lf3MuFEEJjcNG2XCYP6FtgqlSrBVLPabNaGPJN/5iVqs1WkZskm9O1Kd0yLkHC7sI9yjOujDlycslXexysfQ1raz/rhdUiZRY3sRInv127di3ycXUVGxtLbGys9GILhzk/bTrZR4+S+OW8Ck9+i3I0+SjZlmxUVGp6XGNgjRBClJROr9X/egbbt7vVgBE/aY9VFTIvX6k9vtJr7F0779j0i+Diq5VZ5GRA4mFty9ViWF7ya86E/4WCe2BecmzbQiGgMQQ2Kde3LByr1APeMjMz2blzJ+fOncNqtdrtGzBgQDGvqjpiYmKIiYkhOTkZLy8vR4cjbkIh/3uL8yEh+I4caWvLLS1yhPo+9Vk+eDlHk47i4qT15FhVK6/+9ip3RNxBh+AODotNCFHNKYpW8uDiA4GRhfd7hsCL8VqZRe4AveTTVxLlM1Czdd6xKWfAmqOVWSSfglMFzhX1AAyaoT02Z8LcvnmJsWeINqtG7nOPYG22DVGllCr5XbVqFcOHD+fChQuF9knNrxBlQ+fmRuD4F+3aLkyPxXIpkYDnnkPnVv6rwxXk4uRC4xqNbc9Xxq/kxyM/8uORH2kT1IanWj5FVEBUhcclhBCAVmLhW1fbiuNdG8bty+tBTj5zJRG+8jyoWd6xKafh9HZtK0r+RDknk6Ynv0K35TD41NKSY68rCbKMk6hUSpX8Pvnkk9x7771MmDCBwMDAso5JCFEE89mzXJg1C8xmXNu3x7NXL0eHRPvg9jzY+EHm75/P1rNbeWjlQ3Sr2Y2xLcfKkslCiMpJp8srswhtdfVj3fxh6Ld5vcTJpyEp32PPvAHKJJ8m4vwa+GVNgZMoWolF65HQbbzWlJMFe3/M6032DJEEuQKVKvlNSEhg3LhxkvgKUYEMQUHUmvUJKevX49Gzp6PDAaCGSw1ebPsiwyOH88nOT1hyaAkbTm7g15O/0rdOX2KiYqjlWcvRYQohROmYPKBRv6L3qao2e0UugwsHA/oTEeCCLiVfb7IlG1LPaqUWuZJPwcKH851M0eY6zk2GIwdB83u1XZYrJRqSIJeZUiW/99xzDxs2bCAiIqKs4xFCXIVbhw52g9+sWVmceuppvKKLmWaoggS7BzOx40Sim0QzI24Gq46uYkX8ClYfXc1d9e/iseaPEegmvywLIaoRRdGmecvlEcye0CGE9+uHznAlSbVatcF4ySe1AXm5LGao3alAgpygbae3Q0C+uubLx2DaLRRKkHNrj2t3sq9pFtdUquR3+vTp3HvvvWzatIlmzZphMNj/JvLUU0+VSXBCiKtL/OwzUn/9lYw9e1CedvzPXR2vOrzX9T0ebvYwH23/iE2nNrHgwAKWHVrG/Y3u5+FmD+Pj7OPoMIUQomLodODur235+TeEkSu0x7YEOV85RcgtecemXwS9sXCCnKvri3nJ78XDVwboFTE4zzMU/Opri4bc5EqV/H777besWbMGZ2dnNmzYYDfCW1EUSX6FqCA+Dz2E+cxZnDt1Ym9mhqPDsWnk24gZPWawPWE7U7dPZfu57Xyx5wuWHV7G6ntW22aLEEKIm17+BDkkqvD+sLbw6jlIu1Cg9vhk4UQ5+VTRCXKuri/CbS9rjy+fgDWvgGdNbWCeZ+iVZPnKNHA6XeHXVxOlSn5feeUVJk2axPjx49FV45sjRGWnd3cn+I1JmM1mWKH1IqRv3UrymrUEPPsMOldXh8Z3S+AtfN7nc34//Tsfbf+IVoGt7BJfs9WMQSc1bEIIcVWKcvUEOVdoK3hkQ4GBefmSZZ/wvGMTj8CepUWfR2eAHq9Dxye152kX4N/FeTNYeNYEV98qu5JeqZLf7OxshgwZIomvEJWMajZz+pVXMR8/js7FhYBxzzo6JBRFoXNoZzqGdCQ73+CQ3Rd288z6Z3gi6gkG1x/swAiFEKKaMLpBSEttuxbfOtDn7Ss9yKfykuWUM2A1g8kz79iEf2HF8/avz11JzysU2j4Cje/U2rPT4PJxLVF29qQyKlXyGx0dzfz583n55ZfLOh4hxA1QDAaCXnuVCzM+psYjYxwdjh2dosPZydn2/Ou9X5OQnsDfCX9L8iuEEBXNuxa0f7xwuyVHm53C6J7XZnSHRnfkJcpp5+1X0mt6T96xJ7fBl1cWO4vZCv4Nyvd9lEKpkl+LxcK7777L6tWrad68eaEBb5MnTy6T4IQQ18/91ltx69zZrhb//IwZuLVrh2ura8xpWYEmdZxEU7+mdKnZxdZ2LPkY8UnxdK3ZVVaLE0IIR9A7abW/+dVsBUO/zntuztQWAMntLQ5rm7cvOxWcvSAzSesVroRKlfzu2rWLli21LvXdu3fb7ZP/sIRwvPw/h2lbtnDho2lc0M8gYtVKjGFhDowsj1Fv5IHGD9i1TftnGquPrqaFfwuevuVp2gS1cVB0QgghimVwLn4lvUb9YfxxyErVyjAqoVIlv+vXry/rOIQQ5cS5SRO8Bg9G5+JSaRLfoqiqSphHGM56Z3ac38Go1aPoENyBp255iqZ+TR0dnhBCiOthcr/2MQ4iI9aEqOb0np6EvPV/BL6SV6NvSUri/EfTsGZmOjAye4qi8PQtT7Ni8AqGNhyKk86JLWe2cP/y+3l2/bMcvnzY0SEKIYSoBkrV85uWlsbbb7/NunXrOHfuHFar1W7/kSNHyiQ4IUTZUfLNzpLw1v9IWrqUzL17Cft4hgOjKszf1Z9X2r9CdJNoPt7xMT8e/pGfj//MLyd+4Y66d/BE1BOEulfOOjIhhBCVX6mS39GjR/Prr7/y0EMPERwcLHW+QlQxHn37kPbXX/g9+oijQylWTY+a/F/n/2Nkk5HExsXy8/GfWXZ4GSviV3BP/Xt4tMWj+LnISkVCCCGuT6mS35UrV7J8+XI6depU1vEIISqAR7duuHfsiGI02tpSN21C7+GBS1SU4wIrQj2fenx424fsvrCbj7Z/xJYzW/hu/3csObSE8W3Hc3eDux0dohBCiCqkVDW/Pj4++Pr6lnUs5eLEiRN069aNyMhImjdvzg8//ODokISoFPInvjmJiZx+cTxHhz1A6qbfHBhV8Zr6NWVWr1l82utTmvs3J9OSSS3PWo4OSwghRBVTquT3v//9LxMmTCA9Pb2s4ylzTk5OTJkyhT179rBmzRqeeeYZ0tLSHB2WEJWKotfjfmtnTPXq4dqu7bVf4EBtg9vyVd+v+LLvl3ZToX3x7xd8vfdru1XkhBBCiIJKXPbQsmVLu9reQ4cOERgYSHh4eKFFLrZv3152Ed6g4OBggoODAQgKCsLPz4/ExETc3Crn3HNCOILey4uQd97BkpqG7kqPsKqqJC1Zimf/fra2ykJRFFoG5C3feTHjIrFxsWTkZBDiFsJttW5zYHRCCCEqsxInv4MGDSqXADZu3Mh7773H33//zZkzZ1i8eHGha8XGxvLee+9x9uxZWrRowbRp02jb9vp7p/7++28sFgthlXiuUyEcSe+e90th8o8/cuall0ic9yV1vv8exalUQwQqhKfJk+dbP89vp36jW1g3W/vx5OMEOgc6LjAhhBCVTon/N3v99dfLJYC0tDRatGjBqFGjGDx4cKH98+fPZ9y4ccycOZN27doxZcoUevfuzf79+wkICAAgKiqKnJycQq9ds2YNISEhACQmJjJ8+HBmz55dLu9DiOpG5+GBvkYNPHv1rtSJL4BBZ+C+hvdxX8P7bG1p5jQeXPEgga6BtDO3Q1VVB0YohBCisijV/2h169Zl69at1KhRw6798uXL3HLLLdc1z2/fvn3p27dvsfsnT57MmDFjGDlyJAAzZ85k+fLlfPbZZ4wfPx6AuLi4q14jKyuLQYMGMX78eDp27HjNY7OysmzPk5OTATCbzZjN5pK8pRuSe42KuFZVI/emeOVxb5w7d6bWksXo3N3zzn/2LJbERJwjI8vsOuVlV8IusixZ7Lu0j33sY+fanTzZ8kmi/KMcHVqlIT9TRZP7Ujy5N8WTe1O8irg313NuRS1Fd4hOp+Ps2bO2ntdcCQkJhIWFkZ1dugEniqLYlT1kZ2fj6urKggUL7EohoqOjuXz5MkuXLr3mOVVVZdiwYTRs2JCJEyde8/iJEycyadKkQu3ffPMNrq6uJX0rQlQ/qkrop5/hevgwCXcPJrl1a0dHdE1p1jQ2Zm3kz6w/yUH761ADpwb0dO5JsFOwg6MTQghRVtLT0xk2bBhJSUl4enpe9djr6vldtmyZ7fHq1avx8vKyPbdYLKxbt446depcZ7jFu3DhAhaLhcBA+5q9wMBA9u3bV6Jz/P7778yfP5/mzZuzZMkSAObNm0ezZs2KPP6ll15i3LhxtufJycmEhYXRq1eva97MsmA2m1m7di09e/YsNJDwZif3pngVcW+sGRkkrPuF9OPHafvQQxjL8Ge9PA0yD2LB6gUc9DvIj/E/ciDnAAdSD9CrVi8eb/44tT1rOzpEh5GfqaLJfSme3Jviyb0pXkXcm9y/1JfEdSW/ub2viqIQHR1tt89gMBAeHs4HH3xwPacsd507dy60/PLVmEwmTCZToXaDwVChH+aKvl5VIvemeOV6bwwGwj6aivnYMYzh4bbmjF27cG7UCKUSf0+8dF5MaD+B0S1GExsXy8r4law5voZ1J9YxqN4gHmvxGEFuQY4O02HkZ6pocl+KJ/emeHJvilee9+Z6zntd8/xarVasViu1atXi3LlztudWq5WsrCz279/PHXfccd0BF8fPzw+9Xk9CQoJde0JCAkFBN+9/VEI4iqIodolv9vHjHBsezdEhQ8lJTHRcYCVU27M273Z5lwV3LqBrza5YVAsLDy6k/6L+vLv1XVKyUxwdohBCiHJWqkUu4uPj8fPzK+tYCjEajbRq1Yp169bZ2qxWK+vWraNDhw7leu3Y2FgiIyNp06bNtQ8W4iaVfeIEitGIzt0dvbe3o8MpsYa+DZnefTrz+s6jdWBrsq3ZrIxfiV7ROzo0IYQQ5azEZQ8fffQRjzzyCM7Oznz00UdXPfapp54qcQCpqakcOnTI9jw+Pp64uDh8fX2pVasW48aNIzo6mtatW9O2bVumTJlCWlqabfaH8hITE0NMTAzJycl2tc1CiDzunTpR98dlYLGg6LTfpVWLBfOJE3Y9xJVVVEAUn/X+jC1ntpBmTsPVoA1qtapWFh9cTP+6/XF2cnZwlEIIIcpSiZPfDz/8kAceeABnZ2cmT55st9pbfoqiXFfyu23bNm67LW81ptzBZtHR0Xz++ecMGTKE8+fPM2HCBM6ePUtUVBSrVq0qNAhOCOEYhgKzviR+/gXnp0wh4IUX8H3oQQdFVXKKotAxxH4KxNVHVzNxy0S+3PMliwcuRqeU6o9kQgghKqESJ7/x8fG2x0ePHi2zALp163bNyefHjh3L2LFjy+yaQojyoaoqGTt2oJrN6Fyqbo+pUW8k2C2YvnX62hJfVVVRUSURFkKIKu66/xU3m81ERESwd+/e8oin0pCaXyGun6IohE6dQtisT/C6+25be86FC6gWiwMjuz7da3Xnp7t+YkSTEba2Lae3cO+P9/LriV9ltTghhKjCrjv5NRgMZGZmlkcslUpMTAx79uxh69atjg5FiCpFURTcu3SxlUapZjPHH3mEYw8NJ/vkKQdHV3JGvdGu3vez3Z9x4NIBxv4yluErh7P1rPzbIIQQVVGp/n4XExPDO++8Q05OTlnHI4SoZjIPHMB87DjZhw+jMxkdHU6pfdDtA0Y1HYWz3pm483GMWj2Kx9Y+xp6LexwdmhBCiOtwXYtc5Nq6dSvr1q1jzZo1NGvWDDc3N7v9ixYtKpPghBBVn0uTJtRdtpTs48dx8ve3tVtSU9G7uzswsuvjZfLi2VbP8kDjB5i1cxYLDyzk99O/8/vp3+lVuxdjW46ljlfVWPVOCCFuZqXq+fX29ubuu++md+/ehISE4OXlZbcJIUR+htBQ3PLNzZ2xazeHut1G4ryvqlz9bIBrAK+2f5Vlg5bRv25/FBTWHFvDoKWDmPD7BM6knnF0iEIIIa6iVD2/c+fOLes4Kp3Y2FhiY2OxVKFBOkJUFZcXLsCamkrGP9urxHRoRQnzDOPtW99mVNNRTPtnGhtObGDxocX8dOQnhjQcwpjmY/B19nV0mEIIIQqQOXuKIQPehCg/QRMmEDRxIoGvvWZrU83mKtcLDNDApwHTbp/GvL7zaBPUBrPVzFd7v2LK31McHZoQQogilKrnF2DBggV8//33HD9+nOzsbLt927dvv+HAhBDVl6LT4TN0iF3buckfkrV/H8H//S+G0FAHRVZ6UQFRfNrrU7ac2cKMuBmMaT7Gti8xMxFXJ1dZLU4IISqBUvX8fvTRR4wcOZLAwED++ecf2rZtS40aNThy5Ah9+/Yt6xiFENVcTmIil+bPJ23zFjIPHnR0OKWWu1rcV/2+IswjzNb+9p9v039Rf3479ZsDoxNCCAGlTH5nzJjBrFmzmDZtGkajkRdeeIG1a9fy1FNPkZSUVNYxCiGqOSdfX+ouWkjAf57Ho1s3W7tqtTouqDKSbk5n54WdnMs4h7+L/7VfIIQQolyVKvk9fvw4HTt2BMDFxYWUlBQAHnroIb799tuyi86BZIU3ISqWMTycGg8/bHtuTUsj/u57uLxwUZWsBc7lanBl2aBlxHaPpaFvQ1v7F/9+wcaTG6v0exNCiKqoVMlvUFAQiYmJANSqVYs//vgDgPj4+GrzD7kMeBPCsS599x1Ze/dyPnY6anq6o8O5IUa9kS41u9ien0g5wZS/pxCzLoboVdFsO7vNgdEJIcTNpVQD3m6//XaWLVtGy5YtGTlyJM8++ywLFixg27ZtDB48uKxjFELchHxHjADAOTISXYGFdKo6T6MnD0U+xDf7vuGfc/8wcvVIOoV24umWT9O4RmNHhyeEENVaqZLfWbNmYb1SixcTE0ONGjXYvHkzAwYM4NFHHy3TAIUQNydFr7crgwBI3fQbl775hqBJEzEEBDgoshvnZfJiXOtxttXiFh1cxO+nfuf3U7/TO7w3MVExslqcEEKUk1IlvzqdDp0ur2Ji6NChDB06tMyCEkKIgtScHM6+8QbmEye4FFGXgOefd3RINyzQLZDXOrxGdJNoYuNiWRm/ktVHV/PzsZ8ZWG8gj7d4nCC3IEeHKYQQ1Uqpkt+dO3cW2a4oCs7OztSqVQuTyXRDgQkhRH6KkxM1p0/nwscf4xcT4+hwylQtz1q80+UdRjUdxfR/prPh5AYWHVzET4d/YkijIYxuNlpWixNCiDJSquQ3KioKRVFsz1VVtXtuMBgYMmQIn3zyCc7OVXNSd1neWIjKx7lhA2pO+dCu7eyb/4frLS3x6NvX7t+hqqihb0OmdZ9G3Lk4pm6fyraEbczbM4+FBxbybf9vqetd19EhCiFElVeq2R4WL15M/fr1mTVrFnFxcezYsYNZs2bRsGFDvvnmGz799FN++eUXXn311bKOt8LIbA9CVH6pm37j0ldfcer5/5B99KijwykzUQFRfNb7M2b2mElj38aEe4Xb1QBXl1l1hBDCEUrV8/t///d/TJ06ld69e9vamjVrRs2aNXnttdf466+/cHNz47nnnuP9998vs2CFECI/t/bt8Bs7FtWSg6lO9RogpigKnUI70TGkI4mZibZe7TRzGiNXjeTehvdyV727cNKVepV6IYS4KZWq53fXrl3Url27UHvt2rXZtWsXoJVGnDlz5saiE0KIq1AMBvzHxhDw9NO2tpyLFznz2gRyLl1yYGRlR1EUarjUsD1fcGABexP38vnuz1GRHmAhhLhepeoyaNSoEW+//TazZs3CaDQCYDabefvtt2nUqBEAp06dIjAwsOwiFUKIEjj73zdJWbUK8+nT1Pp0jqPDKXP3N7ofvaInxD0Eg84AgNli5q+zf9ExpGOVr3sWQojyVqrkNzY2lgEDBlCzZk2aN28OaL3BFouFn376CYAjR47wxBNPlF2kQghRAjUefpjsY8cI+E/VnwqtKEa9kQcjH7RrW3BwAW/9+RYtA1ry9C1P0yqwlYOiE0KIyq9UyW/Hjh2Jj4/n66+/5sCBAwDce++9DBs2DA8PDwAeeuihsotSCCFKyKVZU+osWmjXA+q+cydprq549+zpwMjKT0ZOBia9iX/O/cOIVSNktTghhLiKUo+U8PDw4LHHHivLWIQQokzkT3xzEhIIXLiIM19/g37GDDxuv82BkZWPUU1HcUfdO/hkxyeFVosbGzWWcK9wR4cohBCVRqkGvAEcPnyYJ598kh49etCjRw+efvppDh8+XJaxOVRsbCyRkZG0adPG0aEIIW6AzsuLpHZtcW7RAvcutzo6nHIT4BrAax1eY+mgpfSr0w8FhdVHVzNo6SAmbp7I2bSzjg5RCCEqhVIlv6tXryYyMpK//vqL5s2b07x5c/744w+aNGnC2rVryzpGh5B5foWoHnTOzlzo14/QuZ+hOGl/7FJVlYuffoYlJcXB0ZW93NXifrjzB7rV7IZFtbDw4EL6L+rPu1vfJTEz0dEhCiGEQ5Uq+R0/fjzPPvssf/75J5MnT2by5Mn8+eefPPPMM7z44otlHaMQQtwwxWCwPb48fz7n3nuPo/feh2o2OzCq8pO7Wty8vvNoHdiabGs28/bMo+/Cvny++3NHhyeEEA5TquR37969PPzww4XaR40axZ49e244KCGEKE+m+vUx1K6Fz7D77ZLi6qjganHpOelkWDIcHZYQQjhMqQa8+fv7ExcXR/369e3a4+LiCAgIKJPAhBCivLi2akXdJUtQTCZbW/axY5hPncKtY0cHRlY+8q8W9/Pxn+kYkvce43PiWXRoEXc3vFtWixNC3BRK9S/dmDFjeOSRRzhy5Agdr/xH8fvvv/POO+8wbty4Mg1QCCHKg87FxfZYtVg4/dLLZGzfTuBrr+L7wAMOjKz8KIpCz9p5072pqsqqjFWc+usUidmJPN7icQdGJ4QQFaNUye9rr72Gh4cHH3zwAS+99BIAISEhTJw4kaeeeqpMAxRCiPKm5uTg3KgRWfv349Gtm6PDqTAW1UILYwvQwX0N7rO1p2an4mZwk9XihBDVUqlqfhVF4dlnn+XkyZMkJSWRlJTEyZMnefrpp+UfSyFElaMzmQia8BoRa1ZjCA21tadt3ow1Pd2BkZUvJ50THU0dWXLnEmq41LC1j9swjhGrRrA9YbsDoxNCiPJR6nl+c3l4eNhWdRNCiKrMqUZeAph16BAnHn2MIwMHkXP+vAOjKn96nd72+GTKSbaf2872c9uJXhXN4z8/zr7EfQ6MTgghylaJyx5atmxZ4l7d7dult0AIUbVZklPQ+/lhrFsHvZ+fo8OpMDU9arL8ruXM3DmTxQcX89up3/jt1G/0Ce/D2JZjqe1Z29EhCiHEDSlx8jto0KByDKPyiY2NJTY2FovF4uhQhBAO4HpLS+ouW4qanW37xV/NziZz/35cmjVzcHTlK9AtkNc7vM7IJiOZHjedlfErWXV0FWuPrWVQvUE81uIxgtyCHB2mEEKUSomT39dff70846h0YmJiiImJITk5GS8vL0eHI4RwAH2Bkq4Ln8ziwowZ+D05Fv8nnnBQVBWnlmct3u3yLg83fZiP/vmIjSc3svDgQn48/CNDGw1ldLPR+Dj7ODpMIYS4Ljdc8yuEEDcDVVW12l9VxRQe7uhwKlRD34bEdo/ly75f0iqwFdnWbL7c8yV9F/Xl47iPSc1OdXSIQghRYpL8CiFECSiKQvAbkwj/4Qc8+va1tWefPIk1K8uBkVWclgEtmdt7Lh/3+JjGvo1JM6cxY8cMjqccd3RoQghRYrKcjxBCXAeXZk1tj61ZWZx49DEAak77CFPduo4Kq8IoikLn0M50DOnI2mNr+ffiv0TWiLTtjzsXR1O/prJanBCi0pJ/nYQQopSyjx3DkpQEgN7n5qp91Sk6eof3pnd4b1vbyZSTjFw9klD3UL7q+xXezt6OC1AIIYpxQ8lvdnY28fHxRERE4OQkebQQ4ubi3KABdX9chvnECZzyJb/mhHMYAgMcGJljHEs+hofBg2C3YEl8hRCVVqlqftPT03n44YdxdXWlSZMmHD+u1Xs9+eSTvP3222UaoBBCVGZOPj64NG9ue56+bRuHevTg/EcfoaqqAyOreJ1CO7Hy7pW80fENW1tiZiKPrX1MVosTQlQapUp+X3rpJXbs2MGGDRtwdna2tffo0YP58+eXWXBCCFHVpPyyHsxmzAkJN+Vy724GN4Ldg23PP931Kb+f/l1WixNCVBqlqlVYsmQJ8+fPp3379nb/uDdp0oTDhw+XWXBCCFHVBL7wH1yiWuDWoYOtzZqRgeLkhGIwODAyxxgeOZyMnAwWHVwkq8UJISqFUvX8nj9/noCAwvVsaWlpN2VPhxBC5OfZq5fdAhkJ77xD/JAhZO4/4MCoHCPQLZAJHSawbNAy+tbRpohbdXQVA5cMZOLmiZxNO+vgCIUQN5tSJb+tW7dm+fLltue5Ce+cOXPokK+3QwghbnY5ly6Rsmo1WXv2Yrl0ydHhOEzuanEL7lxAl5pdsKgWFh5cSP9F/Xlv63tcyrx5740QomKVquzhrbfeom/fvuzZs4ecnBymTp3Knj172Lx5M7/++mtZxyiEEFWWk48PdX9cRuqvv+LWvp2t3Zqdjc5odGBkjpG7Wtw/5/5h6vap/J3wN1/u+ZKFBxcSHRnN8CbDcTO4OTpMIUQ1Vqqe386dOxMXF0dOTg7NmjVjzZo1BAQEsGXLFlq1alXWMQohRJXm5O+P9z332J5bkpI40q8/F2bPRs3JcWBkjlPcanGPrH3E0aEJIaq5Uk/OGxERwezZs8sylkolNjaW2NhYLBaLo0MRQlQzSUuWYD55kqSFi/B98EGUm3Se9IKrxU3/ZzrDGg2z7c+xar8YyGpxQoiyVOJ/UZKTk0t8Uk9Pz1IFU5nExMQQExNDcnIyXl5ejg5HCFGN+Awfjs7DE2OdcHQuLrZ21WpF0ZXqD3JVWu5qcd1rdUen5L3/hQcW8tXer3iu9XN0C+vmuACFENVKiZNfb2/va87koKoqiqJIb6kQQlyFoih4D77Lri159RoS584l+K23MNWt46DIHCt/D6+qqnx/4HuOJh/lTNoZB0YlhKhuSpz8rl+/vjzjEEKIm5ZqsXBu8geYjx0n6cdlBDz9tKNDcjhFUfiy75csOLCAe+rn1Uv/ceYPTHoTLQNaOjA6IURVVuLkt2vXruUZhxBC3LQUvZ7an3/Oxdmz8Xv8cUeHU2m4GdyIbhJte262mvnvlv9yPOU4XWp24amWT9HQt6EDIxRCVEUlTn537txZ4pM2z7fOvRBCiGszBAcTNGGC7bmqqpz+zwu4NG+Oz4MP3JS1wAVl5WTRJqgNp1JPsfHkRjae3Ejf8L7EtIyR1eKEECVW4uQ3KioKRVFQVfWqx0nNrxBC3Li0334j+aefSF69GrfOnW/aOuD83I3uTOw4kRFNRjAjbgYrj65k5dGVrDm2hrvq38WjzR8lyC3I0WEKISq5Eie/8fHx5RmHEEKIfNw6dSJwwmuomVmS+BYQ7hXOu13fZVSzUXy0/SM2ndrEggMLWHZoGfc3up+Hmz2Mj7OPo8MUQlRSJU5+a9eWPykJIURFUXQ6fIcNs2sznznD2Tf/j8CXXsJYM9RBkVUejXwbMaPHDLYnbGfq9qlsP7edL/Z8wYKDC4huEs3wSFktTghRWKmLyObNm0enTp0ICQnh2LFjAEyZMoWlS5eWWXBCCCHynP2//yN13TrOTnjN0aFUKrcE3sLnfT5nRvcZNPJtpK0WFzeDvgv78teZvxwdnhCikilV8vvxxx8zbtw4+vXrx+XLl201vt7e3kyZMqUs4xNCCHFF4H/+g1vHjgS++qqjQ6l0FEXh1pq3Mv+O+bzX5T1qe9Ym05JJXe+6jg5NCFHJlCr5nTZtGrNnz+aVV15Br9fb2lu3bs2uXbvKLDghhBB5jLVrU+uzTzHVzUvoLi9cyKUffrjmYOSbhU7R0adOHxYPXMzc3nPxc/Gz7XvzjzdZdXQVVtXqwAiFEI5WqgXT4+Pjadmy8ATjJpOJtLS0Gw5KCCHEtZlPneLsm/+HmpGB3tsbz549HR1SpWHQGWji18T2fOvZrczfP5+FBxbSbHAzQt2lZlqIm1Wpkt86deoQFxdXaBDcqlWraNy4cZkEJoQQ4uqcgoLwHzuWtD/+wKN7d0eHU6k19m3MEy2eIMOSYZf4Hk06SrhXuOMCE0JUuFIlv+PGjSMmJobMzExUVeWvv/7i22+/5X//+x9z5swp6xiFEEIUQdHrqfHwKHxHjURRFEBbKvn8lKn4PPgghsAAB0dYebgb3Xk8yn71vH2J+7jvx/voHNqZp255ika+jRwUnRCiIpUq+R09ejQuLi68+uqrpKenM2zYMEJCQpg6dSpDhw4t6xiFEEJcRW7iC5D4xZdcnD2b5OXLiVi9CsVgcGBklVvcuTh0io5Npzax6dQm22pxIS4hjg5NCFGOSpX8AjzwwAM88MADpKenk5qaSkCA9DAIIYSjud/ameTly/EeOkQS32sY2mgo7YPbF1otbmDEQOpZ6zk6PCFEOSl18pvL1dUVV1fXsohFCCHEDTLVr0/4/O8g30w8mQcOkHXgIJ79+9n1EouiV4tbdGgRTjhxZvsZxrQYI6vFCVHNlGqqs4SEBB566CFCQkJwcnJCr9fbbUIIIRxHcXLKqwE2mzkz/iVOP/88iZ9+6uDIKq/c1eI+7/M5Uf5R5JDDvH3z6LuoLx/v+Jg0s8xkJER1Uaqe3xEjRnD8+HFee+01goODK3VPwuXLl+nRowc5OTnk5OTw9NNPM2bMGEeHJYQQFca9++2Yz53Dc8AAR4dS6bUKbMWnPT5l6rKp/Gn8k/2X9jMjbgbf7v2W0c1G82Dkg+iUUi+OKoSoBEqV/P72229s2rSJqKioMg6n7Hl4eLBx40ZcXV1JS0ujadOmDB48mBo1ajg6NCGEKHeKwYB/TAw1RoxA5+Zma09etQpjEfO1C20AYQNDA57q8xTrT61netx0jiUfY+OpjQxvMtzR4QkhblCpkt+wsLAqs5qQXq+31SRnZWWhqmqViV0IIcpK/sQ3Y/e/nHruefRenugff/wqr7q55a4W16N2D5YeWmo3FVpiZiJbz26lZ+2e0hMsRBVTqp/YKVOmMH78eI4ePXrDAWzcuJE777yTkJAQFEVhyZIlhY6JjY0lPDwcZ2dn2rVrx19//XVd17h8+TItWrSgZs2a/Oc//8HPz+/aLxJCiGpKcdJjqlsXlzZtsXh6OjqcSs9J58TdDe62WzHu012f8vyvz/Pa7685MDIhRGmUuOfXx8fHrrY3LS2NiIgIXF1dMRSYTicxMbHEAaSlpdGiRQtGjRrF4MGDC+2fP38+48aNY+bMmbRr144pU6bQu3dv9u/fb5teLSoqipycnEKvXbNmDSEhIXh7e7Njxw4SEhIYPHgw99xzD4GBgUXGk5WVRVZWlu15cnIyAGazGbPZXOL3VVq516iIa1U1cm+KJ/emeHJvCtNHRFDzu2/JTk2FP/7AbDZjzcwkY9s23Dp3dnR4DleSz4yXwQs3Jzd6hfWyHWdVrdW+F1h+noon96Z4FXFvrufcilrCGoAvvviixCeNjo4u8bF2wSgKixcvZtCgQba2du3a0aZNG6ZPnw6A1WolLCyMJ598kvHjx1/3NZ544gluv/127rnnniL3T5w4kUmTJhVq/+abb2RKNyFEteW3fAW+GzeSeGtnLtxxh6PDqRIyrBk4K862jqH1mes5mXOSni49CdIHOTg6IW4uuYuuJSUl4XmNv2iVOPmtCAWT3+zsbFxdXVmwYIFdQhwdHc3ly5dZunTpNc+ZkJCAq6srHh4eJCUl0alTJ7799luaNWtW5PFF9fyGhYVx4cKFa97MsmA2m1m7di09e/Ys1KN+s5N7Uzy5N8WTe1O83HvTo0cPUmbO5NKnnxE8dQpu3bo5OjSHKs1nJsuSRZ/FfUjKTkJBoU/tPjza/FFqedQq52grlvw8FU/uTfEq4t4kJyfj5+dXouS3VAPeVqxYgV6vp3fv3nbta9aswWKx0Ldv39KctpALFy5gsVgKlSgEBgayb9++Ep3j2LFjPPLII7aBbk8++WSxiS+AyWTCZDIVajcYDBX6Ya7o61Ulcm+KJ/emeHJvimc0Ggl67jl8770XY628ZC3zwAEMQUHob9K64Ov5zBgMBr7q9xWxcbGsOrqKlcdWsvb4Wu6qfxePNn+UQLeiS+2qKvl5Kp7cm+KV5725nvOWqjhp/PjxWCyWQu1Wq7VUpQjlqW3btsTFxbFjxw527tzJo48+6uiQhBCiUsqf+FrT0jj5RAxH7hxA5t69Doyq6gj3Cue9ru/x/R3f0zm0MzlqDj8c+IH+i/vzwbYPuJx52dEhCiEoZfJ78OBBIiMjC7U3atSIQ4cO3XBQufz8/NDr9SQkJNi1JyQkEBRUvvVUsbGxREZG0qZNm3K9jhBCVEbmhHMoej3odRjCwhwdTpXSuEZjPu7xMZ/3+ZyWAS3JsmTx+b+f03dRX2bumCmrxQnhYKVKfr28vDhy5Eih9kOHDuGWby7JG2U0GmnVqhXr1q2ztVmtVtatW0eHDh3K7DpFiYmJYc+ePWzdurVcryOEEJWRqW4d6ixZTK1Zs9C7u9vasw4fdmBUVUurwFZ80ecLYrvH0tCnIanmVGLjYum3qB/z9swjy5J17ZMIIcpcqZLfgQMH8swzz3A43z+Chw4d4rnnnmPAdS6fmZqaSlxcHHFxcQDEx8cTFxfH8ePHARg3bhyzZ8/miy++YO/evTz++OOkpaUxcuTI0oQuhBCihHQuLpjq1bM9T/3td470v4MzEyfKYkElpCgKXWp24fs7v+fdLu9Sy6MWiZmJvLv1XZYeuvagbSFE2SvVgLd3332XPn360KhRI2rWrAnAyZMnufXWW3n//fev61zbtm3jtttusz0fN24coM3o8PnnnzNkyBDOnz/PhAkTOHv2LFFRUaxatarYeXqFEEKUj4ydOwBQDEa7ed/FtekUHX3r9LWtFrfs8DIG1Rtk238u/Rz+Lv5yX4WoAKVKfr28vNi8eTNr165lx44duLi40Lx5c7p06XLd5+rWrds1exDGjh3L2LFjSxNqqcXGxhIbG1vkwD4hhLgZ+T/xBG5t2uDcJG+lM0tKCopOZ7d8siieQWfgngb3cE+DvLnmc6w5PLz6YVwNrrxz6zuEe4U7LkAhbgKlSn5B+1NOr1696NKlCyaTqdr9thoTE0NMTAzJycl4eXk5OhwhhKgUXAsMAj773/+Ssf0fQt57F9eWLR0UVdV28NJBzqWfw6g34ufi5+hwhKj2SlXza7Va+e9//0toaCju7u7Ex8cD8Nprr/Hpp5+WaYBCCCEqJ8vly6Rv24b59Olq1wFSkRrXaMzKu1cyudtk3I3a4EJVVXl/6/vsT9zv4OiEqH5KlPzOnz/fNgAN4M033+Tzzz/n3XffxWg02tqbNm3KnDlzyj5KIYQQlY7e25u6y5YROuVDXKKibO2WlBTHBVVF+Tr70iYor1d93fF1fLHnC+798V5e3PgiJ5JPODA6IaqXEiW/zs7OdOnShR07tMEOX3zxBbNmzeKBBx5Ar9fbjmvRokWJV14TQghR9end3fHs1cv2POfiRQ736UvC2+9gzZKpvEqrvk99+oT3QUVlRfwKBiwZwBtb3uBc+jlHhyZElVei5HfgwIF89913PPjggwCcPn2aevmmv8lltVoxm81lG6GDyCIXQghx/VLWrsVy8SJpW7ZIKcQNqO1Zu8jV4vot6sfkbZNltTghbkCJa37bt2/Pr7/+CkBkZCSbNm0qdMyCBQtoWU0GPMgiF0IIcf18hg4l7JOZhLz9P5QrZXGqqqJmZzs4sqqpqNXi5v47l76L+vLJjk9IN6c7OkQhqpzrmu3B19cXgAkTJhAdHc2pU6ewWq0sWrSI/fv38+WXX/LTTz+VS6BCCCGqBveuXe2eJy1dysXZcwh5+3+4NGvmoKiqttzV4jad2sRH2z9i/6X9TI+bzjf7vuGR5o9wb4N7MeqN1z6REKL0K7z9+OOP/Pzzz7i5uTFhwgT27t3Ljz/+SM+ePcs6RiGEEFWUarFwcdZssg8fJu33zY4Op0orbrW4t/96m0FLB8lyyUKUUKnn+b311ltZu3ZtWcYihBCimlH0emp//RWX5s2jxuiHbe2q1YqiK1X/y02v4GpxH+/4mPbB7THpTbZjVFWVmmshilHif3lutnXcZcCbEEKUDScfH/yfegrFSetvUVWVE489xvmPpkkt8A3IXS1u+V3LefqWp23t+xP3M2z5MDaflp52IYpS4uS3SZMmfPfdd2Rf4x+qgwcP8vjjj/P222/fcHCOJAPehBCifKT9vpm0jZu4+OmnmM+ccXQ4VZ6zkzNepryVSGfvms3ui7tZeGChA6MSovIqcdnDtGnTePHFF3niiSfo2bMnrVu3JiQkBGdnZy5dusSePXv47bff+Pfffxk7diyPP/54ecYthBCiinLv3InQDydjSUnBWLu2o8Opdl5u9zIBrgHc2+BeW9vZtLMkZyfTwKeBAyMTonIocfLbvXt3tm3bxm+//cb8+fP5+uuvOXbsGBkZGfj5+dGyZUuGDx/OAw88gI+PT3nGLIQQoorz7NvX7nn2sWOcfuUVgiZMwLmBJGg3wtfZlxfavGDXNu2fafx4+Ef61e1HTIsYwjzDHBSdEI533QPeOnfuTOfOncsjFiGEEDephHfeJWPb35x79z1qzZnt6HCqFatqxWwxo6Ky/MhyVsevZnD9wTza4lECXAMcHZ4QFU6G2gohhHC4oImv49mvH0ETJzo6lGpHp+h4t+u7zL9jPp1CO5Gj5vD9ge/pv6g/k/+eTFJWkqNDFKJCSfIrhBDC4QwBAYRO/gBjzVBbW+KXX3JxzhxUi8WBkVUfkTUimdljJnN7zyXKP4pMSyZzd8+lz8I+slqcuKlI8lsMmepMCCEcJ/vkKc69/wHn3v+AlF9+cXQ41UrroNZ82fdLYrvH0sCnAanmVKbHTafvor58vfdrsi0y/Zyo3iT5LYZMdSaEEI5jCA0h6PXX8ezfH48ePRwdTrWTu1rcD3f+wDu3vkOYR5httbg7Ft/BhhMbHB2iEOVGkl8hhBCVjqIoeN89mNAP3retVKaazZyZ8DrZR486NrhqRKfo6Fe3H0sHLeW19q8R4BLAmbQz6BRJD0T1VerljYUQQoiKdHHOHC5//z2pGzdSb81qFKPR0SFVGwadgfsa3seAiAGsPbaWW0Nvte378fCP1HCuQYeQDg6MUIiyU+rk98SJEzz33HPk5ORgtVqZNGkSLVq0KMvYhBBCCBuvAQNI++svvO+5RxLfcuLs5MydEXfanidlJfG/P/9HijmFj3t8TLuAdg6MToiyUerk97HHHuP111+nbdu2nDhxgn79+rFr166yjE0IIYSwMYSGUuuzz+zaMnbtJmPnDnzuvx9FJ3+qLw8D6w0k7lwcHUM6YsnRZt5IN6fjZfC6xiuFqJxKnfwePXqU8PBwAPz8/EhMTCyrmIQQQogi5db/Alizszn90niyDx3GmpKC32OPOTCy6snL5MWLbV/EYrWgU3RYsJCtZnP38rtpE9SGJ6KeIMxDVosTVUupf01++umnGTp0KFu3bmXgwIGMGTOmLONyOJnqTAghKjfFyQmfofdjCAvDe8gQR4dTrel1etvjQ+ZDJKQn8NORnxiweABv/vEm59PPOzA6Ia5PqZPfkSNH4ubmxoABA0hMTOT5558vy7gcTqY6E0KIyk3R6fB98AEiVizHycfH1n55wQLMp087MLLqLdIYyVd9vqJjSEdy1Bzm759Pv0X9+PDvD2W1OFEllDr5/c9//kNYWBgnT55k7Nix3HfffWUZlxBC/H979x0VxfXFAfw7wAJLL9JFwQICCogVNVYULAhq7FGxJhETS6wx1sSWGI3xR9SYKHZNbEQRu0RFo4AuFhCFgBgFEaSItGX3/f4wTFhg6bAI93MO5zBvZmfu3h12L7Nv3iOkQjiBgP89OzwcicuW4++hXhAnJyswqobN3sAeO/rvwC73XXA0ckSuJBe7HuzCwGMDsfPeTpotjtRrVS5+g4KC8O2330JZWRk+Pj50sxshhBCFUzYwgNDJCdoDBkBgbKzocBq8TqadsH/gfmztuxWt9VvjjfgNfrz7IwYdH4SDUQdptjhSL1W5+O3bty+2bduG1NRU7N+/H507d67JuAghhJBKU7O2RvMD+2G67Cu+Tfr2LTJOB4IxpsDIGi6O49Dbsjd+H/I71n2wDk21miI1NxXrbq/D0JNDERATAIlUougwCeFVufjdunUrdHR0sHTpUqSkpGD//v01GRchhBBSJZyyMpSEQn755caNeDF/PpJWr1ZgVA2fspIyhrQYgj+8/8BXXb6CkdAIz7Oe47uw75BdQN0gSP1R5aHOVFRU8PHHH9dkLIQQQkiNYoxBYG4OTlUVOu7uig6nURAoCzC6zWgMbTUUhx4dgpZAC9qq2gDevR4RryLgbOys2CBJo1Yj0xsXFBQgNzcXWlpaNbE7QgghpEZwHIcm06dDz9sbKkZGfHvO/fsQmJlBpUkTBUbXsAlVhJjSdopM2+VnlzHnyhz0tuyNH/v8KDNuMyF1pVLdHk6dOgV/f3+ZtjVr1kBLSwt6enoYMGAA0tLSajI+QgghpNqKFr6SjAz84zsLfw8egpz7DxQYVePzz5t/IFASoLVeayp8icJUqvjdtGkT3r59yy/fuHEDy5cvx7Jly/Dbb7/h2bNn+Prrr2s8SEIIIaSmSDIyoGxoCGU9Pai1aqnocBqVSQ6TcHrYafi09eHbwpLCsPT6UjzPeq64wEijUqluDw8fPsSmTZv45aNHj6J///5YunQpAEBdXR2zZ8+W2YYQQgipT1SbNYP1kcMQJyfL3BiXExEBoZOTAiNrHMy1zGWWt97dijvJd3Am7gxG2ozEDMcZaCKk7iik9lTqyu+bN29gaGjIL1+/fh39+vXjlx0cHPCigcyqQ9MbE0JIw8WpqkK1aVN+OfP8ecSPHoPn8xfQkGh1bGGnhXA1c0WBtACHHh3CoOOD8OOdH5GZn6no0EgDVani18LCAlFRUQCArKwsREREoFu3bvz61NRUaGho1GyECkLTGxNCSOMh/uc5oKwMgYUF9UWtYw5NHPDzgJ/x64Bf4djEETkFOdh5fyc8jnngl/u/IKcgR9EhkgamUsXvyJEjMWfOHOzbtw/Tp0+Hqakpunbtyq8PCwuDra1tjQdJCCGE1CbDKZNh/ftvaOI7k2+TvH4NSXq64oJqZDqbdcb+QfvxY58f0UqvFd7kv8GWO1sw6PggHH50GGKJWNEhkgaiUsXv8uXL0alTJ3z++ecQiUTYv38/lJWV+fWHDh2Cp6dnjQdJCCGE1DZ1e3soqaq+W2AMyatWI9bTE2//uqXYwBoRjuPQp1kfHPU8irU91sJCywIpOSlYc2sNPE964lTsKZotjlRbpW54EwqF2Lt3r9z1V65cqXZAhBBCiKIpZWcjPy4OkvQMKOvpKjqcRkdZSRmeLT3hYeWBY0+OYce9HXie9RxfXv8SUa+jsLDTQkWHSN5jVZ7emBBCCGmopJqasPztCJrt2A71Nm349oJXrxQYVeMjUBZgTJsxCBwWiNkus6Gvpo8PW3/Ir6euEKQqqPglhBBCSqGkrg7NIjd1i5OSEDtoMF589RWkOXQTVl3SEGhgWrtpuDDyAlroteDbV/+1GjPOz8CTtCcKjI68b2pkemNCCCGkoXt7/TqkWVnIe/IEXGHfYFKn1JTV+N/TctMQFBeEPEkejQhBKoWKX0IIIaQC9D78EKpWVlA2MAD3783eTCoFy8mBkqamgqNrfPTV9XHS6yT+/OdPOBo58u1n486inVE7WGhZKDA6Up9VutuDWCxGv3798OQJfcVACCGkcdHo2BFqLf772j39yBH87TmURoRQkKbaTTHebjy/nPQ2CUuvL8WQE0Ow7tY6pOSkKDA6Ul9VuvgVCAS4d+9ebcRCCCGEvDeYRIK0g4cgfvECeXRBqF7ILchFe5P2KJAW4OCjg/xscW/y3yg6NFKPVOmGt48++gi//vprTcdCCCGEvDc4ZWU0P3QIxosWQX/8OL6diWkEAkWx0rXCLwN+wc4BO9HWsK3MbHG7HuyivsEEQBX7/BYUFGDXrl24ePEiOnToAM1ifZ02bdpUI8ERQggh9ZmyliYMJ/vwy0wiwdPJk6Fubw/juXOhJBQqLrhGrKtZV3QZ3AWXEy5j692tiM2IxebwzdgfuR+fOH2CYa2HQaAkUHSYREGqVPw+ePAALi4uAIDHjx/LrKM50QkhhDRWb2/+hZywcORFPYLhpElQsqCbrhSF4zj0a94PvS174/Tfp/GT6Ce8ePsCX//1Nfwf+sPX2RcDrQdCiaNRXxubKhW/jWEmNz8/P/j5+UEioWkUCSGEVIxWj+6w3LkTkswMCIoUvowxujikIMpKyvBq5YWB1gNx9PFR/HzvZzx78wyLry3Grw9+xU/9foKppqmiwyR1iP7dkcPX1xeRkZEIDQ1VdCiEEELeI1of9IDu4MH8cu7jx4jzHoYckUhxQRGoKqtinN04nBl+Bp+3/xzaAm0wxmAkNFJ0aKSOVenKb58+fcr8D/by5ctVDogQQghpSF5t2oy86Gik/LwTlj/5KTqcRk9DoIHpjtMxynYUXma/hLLSuzGbcwtysfLmSkywnwAHQwcFR0lqU5WKX2dnZ5llsVgMkUiEBw8eYNKkSTURFyGEENIgmG9Yj+RNm9Fk5kxFh0KK0FXTha6aLr98JPoIAv8OxN2XdxE4PBAqSjQPWENVpVd28+bNpbavXLkSWVlZ1QqIEEIIaUiUdXVhtmqlTNsrPz+wfDGa+M6EEk2VXC/0bdYXj14/QlezrnzhWyAtQEpOCvUJbmBqtM/vRx99hF27dtXkLgkhhJAGJf+ff5Dy0zak7tiBt9dDFB0O+ZeltiXWfbAOXq28+LZTsacw6PggbLi9Aa9zXyswOlKTarT4vXnzJtTV1Wtyl4QQQkiDotq0KSw2b4Le2DHQ7ttH0eGQMoQmhUIsFWN/1H4MPDYQfiI/mi2uAahSt4fhw4fLLDPGkJiYiLCwMCxbtqxGAiOEEEIaKp0BA6AzYAC/LM3Lw4vFi9Hk44+h3qaNAiMjRa3psQZDWg7BljtbEJkaie0R23Ho0SFMazsNY9qMgboKXfB7H1Wp+NXV1ZVZVlJSgq2tLVavXo0BRf6YCSGEEFK+lO3b8SboLHIiItDq3DlwApp9rD7gOA7dzLvB1cwVFxMuYuvdrYjLiMP34d9jX9Q+fOL0CbxbedNsce+ZKhW/u3fvruk4CCGEkEbLYPx45MfEQnfYMCp86yGO49C/eX/0seyDU7GnsC1iGxLfJmL1zdXwf+CPWe1noa9FX0WHSSqoyn1+09PT8csvv2DJkiV4/fpdJ/A7d+7g+fPnNRYcIYQQ0hioNGmCplt/lOkDnB0aipTtO8AKChQYGSlKRUkFw1oPw+lhp7Go0yIYqBsg4U0CFl5diHFB4/BE/ETRIZIKqNKV33v37qFfv37Q09NDfHw8pk+fDgMDAxw/fhwJCQnYu3dvTcdJCCGENBrS3Fy8+HIpxM+eAUyKJp9+quiQSBGqyqr4yP4jDG89HPsi98H/oT8epz+GqRoNifY+qNKV33nz5mHy5Ml48uSJzOgOgwYNwtWrV2ssOEIIIaQx4tTUYDTLF2pt2kB/wgRFh0Pk0BBo4GOnjxE0PAiT7Sejh1oPfl3062hEpUYpMDoiT5WK39DQUHz88ccl2i0sLJCUlFTtoAghhJDGjOM46Hp5wfr4MShrafHtqbv9kfd3nAIjI6XRU9fDZ86fQUNJA8C7UbDW3lqLUadH4ejjowqOjhRXpeJXTU0NmZmZJdofP34MIyOjagdFCCGEEIBT+u9jOut6CJI3bEDciBEQJycrMCpSnlxJLkw1TSFUEeIDiw/4dsaYAqMiharU53fo0KFYvXo1fvvtNwDv/kNNSEjAokWLMGLEiBoNkBBCCCGAWssW0OzeHarW1hAYGys6HFIGoYoQG3puQGpOKgyFhnz7wqsLYaxhjGntpkFfXV+BETZuVbry+/333yMrKwvGxsbIyclBr1690KpVK2hra2PNmjU1HSMhhBDS6AnMzGD5y06YLFzAt0kyMpB2+DCYVKrAyIg8RQvfx2mPcTb+LPZG7sXA4wOxTbQNb8VvFRhd41XlSS4uXLiAkJAQREREICsrCy4uLnBzc6vp+AghhBDyL47jAFVVfvnl2rXICPgDOQ8ewPybbxQYGSlPa73W2O62HVvubEHU6yj8FPETDj06hKntpmJMmzFQU1ZTdIiNRqWLX7FYDKFQCJFIhO7du6N79+61EVeNy87Ohp2dHUaOHImNGzcqOhxCCCGkWhhjEDo7482ly9D/8ENFh0PKwXEcult0Rzfzbrjw9AK23t2K+Mx4bAzbiH2R+/Cp06fwauUFFaUqXZcklVDpbg8CgQDNmjWDRCKpjXhqzZo1a9C1a1dFh0EIIYTUCI7joD92LFpduQyhszPf/vbWbeT/QxNO1Vccx2GA1QCc8DqB1d1Ww1TTFC+zX2LlzZXwDvDG2bizkDLqxlKbqtTnd+nSpfjyyy/5md3quydPnuDRo0cYOHCgokMhhBBCapSytjb/e0FqKp7PmYO4oUORc/++AqMi5Sk6W9zCTguhr6aPp5lPseDqAow5PQbX/rlGo0PUkioVv//73/9w9epVmJubw9bWFi4uLjI/lXH16lV4enrC3NwcHMfh5MmTJbbx8/ODlZUV1NXV0aVLF9y+fbtSx5g/fz7WrVtXqccQQggh7xuWm/tuNAhLS6jb2io6HFIBaspqmGA/AUEjgjDTeSY0BZqIeh2FmZdm4nHaY0WH1yBVqWOJt7d3jQXw9u1bODk5YcqUKRg+fHiJ9UeOHMG8efOwfft2dOnSBT/88APc3d0RHR0N43+HenF2dkZBKXOfnz9/HqGhobCxsYGNjQ1u3LhRY3ETQggh9Y3AwgLN9+2F5PVrcP/eGMcYw9vr16HZo8e7G+ZIvaQp0MSnTp9ijO0Y/Hr/VyRlJ8HW4L9/YIoPm0aqrtLFb0FBATiOw5QpU9C0adNqBzBw4MAyuyNs2rQJ06dPx+TJkwEA27dvR2BgIHbt2oXFixcDAEQikdzH//XXXzh8+DB+//13ZGVlQSwWQ0dHB8uXLy91+7y8POTl5fHLhZN5iMViiMXiyj69Sis8Rl0c631DuZGPciMf5UY+yk3pGkRe9PT4+DNPnULyl0uh2acPTLf8UK0CuEHkppbUVG60lLUw23k2GGP8vpKzk+F9yhu9mvbC8i7LIVQRVjveulQX501l9s2xKnQo0dbWxv3792FlZVXZh5YdDMfhxIkT/JXl/Px8aGho4OjRozJXmydNmoT09HQEBARUav/+/v548OBBmaM9rFy5EqtWrSrRfvDgQWhoaFTqeIQQQoii6d68CaPTgXjdrx9e9+2j6HBIFYTlheFkzkk0V26OaVrT6Ap+KbKzszFu3DhkZGRAR0enzG2r1O2hb9+++PPPP2u8+C0uJSUFEokEJiYmMu0mJiZ49OhRrRxzyZIlmDdvHr+cmZkJS0tLDBgwoNxk1gSxWIwLFy6gf//+EAgEtX689wnlRj7KjXyUG/koN6VrcHkZNAj5U6eiddOm4FTefewXJCcDHAcVI6NK7arB5aYG1WZuBmEQRqeNBgcONvo2AIDM/EzsidyDCXYToKemV6PHq2l1cd4UflNfEVUqfgcOHIjFixfj/v376NChAzQ1NWXWDx06tCq7rXU+Pj7lbqOmpgY1tZIDTQsEgjr9Q6/r471PKDfyUW7ko9zIR7kpXUPKi6B1a/53xhgSly1HzsOHsNi4EVof9Kj8/hpQbmpabeWmrXFbmeV99/Zhd+Ru/PbkN0xymISJ9hOhKdCU8+j6oTbPm8rst0rF78yZMwG8649bHMdxNTYGcJMmTaCsrIyXL1/KtL98+RKmpqY1cgxCCCGkMZGkp0OSkQGWmwuBhYWiwyFV1Nm0M0JehODR60f4SfQTDj86jGntpmGU7SiaLa4cVRrqTCqVyv2pyckvVFVV0aFDB1y6dEnm2JcuXYKrq2uNHac0fn5+sLe3R6dOnWr1OIQQQkhdUtHXh9XhQ2i+xx9qLaz59vxnzxQYFamsbhbdcGTIEXzX8zs012mO17mv8W3otxhyYghOPDmBAmnJUbDIO1UqfmtSVlYWRCIRP2JDXFwcRCIREhISAADz5s3Dzp07sWfPHkRFReHTTz/F27dv+dEfaouvry8iIyMRGhpaq8chhBBC6honEMjMCpefkIC/h3rhn9lzIM3OVlxgpFKUOCV4WHvghNcJrHBdAWMNYyS9TcLyG8sxLGAYzsWfo9niSlGp4nfQoEHIyMjgl9evX4/09HR+OTU1Ffb29pUKICwsDO3bt0f79u0BvCt227dvzw9FNnr0aGzcuBHLly+Hs7MzRCIRzp49W+ImOEIIIYRUTfadO2BiMSRpaeDU1RUdDqkkgZIAH9p8iMBhgZjfcT701PQQnxmP+X/Ox5jTYxDyPIRmiyuiUn1+z507JzMG7tq1azFq1Cjo6ekBeDcGcHR0dKUC6N27d7kvyKxZszBr1qxK7ZcQQgghFaPn7Q211q2hrKsLTunddTEmkUD65g2U//2MJ/Wfuoo6JjlMwojWI7A3ci/2PNyDqNdR+OTiJxjcYjDWf7Be0SHWC5W68lu8SG3I/0VQn19CCCGNidDBAapFJq967e+P2CGeeHPligKjIlWhpaqFmc4zETQiCBPsJ0BVSRWdTTsrOqx6Q+F9fusr6vNLCCGksWISCTIDz0CSkgLJ69eKDodUkYG6ARZ2WojA4YEY2vK/YWj/iP0Di64uwrPMxnmTY6W6PXAcV2JWEZplhBBCCGlYOGVlND90EJmnTkF3+HC+nW6Gez+Zav43PKxEKsFPop/wPOs57Azs4NPWR3GBKUilil/GGHx8fPhJIHJzc/HJJ5/wk1wU7Q9MCCGEkPeXkpoa9D78kF9mYjGe+0yGiYYQkh49IDA0VGB0pKqUlZSxqfcm7IvchzFtxvDtj9Mew0TDBLpqugqMrm5UqvidNGmSzPJHH31UYpuJEydWL6J6ws/PD35+fjU6bjEhhBDyvnp7+zbyHj2CllAIlp+v6HBINdgb2mPdB+v4ZYlUgkVXFyHpbRJ8HHwwwX4CNAQaCoywdlWq+N29e3dtxVHv+Pr6wtfXF5mZmdDVbfj/BRFCCCFl0ereHRZ7/HH70iXYNmnCt7OCAnAqVZowltQTKTkpUOKUkCXOwv9E/8PBRwcxw3EGRtqMhKqyqqLDq3F0wxshhBBCKkTYvj3eFhnPP+f+A8QOHISskBAFRkWqy0TTBL97/o4NH2yApbYlXue+xvrb6+F5whMnY05CIm1Y34JT8UsIIYSQKkn56SeInz1DxrFjig6FVJMSp4RBLQYhwDsAy7oug7HQGC/evsCykGUY/sdwXHh6ocEMcUvFLyGEEEKqxOL7jTCcNhUmy5bxbQ2lQGqsBEoCjLIdhcDhgfiiwxfQVdPF3xl/Y17wPIwNHIsbL268968xFb+EEEIIqRIlDQ0Yz58PFX19vi352++Q9PU3NCzae05dRR0+bX0QNDwIHzt+DKGKEA9TH+LjCx9j2vlpiMuIU3SIVUbFrxw0wxshhBBSOfnPnuH1nj1IO3AA2eF3FB0OqQHaqtqY1X4WgoYH4SO7jyBQEkCULIJQRajo0KqMbs+Ug0Z7IIQQQipH1dISljt/Rvat29D6oIeiwyE1yFBoiEWdF2Gi/UREpETITJyxP3I/eln2gqW2pQIjrDi68ksIIYSQGqPVvTuM583ll6Vv3yJh6jRk36ErwQ2BmZYZPKw8+OV7r+5hQ+gGDAsYhte578dU2HTllxBCCCG1JmX7drwNCUH+06doGXQGnECg6JBIDdJQ0UA3824wEhrBQN2Ab8+T5EFNWU2BkclHxS8hhBBCao3h9OkoSEmF7lBPKnwboFb6rbCj/w6IJWK+7e+MvzEpaBLW9FiDnk17KjC60lHxSwghhJBao6yjA/N1a2Xasq5dR/btW2gyaxaU1Orn1UFSOQLl//6xOfb4GN6K36K1XmsFRiQfFb9y+Pn5wc/PDxJJw5rVhBBCCFEkaW4uEpctQ0FSEpQ0NdHkk08UHRKpYfM6zMOgFoNgpmWm6FBKRTe8yeHr64vIyEiEhoYqOhRCCCGkwVBSV4fpV0sh7NABBpMmKTocUguUlZThYOig6DDkouKXEEIIIXVK280Nzffvg5Lwv7FiX/24FTkPHyowKtJYUPFLCCGEkDrHcRz/+5tLl5Dy0094OnYcCl69UmBUpDGgPr+EEEIIUSihszO03d2h2qwZVIyMFB0OaeCo+K0hEokEYrG4/A3LIRaLoaKigtzcXLrZrhjKjXyUG/kacm4EAgGUlZUVHQYh1aZiaIimW34AK/I3WpCSgvQTJ2Do40NDpJEaRcVvNTHGkJSUhPT09Brbn6mpKZ49eybzlRCh3JSFciNfQ8+Nnp4eTE1NG+RzI40P9+8/c4wxJK1ahTcXLiI/9m+Yr1+n4MhIQ0LFbzUVFr7GxsbQ0NCo9geQVCpFVlYWtLS0oKREXbKLotzIR7mRr6HmhjGG7OxsJCcnAwDMzOrnkEKEVJX2AHdk3xXBwIdGhCA1i4pfOSoyzq9EIuELX0NDwxo5rlQqRX5+PtTV1RvUB3VNoNzIR7mRryHnRvjvnfLJyckwNjamLhCkweA4DrqeQ6A9oL/MJBhvgoOhamkJtZYtFRgded81rE+CGlSRcX4L+/hqaGjUVViEECKj8P2nJu45IKS+KVr4ipOS8GLBQsQNG46ciAgFRkXed3TltwZQXztCiKLQ+w9pNJSUIGzvDEl6BtQd6u8ECqT+o+KXEEIIIfWewNgYljt2QJqZCU7lXfnCGMObs2ehPWAAf7McIeWhbg+EEEIIeS9wHAdlXV1+Of3IETyfOw/Pps8AY0yBkZH3CRW/hCiQlZUVfvjhB36Z4zicPHlSYfHUNn9/f+jp6fHLK1euhLOzM7/s4+MDb2/vOo+LEPJ+4lTVoKShAa3evagLEKkwKn4bKR8fH3AcB47jIBAIYGJigv79+2PXrl2QSqWKDq9SihdQ77PExEQMHDiwRvdZvMBWpNGjR+Px48eKDoMQ0kDoDR+GFmcCof/RR3xb/j//IP/ZMwVGReo7Kn4bMQ8PDyQmJiI+Ph5BQUHo06cPZs+ejSFDhqCgoEDR4b0XGGM1mitTU1OoFbm7uaERCoUwNjZWdBiEkAZEYGoK7t9hDJlEghcLF+FvL2+8uXxFwZGR+oqK3xrGGEN2fkG1fnLyJVV6XGX7O6mpqcHU1BQWFhZwcXHBl19+iYCAAAQFBcHf35/fLj09HdOmTYORkRF0dHTQt29fRBQZZiYiIgJ9+vSBtrY2dHR00KFDB4SFhfHrQ0JC0Lt3b2hoaEBfXx/u7u5IS0sD8G4M1nXr1sHa2hpCoRBOTk44evQo/9jg4GBwHIdLly6hc+fOMDc3R48ePRAdHQ3g3dfoq1atQkREBH8luzD28uIuzY0bN+Ds7Ax1dXV07NgRJ0+eBMdxEIlEMvEEBQWhQ4cOUFNTw/Xr1xEbGwsvLy+YmJhAS0sLnTp1wsWLF2X2nZycDE9PTwiFQlhbW+PAgQMljl+828OzZ88watQo6OnpwcDAAF5eXoiPj+fXF3YT+P7779GmTRsYGRnB19eXH/aqd+/eePr0KebOncvnpzTjxo3D6NGjZdrEYjGaNGmCvXv3AgDOnj2LHj16QE9PD4aGhhgyZAhiY2P57ePj48FxHI4fP44+ffpAQ0MDTk5OuHnzJr9N8W4P5SnvmIQQUpT0zRtwysrgAKjb2ig6HFJP0WgPNSxHLIH98nMKOXbkandoqFbvJe3bty+cnJxw/PhxTJs2DQAwcuRICIVCBAUFQVdXFzt27EC/fv3w+PFjGBgYYPz48Wjfvj22bdsGZWVliEQiCP6dh10kEqFfv36YMmUKtmzZAhUVFVy5coWfPGTdunXYv38/tm/fjtatW+Pq1av46KOPYGRkhF69evFxLV26FN999x2EQiEWLlyIKVOmICQkBKNHj8aDBw9w9uxZvtjU/fdmiPLiLi4zMxOenp4YNGgQDh48iKdPn2LOnDml5mnx4sXYuHEjWrRoAX19fTx79gyDBg3CmjVroKamhr1798LT0xPR0dFo1qwZgHeF6osXL3DlyhUIBAJ8/vnn/OxcpRGLxXB3d4erqyuuXbsGFRUVfPPNN/Dw8MC9e/egqqoKALhy5QpMTU3xxx9/ICkpCWPHjoWzszOmT5+O48ePw8nJCTNmzMD06dPlHmv8+PEYOXIkPxMaAJw7dw7Z2dkYNmwYAODt27eYN28eHB0dkZWVheXLl2PYsGEQiUQyk0csXboUGzduROvWrbF06VKMHTsWMTExUFGp/LlZ0WMSQggAKOvpodkef+TFxEBgYcG350ZHQ83GhvoFEwBU/MpVkRneGqo2bdrg3r17AIDr16/j9u3bSE5O5r+O37hxI06ePImjR49ixowZSEhIwIIFC9CmTRsAQOvWrfl9ffvtt+jYsSN++uknvs3h3/EZ8/LysHbtWly8eBGurq4AgBYtWuD69evYsWOHTPG7Zs0a9OrVC5mZmVi4cCE8PT2Rm5sLoVAILS0tqKiowNTUlN++InEXd/DgQXAch507d0JdXR329vZ4/vx5qUXj6tWr0b9/f37ZwMAATk5O/PLXX3+NEydO4I8//sCsWbPw+PFjBAUF4fbt2+jUqRMA4Ndff4WdnZ3c1+HIkSOQSqX45Zdf+Dfs3bt3Q09PD8HBwRgwYAAAQF9fH1u3bsXbt2/RsWNHDB48GJcuXcL06dNhYGAAZWVlaGtry+SnOHd3d2hqauLEiROYMGECn4+hQ4dCW1sbADBixAiZx+zatQtGRkaIjIxE27Zt+fb58+dj8ODBAIBVq1bBwcEBMTEx/PlRGRU9JiGEFOKUlKBu899V37wnTxD/4UhodO6Mpj9ugZKmpgKjI/UBFb9y+Pr6wtfXF5mZmfyVxIoQCpQRudq9yseVSqV4k/kG2jralb6yJRTUzBiHjDG+2IqIiEBWVlaJ6ZtzcnL4r5/nzZuHadOmYd++fXBzc8PIkSPR8t+pJ0UiEUaOHFnqcWJiYpCdnS1TRAJAfn4+2rdvL9Pm6OjI/25mZgbgXTeCwquqxVUk7uKio6Ph6OgIdXV1vq1z586lbtuxY0eZ5aysLKxcuRKBgYFITExEQUEBcnJykJCQAACIioqCiooKOnTowD+mTZs2ZXYBiIiIQExMDF98FsrNzZV5Dg4ODjLT2pqZmeH+/fty91saFRUVjBo1CgcOHMCECRPw9u1bBAQE4PDhw/w2T548wfLly3Hr1i2kpKTwN0YmJCTIFKLyXquqFL8VPSYhhMiT+/gxoKQETkUFHM3ISkDFb43jOK5aXQ+kUikKVJWhoaqisK91o6KiYG1tDeBdUWdmZobg4OAS2xUWbitXrsS4ceMQGBiIoKAgrFixAocPH8awYcMgFArlHicrKwsAEBgYCIsiX08BKHHTV2E3CuC/Ga3KGpWiInFXh2axKwfz58/HhQsXsHHjRrRq1QpCoRAffvgh8vPzq3yMrKwsdOjQodS+wUZGRvzvRXMDvMtPVUbsGD9+PHr16oXk5GRcuHABQqEQHh4e/HpPT080b94cO3fuhLm5OaRSKdq2bVviOVb2tSpLRY9JCCHy6A4eDHU7eyhpavLvSSw/HwVp6RCY0A24jREVv0TG5cuXcf/+fcydOxcA4OLigqSkJKioqMDKykru42xsbGBjY4O5c+di7Nix2L17N4YNGwZHR0dcunQJq1atKvEYe3t7qKmpISEhQaaLQ2WpqqqW6J5S0biLsrW1xf79+5GXl8cX36GhoRV6bEhICHx8fPj+sVlZWTI3prVp0wYFBQUIDw/nuz1ER0cjPT1d7j5dXFxw5MgRGBsbQ0dHp0JxlKa0/JSmW7dusLS0xJEjRxAUFISRI0fyhWxqaiqio6Oxc+dOfPDBBwDedS2pTYo4JiGkYVJrYS2znLLjZ7zeuxdmq1dBp4aHlyT1H90x0ojl5eUhKSkJz58/x507d7B27Vp4eXlhyJAhmDhxIgDAzc0Nrq6u8Pb2xvnz5xEfH48bN25g6dKlCAsLQ05ODmbNmoXg4GA8ffoUISEhCA0N5fuyLlmyBKGhoZg5cybu3buHR48eYdu2bUhJSYG2tjbmz5+PuXPnYs+ePYiNjcWdO3ewdetW7Nmzp8LPw8rKCnFxcRCJREhJSUFeXl65cZdm3LhxkEqlmDFjBqKionDu3Dls3LgRAMq9SaJ169Y4fvw4RCIRIiIi+H0VsrW1hYeHBz7++GPcunUL4eHhmDZtWplXxsePH48mTZrAy8sL165dQ1xcHIKDg/H555/jn3/+qVR+rl69iufPnyMlJaXMbceNG4ft27fjwoULGD9+PN+ur68PQ0ND/Pzzz4iJicHly5cxb968CsdQFYo4JiGk4WMSCd7euAHpmzeKDoUoCBW/jdjZs2dhZmYGKysreHh44MqVK/jxxx8REBDA9yHlOA5nzpxBz549MXnyZNjY2GDMmDF4+vQpTExMoKysjNTUVEycOBE2NjYYNWoUBg4cyF/ptbGxwfnz5xEREYHOnTvD1dUVAQEB/J3/X3/9NZYtW4Z169bBzs4OHh4eCAwM5LtdVMSIESPg4eGBPn36wMjICIcOHSo37tLo6Ojg1KlTEIlEcHZ2xtKlS7F8+XIAkOkHXJpNmzZBX18f3bp1g6enJ9zd3eHi4iKzze7du2Fubo5evXph+PDhmDFjRplj3mpoaODq1ato1qwZhg8fDjs7O0ydOhW5ubmVuhK8evVqxMfHo2XLljLdJUozfvx4REZGwsLCAt27d+fblZSUcPjwYYSHh6Nt27aYO3cuvvvuuwrHUBWKOCYhpOHjlJXRfN9eWGzZInPVV5KeTlMkNxIco1e6TIU3vGVkZJQoOHJzcxEXFwdra+tyi6OKkkqlyMzMhI6ODg3lVIwicnPgwAFMnjwZGRkZZV6lVTQ6b+Rr6LmpzvuQWCzGmTNnMGjQoBJ9xxszyot8DTU30rw8xA0fAVVrK5itXg2VUobDLE9DzU1NqIvclFWvFUd9fgkpYu/evWjRogUsLCwQERGBRYsWYdSoUfW68CWEEFI9OXfuID8hAZLMDIDGAm7wqPglpIikpCQsX74cSUlJMDMzw8iRI7FmzRpFh0UIIaQWabq6wvr33yBJT4eKvj7fLs3NhVINfbNL6g8qfgkpYuHChVi4cKGiwyCEEFLH1IuNRZ4dFoZ/5syF6bJl0HEfoKCoSG1oeB3gCCGEEEKqKdXfH5KUFGRdu6roUEgNoyu/hBBCCCHFWGzahNe7/aE/bizfxiQScMo1M5sqURwqfgkhhBBCilFSVUWTj2fItCWt/hosNwcmX34JZV1dBUVGqou6PRBCCCGElCM/IQHpR48iI+AP5D6KVnQ4pBroyq8cfn5+8PPzq9C0sIQQQghp2FSbNYPVgf14GxoKzS6d+XbGWLmzgJL6ha78yuHr64vIyEiEhoYqOhRC6kRCQgK+/vprZGdnKzoUQgipl4TOzmgyfTq/LMnIQPzoMci6dk2BUZHKouKXEAWysrLCDz/8wC9zHIeTJ08qJJZmzZrh5cuXmDVrlkKOTwgh75uUn39G7r17eLl2HVhBgaLDIRVExW8j5ePjA47jwHEcBAIBTExM0L9/f+zatQtSqVTR4VXKypUr4ezsrOgwakRiYiIGFplrviYUL7DL8uOPPyI1NRX79++v0RjeF8HBweA4Dunp6YoOhRDyHjCaNQv6EyfAbO0acCrUk/R9Qa9UI+bh4YHdu3dDIpHg5cuXOHv2LGbPno2jR4/ijz/+gAr9IZeLMQaJRFJjuTI1Na2R/VSVkpISAgICFBoDIYS8L5SEQph++SUAQCwWAwCyLl5E7q1bMJ6/AMpamooMj8hBV35rS/5b+T/i3LK3FWcX+T2nYvutAjU1NZiamsLCwgIuLi748ssvERAQgKCgIPj7+/PbpaenY9q0aTAyMoKOjg769u2LiIgIfn1ERAT69OkDbW1t6OjooEOHDggLC+PXh4SEoHfv3tDQ0IC+vj7c3d2RlpYGAJBKpVi3bh2sra0hFArh5OSEo0eP8o8tvBJ36dIldO7cGebm5ujRoweio9/daevv749Vq1YhIiKCv5JdGHt5cZfmxo0bcHZ2hrq6Ojp27IiTJ0+C4ziIRCKZeIKCgtChQweoqanh+vXriI2NhZeXF0xMTKClpYVOnTrh4sWLMvtOTk6Gp6cnhEIhrK2tceDAgRLHL97t4dmzZxg1ahT09PRgYGAALy8vxMfH8+t9fHzg7e2N77//Hm3atIGRkRF8fX35N+HevXvj6dOnmDt3Lp8feTZt2oR27dpBU1MTlpaWmDlzJrKyssrMF8dx2LFjB4YMGQINDQ3Y2dnh5s2biImJQe/evaGpqYlu3bohNjZW5nHbtm1Dy5YtoaqqCltbW+zbt69G9hsQEAAXFxeoq6ujRYsWWLVqFQqKfBXJcRx++eUXDBs2DBoaGmjdujX++OMPAEB8fDz69OkDANDX1wfHcfDx8QFQ+tVzZ2dnrFy5stoxE0IaDi4/H6++/gbph48g7eBBRYdD5GGkTBkZGQwAy8jIKLEuJyeHRUZGspycnJIPXKEj/2f/h7LbfmMqf9tdg2S33WBd+naVNGnSJObl5VXqOicnJzZw4EB+2c3NjXl6erLQ0FD2+PFj9sUXXzBDQ0OWmprKGGPMwcGBffTRRywqKoo9fvyY/fbbb0wkEjHGGLt79y5TU1Njn376KROJROzBgwds69at7NWrV++e+jffsDZt2rCzZ8+y2NhYtnv3bqampsaCg4MZY4xduXKFAWBdunRhly9fZjdv3mQffPAB69atG2OMsezsbPbFF18wBwcHlpiYyBITE1l2dnaF4i4uIyODGRgYsI8++og9fPiQnTlzhtnY2DAA7O7duzLxODo6svPnz7OYmBiWmprKRCIR2759O7t//z57/Pgx++qrr5i6ujp7+vQpv/+BAwcyJycndvPmTRYWFsa6devGhEIh27x5M78NAHbixAnGGGP5+fnMzs6OTZkyhd27d49FRkaycePGMVtbW5aXl8e/jjo6Ouzjjz9mt27dYgEBAUxDQ4P9/PPPjDHGUlNTWdOmTdnq1av5/MizefNmdvnyZRYXF8cuXbrEbG1t2aeffip3+8J4LSws2JEjR1h0dDTz9vZmVlZWrG/fvuzs2bMsMjKSde3alXl4ePCPOX78OBMIBMzPz49FR0ez77//nikrK7PLly9Xa79Xr15lOjo6zN/fn8XGxrLz588zKysrtmLFCpaWlsYkEgkDwJo2bcoOHjzInjx5wj7//HOmpaXFUlNTWUFBATt27BgDwKKjo1liYiJLT09njDHWvHlzmdeJsXd/JytWrKhWzDWhzPehcuTn57OTJ0+y/Pz8Go3pfUd5kY9yI19hbtKvX2cJn3zKJP++T5O6OW/KqteKo+K3HI2x+B09ejSzs7NjjDF27do1pqOjw3Jzc2W2admyJduxYwdjjDFtbW3m7+9f6r7Gjh3LunfvXuq63NxcpqGhwW7cuCHTPnXqVDZ27FjG2H/F5sWLF5lEImFpaWns1KlTDACf9xUrVjAnJyeZfVQk7uK2bdvGDA0NZV7PnTt3llr8njx5stR9FOXg4MC2bt3KGGMsOjqaAWC3b9/m10dFRTEAcovfffv2MVtbWyaVSvn1eXl5TCgUsnPnzjHG3r2OzZs3Z/n5+XyBN3LkSDZ69Gj+MaUVbhXx+++/M0NDwzK3AcC++uorfvnmzZsMAPv111/5tkOHDjF1dXV+uVu3bmz69Oky+xk5ciQbNOi/c70q++3Xrx9bu3atzH737dvHzMzMZIrfovvNyspiAFhQUBBj7L/XNy0tTWY/FS1+KxtzTaDit+ZRXuSj3MgnLzdSqZQlfv0NexsaqqDIFK++Fb/UqbO2fPlC/jqu2NSIC2L4X6VSKTLfvIGOtjaUlJQArljPlDn3azDI0rEiYxZGREQgKysLhoaGMtvk5OTwX9/OmzcP06ZNw759++Dm5oaRI0eiZcuWAACRSISRI0eWepyYmBhkZ2ejf//+Mu35+flo3769TJujoyP/u5mZGYB33QiaNWtW6r4rEndx0dHRcHR0hLq6Ot/WuXPnUrft2LGjzHJWVhZWrlyJwMBAJCYmoqCgADk5OUhISAAAREVFQUVFBR06dOAf06ZNG+jp6ZW6/8LnEBMTA21tbZn23Nxcmefg4OAA5SLTbZqZmeH+/cqfJxcvXsS6devw6NEjZGZmoqCgALm5ucjOzoaGhobcxxV9bUxMTAAA7dq1k2nLzc1FZmYmdHR0EBUVhRkzZGdN6t69O7Zs2VKt/UZERCAkJARr1qzht5FIJPxz0NHRKbFfTU1N6OjoIDk5ufwEVUBlYyaENHxvgoKQtn8/0n/7Da0uX4JKkyaKDqnRo+K3tqhWopN70W2lUkAgedemVEqX7Mrst4qioqJgbW0N4F1RZ2ZmhuDg4BLbFRZuK1euxLhx4xAYGIigoCCsWLEChw8fxrBhwyAUCuUep7A/aWBgICwsLGTWqampySwLBAL+98LCvKxRKSoSd3Voasq+DvPnz8eFCxewceNGtGrVCkKhEB9++CHy8/OrfIysrCx06NCh1L7BRkZG/O9FcwO8y09lR+yIj4/HkCFD8Omnn2LNmjUwMDDA9evXMXXqVOTn55dZ/Jb22lT29aqJ/WZlZWHVqlUYPny4zH6kUqnMPzRVyZeSkhIYYzJthf2qqxMzIaTh0/zgA+iN/BACCwsqfOsJKn6JjMuXL+P+/fuYO3cuAMDFxQVJSUlQUVGBlZWV3MfZ2NjAxsYGc+fOxdixY7F7924MGzYMjo6OuHTpElatWlXiMfb29lBTU0NCQgJ69epV5ZhVVVVLzMRX0biLsrW1xf79+5GXl8cX3xWd5CQkJAQ+Pj4YNmwYgHeFWNEb09q0aYOCggKEh4ejU6dOAN5daS5rSC0XFxccOXIExsbG1bpKWFp+igsPD4dUKsX333//7hsHAL/99luVj1kWOzs7hISEYNKkSXxbSEgI7O3tq7VfFxcXREdHo1WrVjLtUqkUmZmZFdqHqqoqAJTIl5GRERITE/nlzMxMxMXFVSteQkjjoKytDbOvv5b5B1qcmIi0Q4fRZOanUCryzzmpGzTaQyOWl5eHpKQkPH/+HHfu3MHatWvh5eWFIUOGYOLEiQAANzc3uLq6wtvbG+fPn0d8fDxu3LiBpUuXIiwsDDk5OZg1axaCg4Px9OlThISEIDQ0FHZ2dgCAJUuWIDQ0FDNnzsS9e/fw6NEjbNu2DSkpKdDW1sb8+fMxd+5c7NmzB7Gxsbhz5w62bt2KPXv2VPh5WFlZIS4uDiKRCCkpKcjLyys37tKMGzcOUqkUM2bMQFRUFM6dO4eNGzcCQLlTV7Zu3RrHjx+HSCRCREQEv69Ctra28PDwwMcff4xbt24hPDwc06ZNK/PK+Pjx49GkSRN4eXnh2rVriIuLQ3BwMD7//HP8888/lcrP1atX8fz5c6SkpJS6TatWrSAWi7F161b8/fff2LdvH7Zv317hY1TGggUL4O/vj23btuHJkyfYtGkTjh8/jvnz51drv8uXL8fevXuxatUqPHz4EFFRUTh8+DCWLVtW4X00b94cHMfh9OnTePXqFf/tRN++fbFv3z5cu3YN9+/fx6RJk2S6mhBCSHkKP0cYY0hcthypP/+MxOXLFRxV40TFbyN29uxZmJmZwcrKCh4eHrhy5Qp+/PFHBAQE8B/sHMfhzJkz6NmzJyZPngwbGxuMGTMGT58+hYmJCZSVlZGamoqJEyfCxsYGo0aNwsCBA/krvTY2Njh//jwiIiLQuXNnuLq6IiAggB8X9+uvv8ayZcuwbt062NnZwcPDA4GBgXy3i4oYMWIEPDw80KdPHxgZGeHQoUPlxl0aHR0dnDp1CiKRCM7Ozli6dCmW//vGpF7Of+abNm2Cvr4+unXrBk9PT7i7u8PFxUVmm927d8Pc3By9evXC8OHDMWPGDBgbG8vdp4aGBq5evYpmzZph+PDhsLOzw9SpU5Gbm1upK8GrV69GfHw8WrZsKdNdoignJyds2rQJGzZsQNu2bXHgwAGsW7euwseoDG9vb2zZsgUbN26Eg4MDduzYgd27d6N3797V2q+7uztOnz6N8+fPo1OnTujatSs2b94st194aSwsLLBq1SosXrwYJiYm/Gx3S5YsQa9evTBkyBAMHjwY3t7efL92QgipDI7joD9+HASWlmjyyaeKDqdR4ljxjmxERmZmJnR1dZGRkVGi4MjNzUVcXBysra3LLY4qqvArWh0dHf7rZ/KOInJz4MABTJ48GRkZGWVepVU0Om/ka+i5qc77kFgsxpkzZzBo0KASfaEbM8qLfJQb+SqbG1ZQIDMrXOaZMxBYNoOwXdvaDFMh6uK8KateK476/BJSxN69e9GiRQtYWFggIiICixYtwqhRo+p14UsIIeT9U7TwzX/2DC+WfgWWnw+rA/shdHZWXGCNABW/hBSRlJSE5cuXIykpCWZmZhg5cqTM0FmEEEJITVPS0oJ2nz4oSEmBepEhE0ntoOKXkCIWLlyIhQsXKjoMQgghjYiKvj4sNn0PaU4OuH+7ZzGJBOlHj0FvmDe4f0eiITWj4XWAI4QQQgh5DykV6WL3es9eJK1YgYQpU0uMM06qh4pfQgghhJB6RmBuDmU9Peh6e5U73CapnEbR7cHKyoq/01tfXx9XrlxRdEiEEEIIIXLpeLhDo0tnKBeZlTQvNhZMIoG6jY3iAmsAGkXxCwA3btyAlpaWosMghBBCCKkQFX19/ncmFuPFgoXIe/IE5t9vhM6AAQqM7P1G3R4IIYQQQuo5aU4OVIyNwWlo0FBo1aTw4vfq1avw9PSEubk5OI7DyZMnS2zj5+cHKysrqKuro0uXLrh9+3aljsFxHHr16oVOnTrhwIEDNRQ5IfJt2bIFN2/eVHQY7zWRSITvvvsOBQUFig6FEEIUTllHB023/QTrY0chKDI7aHZ4OJhEosDI3j8K7/bw9u1bODk5YcqUKRg+fHiJ9UeOHMG8efOwfft2dOnSBT/88APc3d0RHR3NTw3r7Oxc6gfk+fPnYW5ujuvXr8PCwgKJiYlwc3NDu3bt4ChnHL28vDzk5eXxy5mZmQDezU4iFotlthWLxWCMQSqVQiqVVjkHRRXe0Vm4X/Kf9yU3mzZtwqlTpzBjxow6i1Nebvz9/TFv3jy8fv0aALBq1SoEBATgzp07cvdVOBVyeHg4nBV0deH169cYMWIENm/eDCUlpWrl8X05b6pKKpWCMQaxWMxPS15Rhe9pxd/bGjvKi3yUG/nqKjeciQl/jNyHD/HPxElQb9sW5j/vgJKGRq0eu6rqIjeV2Xe9mt6Y4zicOHEC3t7efFuXLl3QqVMn/O9//wPw7o3e0tISn332GRYvXlzpYyxYsAAODg7w8fEpdf3KlSuxatWqEu0HDx6ERrGTSkVFBaamprC0tITqezYG38yZM3Ho0CEA756Hvr4+HBwcMGLECIwbN+69mgZ2/fr1CAwMxLVr1xQdCv766y8sWLAAp0+fhq6urqLDwcGDB7FkyRI8ffoUAJCVlYX8/HwYGBgAeHceZGRkyHwjIpFIkJKSAkNDQ6io1P3/x4wxjBkzBgMHDpT7d0r+k5+fj2fPniEpKYmukhPSyGg9eACT335Htq0tEsePU3Q4CpWdnY1x48a9/9Mb5+fnIzw8HEuWLOHblJSU4ObmVuGvlN++fQupVAptbW1kZWXh8uXLGDVqlNztlyxZgnnz5vHLmZmZsLS0xIABA0okMzc3F8+ePYOWlhbU1dUr+exKxxjDmzdvoK2tXatDmwgEAri7u2PXrl2QSCR4+fIlzp07hyVLliAwMBABAQEKKXzKIi83ampqUFZWLvdkr62YJBIJn6sBAwZggAJuQpCXG3V1dXAcx+emeI4EAgFUVFRKtOsXuclCEYKCgmpsX3X1N6Uoubm5EAqF6NmzZ6Xfh8RiMS5cuID+/ftDIBDUUoTvH8qLfJQb+RSSm0GDIJ4wAUrq6mj/7/u2NDcXklevILC0rJsYKqAuclP4TX2FsHoEADtx4gS//Pz5cwaA3bhxQ2a7BQsWsM6dO1don7GxsczR0ZE5OjoyBwcH9sMPP1QqpoyMDAaAZWRklFiXk5PDIiMjWU5OTqX2WRaJRMLS0tKYRCKpsX2WZtKkSczLy6tE+6VLlxgAtnPnTr4tLS2NTZ06lTVp0oRpa2uzPn36MJFIxK8XiUSsd+/eTEtLi2lrazMXFxcWGhrKr79+/Trr1asXEwqFTE9Pjw0YMIC9fv2aMfbu+a5du5ZZWVkxdXV15ujoyH7//Xf+sVeuXGEA2MWLF1mHDh2YUChkrq6u7NGjR4wxxnbv3s0AyPzs3r27QnEXFxcXxwCwQ4cOMVdXV6ampsYcHBxYcHBwiXjOnDnDXFxcmEAgYFeuXCn3eTDG2IMHD9jgwYOZtrY209LSYj169GAxMTF8HlatWsUsLCyYqqoqc3JyYkFBQSViO3bsGOvduzcTCoXM0dGR/9soPG9+/fVXZmlpyYRCIfP29mYbN25kurq6/H5WrFjBnJyc+N+L5+7KlSv8se7evcs/Ljg4mHXq1ImpqqoyU1NTtmjRIiYWi/n1vXr1Yp999hlbsGAB09fXZyYmJmzFihUyz7/wvPL29mZCoZC1atWKBQQEyGxz//595uHhwTQ1NZmxsTH76KOP2KtXr/j1FclzcXX1N6Uo1Xkfys/PZydPnmT5+fm1ENn7i/IiH+VGvvqSm6T1G1iUkzNLO3ZcoXEUVRe5KateK+79+W67ilq0aIGIiAhERETgwYMHmD17dp0cN1ucXemfAul/X1kWSAuQLc5GbkFuhfZbU/r27QsnJyccP36cbxs5ciSSk5MRFBSE8PBwuLi4oF+/fnw/0vHjx6Np06YIDQ1FeHg4Fi9ezP9nJxKJ0K9fP9jb2+PmzZu4fv06PD09Ifm3c/66deuwd+9ebN++HQ8fPsTcuXPx0Ucf4c8//5SJa+nSpfjuu+9w+fJlqKioYMqUKQCA0aNH44svvoCDgwMSExORmJiI0aNHVyhueRYsWIAvvvgCd+/ehaurKzw9PZGamiqzzeLFi7F+/XpERUXB0dGx3Ofx/Plz9OzZE2pqarh8+TLCw8MxZcoU/mvqLVu24Pvvv8fGjRtx7949uLu7Y+jQoXjy5EmJPMyfPx8ikQg2NjYYO3Ysv4+wsDBMnz4ds2bNgkgkQp8+ffDNN9/IfZ7z58/HqFGj4OHhweeuW7duJbZ7/vw5Bg0ahE6dOiEiIgLbtm3Dr7/+WmLfe/bsgaamJm7duoVvv/0Wq1evxoULF2S2WbVqFUaNGoV79+5h0KBBGD9+PP96pKeno2/fvmjfvj3CwsJw9uxZvHz5UuabmoqeL4QQ0hixggLkRT8Cy82Fsr6eosOpv2qtBK8CFLvym5eXx5SVlWXaGGNs4sSJbOjQobUay//+9z9mZ2fHbGxsqnTlt61/20r/nI07y1+lCvo7iLX1b8t8gnxk9vvBoQ9KfWxlybvyyxhjo0ePZnZ2dowxxq5du8Z0dHRYbm6uzDYtW7ZkO3bsYIwxpq2tzfz9/Uvd19ixY1n37t1LXZebm8s0NDRKXNmfOnUqGzt2LGNM9spvYW5OnTrFAPB5L3o1s1BF4i6u8Irn+vXr+TaxWMyaNm3KNmzYIBPPyZMnK/U8lixZwqytreX+12tubs7WrFkj09apUyc2c+ZMmdh++eUXfv3Dhw8ZABYVFcUkEgkbMWIEGzhwoMw+Ro8eLffKL2OlnwfFr/x++eWXzNbWlkmlUn4bPz8/pqWlxV9N7dWrF+vRo0eJ+BctWsQvA2BfffUVv5yVlcUA8Fe4v/76azZgwACZfTx79owBYNHR0RXKc2noyq989eVKVX1DeZGPciNffcmNVCJhWSEhMm35SUlMqsD3wPp25bd+deosRlVVFR06dMClS5f4m+CkUikuXbqEWbNm1eqxfX194evri8zMzHpx41JdYozxfSMjIiKQlZUFQ0NDmW1ycnIQGxsLAJg3bx6mTZuGffv2wc3NDSNHjkTLli0BvLvyO3LkyFKPExMTg+zsbPTv31+mPT8/H+3bt5dpKzo6h5mZGQAgOTkZzZo1K3XfFYlbHldXV/53FRUVdOzYEVFRUTLbdOzYsVLPQyQS4YMPPii1r1NmZiZevHiB7t27y7R3794dERERMm3y8mBjY4PHjx9jxIgRJZ7L2bNny3y+5YmKioKrq6tMf9nu3bsjKysL//zzD/8aFB9BxczMDMnJyXLj19TUhI6ODr9NREQErly5UupkNLGxsRCLxRU+XwghpLHilJSgWeRbPOnbt3j60QQImlrAfMMGmWHSGiuFF79ZWVmIiYnhl+Pi4iASiWBgYIBmzZph3rx5mDRpEjp27IjOnTvjhx9+wNu3bzF58mQFRl2+W+NuVfoxqsr/jRjR17Ivbo27BSVOtmfK2RHVK2QqIioqCtbW1gDevT5mZmYIDg4usZ3ev1Murly5EuPGjUNgYCCCgoKwYsUKHD58GMOGDYNQKJR7nKysLABAYGAgLCwsZNapqanJLBctGguLsLKGrapI3NWhqakpcyyg7OdRVh4qo7J5qEvFC3uO40rEVtY2WVlZ8PT0xIYNG0rs28zMDA8ePABQsfOFEELIOzkPHqLg1SswSUG9HQqtrim8+A0LC0OfPn345cKRFiZNmgR/f3+MHj0ar169wvLly5GUlARnZ2ecPXsWJiYmigq5QjQEVTvBCgsBFSUVqCqVHD6tqvutqMuXL+P+/fuYO3cuAMDFxQVJSUlQUVGBlZWV3MfZ2NjAxsYGc+fOxdixY7F7924MGzYMjo6OuHTpUqnDx9nb20NNTQ0JCQno1atXlWNWVVXl+xAXqmjcpfnrr7/Qs2dPAEBBQQHCw8PL/KahIs/D0dERe/bsgVgsLlEA6ujowNzcHCEhITKPDwkJQefOnSsct42NDW7dkv2n66+//irzMaXlrjg7OzscO3ZM5huBkJAQaGtro2nTphWOrzwuLi44duwYrKysSh1ppKbOF0IIaUw0u3RGi5MnIElPh3KRb9YkmZlQVsAoSfWBwm946927NxhjJX78/f35bWbNmoWnT58iLy8Pt27dQpcuXWo9Lj8/P9jb26NTp061fixFycvLQ1JSEp4/f447d+5g7dq18PLywpAhQzBx4kQAgJubG1xdXeHt7Y3z588jPj4eN27cwNKlSxEWFoacnBzMmjULwcHBePr0KUJCQhAaGgo7OzsA74aOCw0NxcyZM3Hv3j08evQI27ZtQ0pKCrS1tTF//nzMnTsXe/bsQWxsLO7cuYOtW7diz549FX4eVlZW/DcGKSkpyMvLKzfusvj5+eHEiRN49OgRfH19kZaWxt9gV5qKPI9Zs2YhMzMTY8aMQVhYGJ48eYJ9+/YhOjoawLub7DZs2IAjR44gOjoaixcvhkgkqtQNmh9//DHOnTuHjRs34smTJ/jf//5XbpcHKysr3Lt3D9HR0UhJSSl1kPCZM2fi2bNn+Oyzz/Do0SMEBARgxYoVmDdvXo2OB+3r64vXr19j7NixCA0NRWxsLM6dO4fJkydDIpHU2PlCCCGNjaqVlcyUyFnXriOmnxvSj59QXFCKVGs9jxuIhjzUGf4d3kpFRYUZGRkxNzc3tmvXrhLHzszMZJ999hkzNzdnAoGAWVpasvHjx7OEhASWl5fHxowZwywtLZmqqiozNzdns2bNkslJcHAw69atG1NTU2N6enrM3d2dpaWlMcYYk0ql7IcffmC2trZMIBAwIyMj5u7uzv7880/G2H83mBXmJC0tjYWHhzMALC4ujjH27oazESNGMD09PZmhzsqKuzSFN3odPHiQde7cmamqqjJ7e3t2+fJlfpui8RRV3vNgjLGIiAg2YMAApqGhwbS1tdkHH3zAYmNjGWPvXveVK1cyCwsLJhAI5A51VnT4sbS0NH54ssLc7Ny5kzVt2pQJhULm6elZ5lBnjDGWnJzM+vfvz7S0tKo91Nns2bNlcuLl5cUmTZrEL6PYDa2MMaarq8u/Xowx9vjxYzZs2DCmp6fHhEIha9OmDZszZw5/s11F8lwc3fAmX325Qae+obzIR7mR733KzbPPZ7NI2zYs8Zs15W9cA+rbDW/1aoa3+qjwhrfSZgzJzc1FXFwcrK2ta2ySC6lUiszMTOjo6LxXs6zVhdrOTXx8PKytrXH37l2FTetbVXTeyNfQc1Od9yGxWIwzZ85g0KBBNGFBEZQX+Sg38r1PuWESCdKOHIGetzffD1ianw9OIKiVyYDqIjdl1WvFNbxPAkIIIYQQIhenrAyDceNkboBL/Oor/OM7CwWvXikwsrqh8BveCCGEEEKI4uQ/fYo3QWfBJBKInz+HipGRokOqVVT8yuHn5wc/P79y74QnDYeVlRWoFxAhhJDGRrV5c1gdPYqcO+EyN8YxqRRcA+wu1vCeUQ3x9fVFZGQkQkNDFR0KIYQQQkitUre1gf7YsfxyQWoq/vYcisxqTpRUH1HxSwghhBBCZKT+ugv5sbFI2bYdrKBA0eHUKOr2QAghhBBCZBjPmQ0ldXVo93cDV8rEQ+8zuvJLCCGEEEJkcKqqMPr8M6j/O2kVAKSfPInnX8xHQVqaAiOrPip+5WgMM7wRQgghhFSENCcHyRu+RWZgIDJOnFR0ONVCxa8cdMMbIYQQQsg7SkIhLH/eAZ2hnjCYOEHR4VQLFb+ENBDp6elYvXo1EhMTFR0KIYSQBkjYrh0svv2W7wPMGMOLRYvxJjhYsYFVEhW/hDQAjDF8+umnyMnJgZmZmaLDgY+PD7y9vfnl3r17Y86cOWU+xt/fH3p6erUaFyGEkJqT+ccfyAgIwPM5c1GQkqLocCqMit9GysfHBxzH4ZNPPimxztfXFxzHwcfHp+4Dq4KVK1fCucig3I3Rxo0boa2tjbVr1yo6lFIdP34cX3/9Nb9sZWWFH374QWab0aNH4/Hjx3UcWf0WHBwMjuOQnp6u6FAIIaQEbXd3GPj4wHjePKg0aaLocCqMit9GzNLSEocPH0ZOTg7flpubi4MHD6JZs2YKjOz95u/vj969e9fqMfLz82WWFyxYgJ9//hkcx9XqcavKwMAA2traZW4jFAphbGxcRxERQgipLiV1dZgsXiTTBzj/6VMkrV4NSVaWAiMrGxW/clR3tAdpdjak2dky0+Wy/Px37cUKF35bqfS/bcXid+15eRXatipcXFxgaWmJ48eP823Hjx9Hs2bN0L59e5lt8/Ly8Pnnn8PY2Bjq6uro0aOHzM2AhVeozp07h/bt20MoFKJv375ITk5GUFAQ7OzsoKOjg3HjxiE7O/u/5yOVYt26dbC2toZQKISTkxOOHj1aYr+XLl1C586dYW5ujh49eiA6OhrAu0Jz1apViIiIAMdx4DgO/v7+iI+PB8dxEIlE/L7S09PBcRyC/+2bVNWYa1rh1/0nT55E69atoa6uDnd3dzx79ozfpvDq9i+//AJra2uoq6vzz2natGkwMTFBs2bN4ObmhoiICJn9nzp1Cp06dYK6ujqaNGmCYcOG8evS0tIwceJE6OvrQ0NDAwMHDsSTJ09KxHbu3DnY2dlBS0sLHh4eMv2KJRIJ5s2bBz09PRgaGmLhwoUlpoku2u2hd+/eePr0KebOncu/ZkWPVdS2bdvQsmVLqKqqwtbWFvv27ZNZz3EcfvnlFwwbNgwaGhpo3bo1/vjjD359cHAwlJWV8eeff6Jz587Q0NBAt27d+POnUEBAAFxcXKCuro4WLVpg1apVKCgyqDvHcdixYweGDBkCDQ0N2NnZ4ebNm4iJiUHv3r2hqamJbt26ITY2ttL7lRd/fHw8+vTpAwDQ19d/r76NIYQ0TowxJC79CmkHDyFp9WpFhyMfI2XKyMhgAFhGRkaJdTk5OSwyMpLl5OSUWBdp24ZF2rZh4tRUvu3Vtm0s0rYNe/HVVzLbRjm3Z5G2bVjes3+YRCJhaWlp7NXu3SzStg3754v5MttGd3VlkbZtWO7jx3zb6yNHKv28Jk2axLy8vNimTZtYv379+PZ+/fqxzZs3My8vLzZp0iS+/fPPP2fm5ubszJkz7OHDh2zSpElMX1+fpf77/K5cucIAsK5du7Lr16+zO3fusFatWrFevXqxAQMGsDt37rCrV68yQ0NDtn79en6/33zzDWvTpg07e/Ysi42NZbt372ZqamosODhYZr9dunRhly9fZjdv3mQffPAB69atG2OMsezsbPbFF18wBwcHlpiYyBITE1l2djaLi4tjANjdu3f5Y6WlpTEA7MqVK9WKuTy7d+9mvXr1qtT2AoGAdezYkd24cYOFhYWxzp0788+RMcZWrFjBNDU1mYeHB7tz5w6LiIhgjDHm5ubGPD092a1bt1hYWBibN28eMzQ05F+X06dPM2VlZbZ8+XIWGRnJRCIRW7t2Lb/foUOHMjs7O3b16lUmEomYu7s7a9WqFcvPz5eJzc3NjYWGhrLw8HBmZ2fHxo0bx+9jw4YNTF9fnx07doxFRkayqVOnMm1tbebl5cVv06tXLzZ79mzGGGOpqamsadOmbPXq1fxrVngsXV1d/jHHjx9nAoGA+fn5sejoaPb9998zZWVldvnyZX4bAKxp06bs4MGD7MmTJ+zzzz9nWlpaJc7Ljh07ssuXL7OHDx/KnD+MMXb16lWmo6PD/P39WWxsLDt//jyzsrJiK1eulDmOhYUFO3LkCIuOjmbe3t7MysqK9e3bl509e5ZFRkayrl27Mg8Pj0rvV178BQUF7NixYwwAi46OZomJiSw9Pb3E+VPW+1B58vPz2cmTJ/nXm7xDeZGPciMf5eadrFu3WKyXN8t79g/fVhe5KateK46K33I09OI3OTmZqampsfj4eBYfH8/U1dXZq1evZIrfrKwsJhAI2IEDB/jH5+fnM3Nzc/btt98yxv4rMi5evMhvs27dOgaAxcbG8m0ff/wxc3d3Z4wxlpubyzQ0NNiNGzdkYps6dSobO3Zsif0W5ubUqVMMAJ/3FStWMCcnJ5l9VKb4rUzMFVGV4hcA++uvv/i2qKgoBoDdunWLf44CgYAlJyfz21y7do3p6Oiw3NxcPjcSiYS1bNmS7dixgzHGmKurKxs/fnypx338+DEDwEJCQvi2lJQUJhQK2W+//SYTW0xMDL+Nn58fMzEx4ZfNzMz484AxxsRiMWvatKnc4pcxxpo3b842b95cIg9Fi99u3bqx6dOny2wzcuRINmjQIH4ZAPuqyN9TVlYWA8CCgoIYY/+9xidPnmQSiYQxxlhgYKDM+dOvXz+ZfwgYY2zfvn3MzMxM7nFu3rzJALBff/2Vbzt06BBTV1fnl6uyX3nxp6WlMXmo+K15lBf5KDfyUW7+I5VKZZbrW/HbsOarq0ds74QDADihkG8znDIFBhMnAsWmCbQJuf5uW3V1FH5ZrD92LAxGjQKUlWW2bXXpIr9tIb0iX2NXlpGREQYPHgx/f38wxjB48GA0KdZpPTY2FmKxGN27d+fbBAIBOnfujKioKJltHR0d+d9NTEygoaGBFi1ayLTdvn0bABATE4Ps7Gz0799fZh/5+fklul0U3W/haAbJyck10je5MjGXJiEhAfb29vxyQUEBxGIxtLS0+LYvv/wSX375pdx9qKioyHSxadOmDfT09BAVFYXOnTsDAJo3bw4jIyN+m4iICGRlZcHQ0FBmXzk5OfzX7yKRCNOnTy/1mFFRUVBRUUGXLl34NkNDQ9ja2sq8rhoaGmjZsiW/bGZmhuTkZABARkYGEhMTZfahoqKCjh07luj6UFlRUVGYMWOGTFv37t2xZcsWmbair5+mpiZ0dHT4+Ao5ODjIxA/8d/5EREQgJCQEa9as4beRSCTIzc1FdnY2NDQ0ShzHxMQEANCuXTuZttzcXGRmZkJHR6dK+5UXPyGEvE/q6/0nhaj4rSVK/36wFcWpqoJTVS1z28K+vJxAACU1tYrtVyCoTqiYMmUKZs2aBeBdX+fqEBSJheM4meXCNum/zzHr387wgYGBsLCwkNlOrdhzL75fAPx+SqOk9K47e9ECTCynb3RlYi6Nubm5TN/i48eP49ixYzhw4ADfZmBgIPfxFaWpqSmznJWVBTMzMwQHB0MqlSIrKwtaWlpQUlLi+84Ki/zzVVWl5aO6hW1NqsjrVdb5k5WVhVWrVmH48OEl9q1e5J/M0vZR0/uVFz8hhJCaQ8UvgYeHB/Lz88FxHNzd3UusL7zhKCQkBM2bNwfwrpAMDQ0td+zWstjb20NNTQ0JCQno1atXlfejqqoKiUQi01Z4hTQxMZG/ily0QK1JKioqaNWqFb9sbGwMoVAo01aegoIChIWF8Vd5o6OjkZ6eDrsic6oX5+LigqSkJKioqKBZs2b8FcfCwh94d1Xx0qVLmDx5conH29nZoaCgALdu3UK3bt0AAKmpqYiOjpa5kl0WXV1dmJmZ4datW+jZsyf/XMLDw+Hi4iL3caW9ZqXFFxISgkmTJvFtISEhFY6tolxcXBAdHV2p16uu9qv67z/L5eWKEEJIxVHxS6CsrMx/za1crJsF8O6K46effooFCxbAwMAAzZo1w7fffovs7GxMnTq1ysfV1tbG/PnzMXfuXEilUvTo0QMZGRkICQmBjo6OTNFTFisrK8TFxUEkEqFp06bQ1taGUChE165dsX79elhbWyM5ORlfffVVlWOtbQKBAJ999hl+/PFHqKioYNasWejatStfDJfGzc0Nrq6u8Pb2xvr162Fubo7MzEwEBQVh2LBh6NixI1asWIF+/fqhZcuWGDNmDAoKCnDmzBksWrQIrVu3hpeXF6ZPn44dO3ZAW1sbixcvhoWFBby8vCoc++zZs7F+/Xq0bt0abdq0waZNm8odl9bKygpXr17FmDFjoKamVqKrDfBu+LZRo0ahffv2cHNzw6lTp3D8+HFcvHixwrFVxPLlyzFkyBA0a9YMH374IZSUlBAREYEHDx7gm2++Ueh+mzdvDo7jcPr0aQwaNAhCoVCmOw0hhJDKo6HOCABAR0cHOjo6ctevX78eI0aMwIQJE+Di4oKYmBicO3cO+vr61Tru119/jWXLlmHdunWws7ODh4cHAgMDYW1tXeF9jBgxAh4eHujTpw+MjIxw6NAhAMCuXbtQUFCADh06YM6cOdUqZGqbhoYGFi1ahHHjxqF79+7Q0tLCkSNHynwMx3E4c+YMevbsialTp6Jjx44YN24cnj59yvdJ7d27N37//Xf88ccfcHZ2Rt++fWX6L+/evRsdOnTAkCFD4OrqCsYYzpw5U+Kr+LJ88cUXmDBhAiZNmgRXV1doa2vLDKdWmtWrVyM+Ph4tW7aU6cdclLe3N7Zs2YKNGzfCwcEBO3bswO7du2t8DGV3d3ecPn0a58+fR6dOndC1a1ds3ryZ/5ZDkfu1sLDAqlWrsHjxYpiYmPDdkwghhFQdx+pT5716xM/PD35+fpBIJHj8+DEyMjJKFIe5ubmIi4uTGXe1uqRSaalfX5OGmxt/f3/MmTOnWrN4NdTc1ISGnpvqvA+JxWKcOXMGgwYNqtQ/PA0d5UU+yo18lBv56iI3mZmZ0NXVLbVeK67hfRLUEF9fX0RGRspM5EAIIYQQQt5vVPwSQgghhJBGg4pfQhTMx8enWl0eCCGEEFJxVPwSQgghhJBGg4rfGkD3DBJCFIXefwghpHKo+K2GwjsWs7OzFRwJIaSxKnz/obvLCSGkYmiSi2pQVlaGnp4ekpOTAbwbq7W681lLpVLk5+cjNze3QQ7LVB2UG/koN/I11NwwxpCdnY3k5GTo6emVOkENIYSQkqj4rSZTU1MA4Avg6mKMIScnB0KhsNqFdENDuZGPciNfQ8+Nnp4e/z5ECCGkfFT8VhPHcTAzM4OxsTHEYnG19ycWi3H16lX07NmTvsYshnIjH+VGvoacG4FAQFd8CSGkkqj4laPoDG8VoaysXCMfQsrKyigoKIC6unqD+6CuLsqNfJQb+Sg3hBBCimo4HeBqGM3wRgghhBDS8FDxSwghhBBCGg0qfgkhhBBCSKNBfX7LUTiAfGZmZp0cTywWIzs7G5mZmdQ/sRjKjXyUG/koN/JRbkpHeZGPciMf5Ua+ushNYZ1WkYl/qPgtx5s3bwAAlpaWCo6EEEIIIYSU5c2bN9DV1S1zG47R3JhlkkqlePHiBbS1tetkjNDMzExYWlri2bNn0NHRqfXjvU8oN/JRbuSj3MhHuSkd5UU+yo18lBv56iI3jDG8efMG5ubm5U5oRFd+y6GkpISmTZvW+XF1dHToj0cOyo18lBv5KDfyUW5KR3mRj3IjH+VGvtrOTXlXfAvRDW+EEEIIIaTRoOKXEEIIIYQ0GlT81jNqampYsWIF1NTUFB1KvUO5kY9yIx/lRj7KTekoL/JRbuSj3MhX33JDN7wRQgghhJBGg678EkIIIYSQRoOKX0IIIYQQ0mhQ8UsIIYQQQhoNKn4JIYQQQkijQcVvPePn5wcrKyuoq6ujS5cuuH37tqJDqnPr1q1Dp06doK2tDWNjY3h7eyM6Olpmm969e4PjOJmfTz75REER142VK1eWeM5t2rTh1+fm5sLX1xeGhobQ0tLCiBEj8PLlSwVGXHesrKxK5IbjOPj6+gJoXOfL1atX4enpCXNzc3Ach5MnT8qsZ4xh+fLlMDMzg1AohJubG548eSKzzevXrzF+/Hjo6OhAT08PU6dORVZWVh0+i9pRVm7EYjEWLVqEdu3aQVNTE+bm5pg4cSJevHghs4/SzrX169fX8TOpeeWdNz4+PiWet4eHh8w2DfG8KS8vpb3vcByH7777jt+moZ4zFfmsrsjnUkJCAgYPHgwNDQ0YGxtjwYIFKCgoqNXYqfitR44cOYJ58+ZhxYoVuHPnDpycnODu7o7k5GRFh1an/vzzT/j6+uKvv/7ChQsXIBaLMWDAALx9+1Zmu+nTpyMxMZH/+fbbbxUUcd1xcHCQec7Xr1/n182dOxenTp3C77//jj///BMvXrzA8OHDFRht3QkNDZXJy4ULFwAAI0eO5LdpLOfL27dv4eTkBD8/v1LXf/vtt/jxxx+xfft23Lp1C5qamnB3d0dubi6/zfjx4/Hw4UNcuHABp0+fxtWrVzFjxoy6egq1pqzcZGdn486dO1i2bBnu3LmD48ePIzo6GkOHDi2x7erVq2XOpc8++6wuwq9V5Z03AODh4SHzvA8dOiSzviGeN+XlpWg+EhMTsWvXLnAchxEjRshs1xDPmYp8Vpf3uSSRSDB48GDk5+fjxo0b2LNnD/z9/bF8+fLaDZ6ReqNz587M19eXX5ZIJMzc3JytW7dOgVEpXnJyMgPA/vzzT76tV69ebPbs2YoLSgFWrFjBnJycSl2Xnp7OBAIB+/333/m2qKgoBoDdvHmzjiKsP2bPns1atmzJpFIpY6xxni+MMQaAnThxgl+WSqXM1NSUfffdd3xbeno6U1NTY4cOHWKMMRYZGckAsNDQUH6boKAgxnEce/78eZ3FXtuK56Y0t2/fZgDY06dP+bbmzZuzzZs3125wClZabiZNmsS8vLzkPqYxnDcVOWe8vLxY3759ZdoawznDWMnP6op8Lp05c4YpKSmxpKQkfptt27YxHR0dlpeXV2ux0pXfeiI/Px/h4eFwc3Pj25SUlODm5oabN28qMDLFy8jIAAAYGBjItB84cABNmjRB27ZtsWTJEmRnZysivDr15MkTmJubo0WLFhg/fjwSEhIAAOHh4RCLxTLnT5s2bdCsWbNGd/7k5+dj//79mDJlCjiO49sb4/lSXFxcHJKSkmTOE11dXXTp0oU/T27evAk9PT107NiR38bNzQ1KSkq4detWncesSBkZGeA4Dnp6ejLt69evh6GhIdq3b4/vvvuu1r+irS+Cg4NhbGwMW1tbfPrpp0hNTeXX0XkDvHz5EoGBgZg6dWqJdY3hnCn+WV2Rz6WbN2+iXbt2MDEx4bdxd3dHZmYmHj58WGuxqtTankmlpKSkQCKRyJwAAGBiYoJHjx4pKCrFk0qlmDNnDrp37462bdvy7ePGjUPz5s1hbm6Oe/fuYdGiRYiOjsbx48cVGG3t6tKlC/z9/WFra4vExESsWrUKH3zwAR48eICkpCSoqqqW+JA2MTFBUlKSYgJWkJMnTyI9PR0+Pj58W2M8X0pTeC6U9j5TuC4pKQnGxsYy61VUVGBgYNCozqXc3FwsWrQIY8eOhY6ODt/++eefw8XFBQYGBrhx4waWLFmCxMREbNq0SYHR1j4PDw8MHz4c1tbWiI2NxZdffomBAwfi5s2bUFZWpvMGwJ49e6CtrV2iu1ljOGdK+6yuyOdSUlJSqe9HhetqCxW/pF7z9fXFgwcPZPq2ApDpR9auXTuYmZmhX79+iI2NRcuWLes6zDoxcOBA/ndHR0d06dIFzZs3x2+//QahUKjAyOqXX3/9FQMHDoS5uTnf1hjPF1J1YrEYo0aNAmMM27Ztk1k3b948/ndHR0eoqqri448/xrp16+rN1K21YcyYMfzv7dq1g6OjI1q2bIng4GD069dPgZHVH7t27cL48eOhrq4u094Yzhl5n9X1FXV7qCeaNGkCZWXlEndBvnz5EqampgqKSrFmzZqF06dP48qVK2jatGmZ23bp0gUAEBMTUxeh1Qt6enqwsbFBTEwMTE1NkZ+fj/T0dJltGtv58/TpU1y8eBHTpk0rc7vGeL4A4M+Fst5nTE1NS9xkW1BQgNevXzeKc6mw8H369CkuXLggc9W3NF26dEFBQQHi4+PrJsB6okWLFmjSpAn/N9TYz5tr164hOjq63PceoOGdM/I+qyvyuWRqalrq+1HhutpCxW89oaqqig4dOuDSpUt8m1QqxaVLl+Dq6qrAyOoeYwyzZs3CiRMncPnyZVhbW5f7GJFIBAAwMzOr5ejqj6ysLMTGxsLMzAwdOnSAQCCQOX+io6ORkJDQqM6f3bt3w9jYGIMHDy5zu8Z4vgCAtbU1TE1NZc6TzMxM3Lp1iz9PXF1dkZ6ejvDwcH6by5cvQyqV8v80NFSFhe+TJ09w8eJFGBoalvsYkUgEJSWlEl/5N3T//PMPUlNT+b+hxnzeAO++cerQoQOcnJzK3bahnDPlfVZX5HPJ1dUV9+/fl/nHqfCfTnt7+1oNntQThw8fZmpqaszf359FRkayGTNmMD09PZm7IBuDTz/9lOnq6rLg4GCWmJjI/2RnZzPGGIuJiWGrV69mYWFhLC4ujgUEBLAWLVqwnj17Kjjy2vXFF1+w4OBgFhcXx0JCQpibmxtr0qQJS05OZowx9sknn7BmzZqxy5cvs7CwMObq6spcXV0VHHXdkUgkrFmzZmzRokUy7Y3tfHnz5g27e/cuu3v3LgPANm3axO7evcuPWLB+/Xqmp6fHAgIC2L1795iXlxeztrZmOTk5/D48PDxY+/bt2a1bt9j169dZ69at2dixYxX1lGpMWbnJz89nQ4cOZU2bNmUikUjmvafwrvMbN26wzZs3M5FIxGJjY9n+/fuZkZERmzhxooKfWfWVlZs3b96w+fPns5s3b7K4uDh28eJF5uLiwlq3bs1yc3P5fTTE86a8vyfGGMvIyGAaGhps27ZtJR7fkM+Z8j6rGSv/c6mgoIC1bduWDRgwgIlEInb27FlmZGTElixZUquxU/Fbz2zdupU1a9aMqaqqss6dO7O//vpL0SHVOQCl/uzevZsxxlhCQgLr2bMnMzAwYGpqaqxVq1ZswYIFLCMjQ7GB17LRo0czMzMzpqqqyiwsLNjo0aNZTEwMvz4nJ4fNnDmT6evrMw0NDTZs2DCWmJiowIjr1rlz5xgAFh0dLdPe2M6XK1eulPr3M2nSJMbYu+HOli1bxkxMTJiamhrr169fiZylpqaysWPHMi0tLaajo8MmT57M3rx5o4BnU7PKyk1cXJzc954rV64wxhgLDw9nXbp0Ybq6ukxdXZ3Z2dmxtWvXyhSA76uycpOdnc0GDBjAjIyMmEAgYM2bN2fTp08vcWGmIZ435f09McbYjh07mFAoZOnp6SUe35DPmfI+qxmr2OdSfHw8GzhwIBMKhaxJkybsiy++YGKxuFZj5/59AoQQQgghhDR41OeXEEIIIYQ0GlT8EkIIIYSQRoOKX0IIIYQQ0mhQ8UsIIYQQQhoNKn4JIYQQQkijQcUvIYQQQghpNKj4JYQQQgghjQYVv4QQ8p4QiUT47rvvUFBQoOhQCCHkvUXFLyGEvAdev36NESNGwM7ODioqKrV2HCsrK/zwww+1tn9CCFE0Kn4JIURBfHx84O3tDQDo3bs35syZU+p2jDFMnDgRixYtwpAhQ2rk2P7+/tDT0yvRHhoaihkzZtTIMQghpD6qvcsHhBBCagTHcTh9+nSFts3Pz4eqqmqVj2VkZFTlxxJCyPuArvwSQoiC+fj44M8//8SWLVvAcRw4jkN8fDwA4MGDBxg4cCC0tLRgYmKCCRMmICUlhX9s7969MWvWLMyZMwdNmjSBu7s7AGDTpk1o164dNDU1YWlpiZkzZyIrKwsAEBwcjMmTJyMjI4M/3sqVKwGU7PaQkJAALy8vaGlpQUdHB6NGjcLLly/59StXroSzszP27dsHKysr6OrqYsyYMXjz5g2/zdGjR9GuXTsIhUIYGhrCzc0Nb9++raVsEkJI2aj4JYQQBduyZQtcXV0xffp0JCYmIjExEZaWlkhPT0ffvn3Rvn17hIWF4ezZs3j58iVGjRol8/g9e/ZAVVUVISEh2L59OwBASUkJP/74Ix4+fIg9e/bg8uXLWLhwIQCgW7du+OGHH6Cjo8Mfb/78+SXikkql8PLywuvXr/Hnn3/iwoUL+PvvvzF69GiZ7WJjY3Hy5EmcPn0ap0+fxp9//on169cDABITEzF27FhMmTIFUVFRCA4OxvDhw8EYq41UEkJIuajbAyGEKJiuri5UVVWhoaEBU1NTvv1///sf2rdvj7Vr1/Jtu3btgqWlJR4/fgwbGxsAQOvWrfHtt9/K7LNo/2ErKyt88803+OSTT/DTTz9BVVUVurq64DhO5njFXbp0Cffv30dcXBwsLS0BAHv37oWDgwNCQ0PRqVMnAO+KZH9/f2hrawMAJkyYgEuXLmHNmjVITExEQUEBhg8fjubNmwMA2rVrV41sEUJI9dCVX0IIqaciIiJw5coVaGlp8T9t2rQB8O5qa6EOHTqUeOzFixfRr18/WFhYQFtbGxMmTEBqaiqys7MrfPyoqChYWlryhS8A2NvbQ09PD1FRUXyblZUVX/gCgJmZGZKTkwEATk5O6NevH9q1a4eRI0di586dSEtLq3gSCCGkhlHxSwgh9VRWVhY8PT0hEolkfp48eYKePXvy22lqaso8Lj4+HkOGDIGjoyOOHTuG8PBw+Pn5AXh3Q1xNEwgEMsscx0EqlQIAlJWVceHCBQQFBcHe3h5bt26Fra0t4uLiajwOQgipCCp+CSGkHlBVVYVEIpFpc3FxwcOHD2FlZYVWrVrJ/BQveIsKDw+HVCrF999/j65du8LGxgYvXrwo93jF2dnZ4dmzZ3j27BnfFhkZifT0dNjb21f4uXEch+7du2PVqlW4e/cuVFVVceLEiQo/nhBCahIVv4QQUg9YWVnh1q1biI+PR0pKCqRSKXx9ffH69WuMHTsWoaGhiI2Nxblz5zB58uQyC9dWrVpBLBZj69at+Pvvv7Fv3z7+Rriix8vKysKlS5eQkpJSancINzc3tGvXDuPHj8edO3dw+/ZtTJw4Eb169ULHjh0r9Lxu3bqFtWvXIiwsDAkJCTh+/DhevXoFOzu7yiWIEEJqCBW/hBBSD8yfPx/Kysqwt7eHkZEREhISYG5ujpCQEEgkEgwYMADt2rXDnDlzoKenByUl+W/fTk5O2LRpEzZs2IC2bdviwIEDWLduncw23bp1wyeffILRo0fDyMioxA1zwLsrtgEBAdDX10fPnj3h5uaGFi1a4MiRIxV+Xjo6Orh69SoGDRoEGxsbfPXVV/j+++8xcODAiieHEEJqEMdovBlCCCGEENJI0JVfQgghhBDSaFDxSwghhBBCGg0qfgkhhBBCSKNBxS8hhBBCCGk0qPglhBBCCCGNBhW/hBBCCCGk0aDilxBCCCGENBpU/BJCCCGEkEaDil9CCCGEENJoUPFLCCGEEEIaDSp+CSGEEEJIo/F/Y+EVYGIZ8cEAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "n_trials = 100      # nombre de trajectoires\n",
+        "max_iters = 200    # nombre d'itérations\n",
+        "\n",
+        "# Listes pour stocker les pertes de chaque trajectoire\n",
+        "loss_vanilla_trials = []\n",
+        "loss_momentum_trials = []\n",
+        "loss_preconditioned_trials = []\n",
+        "loss_mom_prec_trials = []\n",
+        "\n",
+        "for trial in range(n_trials):\n",
+        "    # On génère un point initial différent pour chaque trajectoire\n",
+        "    delta = np.random.randn(2*r)\n",
+        "    current_norm = S_err(theta_star + delta)\n",
+        "    scale = 0.1 / current_norm if current_norm != 0 else 0.0\n",
+        "    initial_point = theta_star + scale * delta\n",
+        "    #initial_point = theta_star + np.random.randn(2*r) * 0.01\n",
+        "    y_current = y_star  # on garde y_star inchangé\n",
+        "\n",
+        "    # --- Expérience 1 : Descente gradient vanilla (pas de momentum, pas de préconditionnement) ---\n",
+        "    P_k = identity_P_k  # utilisation de l'identité\n",
+        "    theta_vanilla, loss_vanilla = preconditioned_gradient_descent(\n",
+        "        S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "        learning_rate=0.3, momentum=0, max_iters=max_iters\n",
+        "    )\n",
+        "    loss_vanilla_trials.append(loss_vanilla)\n",
+        "\n",
+        "    # --- Expérience 2 : Descente gradient avec momentum (momentum, pas de préconditionnement) ---\n",
+        "    P_k = identity_P_k\n",
+        "    theta_momentum, loss_momentum = preconditioned_gradient_descent(\n",
+        "        S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "        learning_rate=0.3, momentum=0.7, max_iters=max_iters\n",
+        "    )\n",
+        "    loss_momentum_trials.append(loss_momentum)\n",
+        "\n",
+        "    # --- Expérience 3 : Descente préconditionnée (pas de momentum, avec préconditionnement) ---\n",
+        "    P_k = P_k_original\n",
+        "    theta_preconditioned, loss_preconditioned = preconditioned_gradient_descent(\n",
+        "        S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "        learning_rate=0.1, momentum=0, max_iters=max_iters\n",
+        "    )\n",
+        "    loss_preconditioned_trials.append(loss_preconditioned)\n",
+        "\n",
+        "    # --- Expérience 4 : Momentum + préconditionnement (momentum, avec préconditionnement) ---\n",
+        "    P_k = P_k_original\n",
+        "    theta_mom_prec, loss_mom_prec = preconditioned_gradient_descent(\n",
+        "        S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "        learning_rate=0.1, momentum=0.2, max_iters=max_iters\n",
+        "    )\n",
+        "    loss_mom_prec_trials.append(loss_mom_prec)\n",
+        "\n",
+        "# Convertir les listes en tableaux NumPy pour calculer la moyenne et l'écart-type\n",
+        "loss_vanilla_trials = np.array(loss_vanilla_trials)\n",
+        "loss_momentum_trials = np.array(loss_momentum_trials)\n",
+        "loss_preconditioned_trials = np.array(loss_preconditioned_trials)\n",
+        "loss_mom_prec_trials = np.array(loss_mom_prec_trials)\n",
+        "\n",
+        "iters = np.arange(max_iters)\n",
+        "\n",
+        "# Calcul des moyennes et écarts-types pour chaque méthode\n",
+        "mean_vanilla = np.mean(loss_vanilla_trials, axis=0)\n",
+        "std_vanilla = np.std(loss_vanilla_trials, axis=0)\n",
+        "\n",
+        "mean_momentum = np.mean(loss_momentum_trials, axis=0)\n",
+        "std_momentum = np.std(loss_momentum_trials, axis=0)\n",
+        "\n",
+        "mean_preconditioned = np.mean(loss_preconditioned_trials, axis=0)\n",
+        "std_preconditioned = np.std(loss_preconditioned_trials, axis=0)\n",
+        "\n",
+        "mean_mom_prec = np.mean(loss_mom_prec_trials, axis=0)\n",
+        "std_mom_prec = np.std(loss_mom_prec_trials, axis=0)\n",
+        "\n",
+        "# --- Restaurer le préconditionneur original si nécessaire ---\n",
+        "P_k = P_k_original"
+      ],
+      "metadata": {
+        "id": "-O2XbCmgGnkB"
+      },
+      "execution_count": 18,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# --- Affichage ---\n",
+        "size = 18\n",
+        "\n",
+        "\n",
+        "#plt.figure(figsize=(8, 6))\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "\n",
+        "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n",
+        "\n",
+        "# Descente gradient vanilla\n",
+        "plt.semilogy(iters, mean_vanilla, linestyle='-', color=colors[0],\n",
+        "             label=\"Vanilla\")\n",
+        "plt.fill_between(iters, mean_vanilla - std_vanilla, mean_vanilla + std_vanilla,\n",
+        "                 color=colors[0], alpha=0.1)\n",
+        "\n",
+        "# Descente gradient à momentum\n",
+        "plt.semilogy(iters, mean_momentum, linestyle='--', color=colors[1],\n",
+        "             label=\"Momentum\")\n",
+        "plt.fill_between(iters, mean_momentum - std_momentum, mean_momentum + std_momentum,\n",
+        "                 color=colors[1], alpha=0.1)\n",
+        "\n",
+        "# Descente préconditionnée\n",
+        "plt.semilogy(iters, mean_preconditioned, linestyle='-.', color=colors[2],\n",
+        "             label=\"Descente Préconditionnée\")\n",
+        "plt.fill_between(iters, mean_preconditioned - std_preconditioned, mean_preconditioned + std_preconditioned,\n",
+        "                 color=colors[2], alpha=0.1)\n",
+        "\n",
+        "# Momentum + préconditionnement\n",
+        "plt.semilogy(iters, mean_mom_prec, linestyle=':', color=colors[3],\n",
+        "             label=\"Momentum \\n + Preconditionnement\")\n",
+        "plt.fill_between(iters, mean_mom_prec - std_mom_prec, mean_mom_prec + std_mom_prec,\n",
+        "                 color=colors[3], alpha=0.1)\n",
+        "\n",
+        "\n",
+        "plt.xlabel(\"Itérations\", fontsize=size)\n",
+        "plt.ylabel(r\"Erreur $\\| S ({\\theta}_k - \\theta^\\star) \\|_{\\infty}$ (log)\", fontsize=size)\n",
+        "#plt.title(f\"Comparaison des algorithmes de descente (moyenne et écart-type sur {n_trials} trajectoires)\", fontsize=16)\n",
+        "plt.legend()\n",
+        "#plt.grid(True)\n",
+        "\n",
+        "\n",
+        "plt.xticks(fontsize=size)\n",
+        "plt.yticks(fontsize=size)\n",
+        "plt.legend(fontsize=size)\n",
+        "\n",
+        "# Save the figure as a PDF\n",
+        "pdf_filename = \"/content/CompSpeedMoy.pdf\"\n",
+        "plt.savefig(pdf_filename, format=\"pdf\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 562
+        },
+        "id": "VGMuuVdfIbWG",
+        "outputId": "318bcfc9-55cc-440b-df1f-fa36e82065d3"
+      },
+      "execution_count": 19,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "n_trials = 100     # nombre de trajectoires\n",
+        "max_iters = 200    # nombre d'itérations\n",
+        "\n",
+        "# Listes pour stocker les pertes de chaque trajectoire\n",
+        "loss_vanilla_trials = []\n",
+        "loss_momentum_trials = []\n",
+        "loss_preconditioned_trials = []\n",
+        "loss_mom_prec_trials = []\n",
+        "\n",
+        "for trial in range(n_trials):\n",
+        "    # On génère un point initial différent pour chaque trajectoire\n",
+        "    delta = np.random.randn(2*r)\n",
+        "    current_norm = S_err(theta_star + delta)\n",
+        "    scale = 0.1 / current_norm if current_norm != 0 else 0.0\n",
+        "    initial_point = theta_star + scale * delta\n",
+        "    #initial_point = theta_star + np.random.randn(2*r) * 0.01\n",
+        "    y_current = y_star  # on garde y_star inchangé\n",
+        "\n",
+        "    # --- Expérience 1 : Descente gradient vanilla ---\n",
+        "    P_k = identity_P_k\n",
+        "    theta_vanilla, loss_vanilla = preconditioned_gradient_descent(\n",
+        "        S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "        learning_rate=0.3, momentum=0, max_iters=max_iters\n",
+        "    )\n",
+        "    loss_vanilla_trials.append(loss_vanilla)\n",
+        "\n",
+        "    # --- Expérience 2 : Descente gradient avec momentum ---\n",
+        "    P_k = identity_P_k\n",
+        "    theta_momentum, loss_momentum = preconditioned_gradient_descent(\n",
+        "        S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "        learning_rate=0.3, momentum=0.7, max_iters=max_iters\n",
+        "    )\n",
+        "    loss_momentum_trials.append(loss_momentum)\n",
+        "\n",
+        "    # --- Expérience 3 : Descente préconditionnée ---\n",
+        "    P_k = P_k_original\n",
+        "    theta_preconditioned, loss_preconditioned = preconditioned_gradient_descent(\n",
+        "        S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "        learning_rate=0.3, momentum=0, max_iters=max_iters\n",
+        "    )\n",
+        "    loss_preconditioned_trials.append(loss_preconditioned)\n",
+        "\n",
+        "    # --- Expérience 4 : Momentum + préconditionnement ---\n",
+        "    P_k = P_k_original\n",
+        "    theta_mom_prec, loss_mom_prec = preconditioned_gradient_descent(\n",
+        "        S_err_wrapper, initial_point, y_current.reshape(-1, 1),\n",
+        "        learning_rate=0.3, momentum=0.6, max_iters=max_iters\n",
+        "    )\n",
+        "    loss_mom_prec_trials.append(loss_mom_prec)\n",
+        "\n",
+        "# Conversion des listes en tableaux NumPy\n",
+        "loss_vanilla_trials = np.array(loss_vanilla_trials)\n",
+        "loss_momentum_trials = np.array(loss_momentum_trials)\n",
+        "loss_preconditioned_trials = np.array(loss_preconditioned_trials)\n",
+        "loss_mom_prec_trials = np.array(loss_mom_prec_trials)\n",
+        "\n",
+        "iters = np.arange(max_iters)\n",
+        "\n",
+        "# Calcul de la médiane et des quartiles (25ème et 75ème percentiles) pour chaque méthode\n",
+        "\n",
+        "# Descente gradient vanilla\n",
+        "median_vanilla = np.median(loss_vanilla_trials, axis=0)\n",
+        "q1_vanilla = np.percentile(loss_vanilla_trials, 25, axis=0)\n",
+        "q3_vanilla = np.percentile(loss_vanilla_trials, 75, axis=0)\n",
+        "\n",
+        "# Descente gradient à momentum\n",
+        "median_momentum = np.median(loss_momentum_trials, axis=0)\n",
+        "q1_momentum = np.percentile(loss_momentum_trials, 25, axis=0)\n",
+        "q3_momentum = np.percentile(loss_momentum_trials, 75, axis=0)\n",
+        "\n",
+        "# Descente préconditionnée\n",
+        "median_preconditioned = np.median(loss_preconditioned_trials, axis=0)\n",
+        "q1_preconditioned = np.percentile(loss_preconditioned_trials, 25, axis=0)\n",
+        "q3_preconditioned = np.percentile(loss_preconditioned_trials, 75, axis=0)\n",
+        "\n",
+        "# Momentum + préconditionnement\n",
+        "median_mom_prec = np.median(loss_mom_prec_trials, axis=0)\n",
+        "q1_mom_prec = np.percentile(loss_mom_prec_trials, 25, axis=0)\n",
+        "q3_mom_prec = np.percentile(loss_mom_prec_trials, 75, axis=0)\n",
+        "\n",
+        "# --- Affichage ---\n",
+        "plt.figure(figsize=(8, 6))\n",
+        "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n",
+        "\n",
+        "# Descente gradient vanilla\n",
+        "plt.semilogy(iters, median_vanilla, linestyle='-', color=colors[0],\n",
+        "             label=\"Descente gradient vanilla (médiane)\")\n",
+        "plt.fill_between(iters, q1_vanilla, q3_vanilla,\n",
+        "                 color=colors[0], alpha=0.3)\n",
+        "\n",
+        "# Descente gradient à momentum\n",
+        "plt.semilogy(iters, median_momentum, linestyle='--', color=colors[1],\n",
+        "             label=\"Descente gradient à momentum (médiane)\")\n",
+        "plt.fill_between(iters, q1_momentum, q3_momentum,\n",
+        "                 color=colors[1], alpha=0.3)\n",
+        "\n",
+        "# Descente préconditionnée\n",
+        "plt.semilogy(iters, median_preconditioned, linestyle='-.', color=colors[2],\n",
+        "             label=\"Descente préconditionnée (médiane)\")\n",
+        "plt.fill_between(iters, q1_preconditioned, q3_preconditioned,\n",
+        "                 color=colors[2], alpha=0.3)\n",
+        "\n",
+        "# Momentum + préconditionnement\n",
+        "plt.semilogy(iters, median_mom_prec, linestyle=':', color=colors[3],\n",
+        "             label=\"Momentum + préconditionnement (médiane)\")\n",
+        "plt.fill_between(iters, q1_mom_prec, q3_mom_prec,\n",
+        "                 color=colors[3], alpha=0.3)\n",
+        "\n",
+        "\n",
+        "plt.xticks(fontsize=16)\n",
+        "plt.yticks(fontsize=16)\n",
+        "plt.legend(fontsize=16)\n",
+        "\n",
+        "\n",
+        "\n",
+        "plt.xlabel(\"Itérations\", fontsize=16)\n",
+        "plt.ylabel(r\"Erreur $\\| S (\\hat{\\theta} - \\theta^\\star) \\|_{\\infty}$ (échelle logarithmique)\", fontsize=16)\n",
+        "#plt.title(f'Comparaison des algorithmes de descente\\nMédiane et intervalle interquartile sur {n_trials} trajectoires')\n",
+        "plt.legend()\n",
+        "plt.grid(True)\n",
+        "plt.show()\n",
+        "\n",
+        "# --- Restaurer le préconditionneur original si nécessaire ---\n",
+        "P_k = P_k_original"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 554
+        },
+        "id": "vzFhzYfxJETX",
+        "outputId": "2b876e0c-6fd4-453e-8807-e7e45a9c709b"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "# Paramètres de l'algorithme de descente\n",
+        "max_iters = 400\n",
+        "learning_rate = 0.1\n",
+        "threshold = 1e-2  # Seuil de convergence sur S_infty\n",
+        "\n",
+        "# ----- Paramètres de l'expérience -----\n",
+        "# On étudie des distances S_norm allant de 0.1 à 1\n",
+        "nb_distances = 10  # par exemple, 10 valeurs\n",
+        "distances = np.linspace(0.01, 1.5, nb_distances)\n",
+        "nb_experiences = 30  # 10 points aléatoires par distance\n",
+        "\n",
+        "# On prépare une structure pour stocker le taux de convergence pour chaque méthode\n",
+        "# Les méthodes seront : Vanilla, Momentum, Préconditionnée, Momentum+Préconditionnement\n",
+        "methods = [\"Vanilla\", \"Momentum\", \"Preconditioned\", \"Momentum+Preconditioned\"]\n",
+        "convergence_rates = {m: [] for m in methods}\n",
+        "\n",
+        "\n",
+        "# ----- Boucle sur les distances -----\n",
+        "for d in distances:\n",
+        "    # compteur de convergences pour chaque méthode (sur nb_experiences)\n",
+        "    counts = {m: 0 for m in methods}\n",
+        "\n",
+        "    for _ in range(nb_experiences):\n",
+        "        # Génération d'un point initial à distance d de theta_star\n",
+        "        # On génère un vecteur aléatoire delta dans R^(2r) et on le redimensionne.\n",
+        "        delta = np.random.randn(2*r)\n",
+        "        current_norm = S_err(theta_star + delta)\n",
+        "        scale = d / current_norm if current_norm != 0 else 0.0\n",
+        "        theta_init = theta_star + scale * delta\n",
+        "\n",
+        "        # Pour chaque méthode, on réinitialise le point de départ\n",
+        "        # et on configure le préconditionneur et le momentum.\n",
+        "\n",
+        "        # 1. Vanilla (pas de momentum, pas de préconditionnement)\n",
+        "        P_k = identity_P_k  # on définit le préconditionneur comme identité\n",
+        "        theta_final, loss_history = preconditioned_gradient_descent(\n",
+        "            S_err_wrapper, theta_init, y_star.reshape(-1, 1),\n",
+        "            learning_rate=learning_rate, momentum=0, max_iters=max_iters\n",
+        "        )\n",
+        "        if loss_history[-1] < threshold:\n",
+        "            counts[\"Vanilla\"] += 1\n",
+        "\n",
+        "        # 2. Avec momentum (momentum, pas de préconditionnement)\n",
+        "        P_k = identity_P_k\n",
+        "        theta_final, loss_history = preconditioned_gradient_descent(\n",
+        "            S_err_wrapper, theta_init, y_star.reshape(-1, 1),\n",
+        "            learning_rate=learning_rate, momentum=0.7, max_iters=max_iters\n",
+        "        )\n",
+        "        if loss_history[-1] < threshold:\n",
+        "            counts[\"Momentum\"] += 1\n",
+        "\n",
+        "        # 3. Préconditionnée (pas de momentum, avec préconditionnement)\n",
+        "        P_k = P_k_original  # ici P_k_original, tel que défini plus haut\n",
+        "        theta_final, loss_history = preconditioned_gradient_descent(\n",
+        "            S_err_wrapper, theta_init, y_star.reshape(-1, 1),\n",
+        "            learning_rate=learning_rate, momentum=0, max_iters=max_iters\n",
+        "        )\n",
+        "        if loss_history[-1] < threshold:\n",
+        "            counts[\"Preconditioned\"] += 1\n",
+        "\n",
+        "        # 4. Momentum + Préconditionnement (momentum, avec préconditionnement)\n",
+        "        P_k = P_k_original\n",
+        "        theta_final, loss_history = preconditioned_gradient_descent(\n",
+        "            S_err_wrapper, theta_init, y_star.reshape(-1, 1),\n",
+        "            learning_rate=learning_rate, momentum=0.6, max_iters=max_iters\n",
+        "        )\n",
+        "        if loss_history[-1] < threshold:\n",
+        "            counts[\"Momentum+Preconditioned\"] += 1\n",
+        "\n",
+        "    # Calcul du taux de convergence (en fraction) pour chaque méthode à la distance d\n",
+        "    for m in methods:\n",
+        "        convergence_rates[m].append(counts[m] / nb_experiences)"
+      ],
+      "metadata": {
+        "id": "rnAGVTbXr_Vc"
+      },
+      "execution_count": 20,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ----- Visualisation des résultats -----\n",
+        "size = 18\n",
+        "\n",
+        "#plt.figure(figsize=(8,6))\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "\n",
+        "# Récupération du cycle de couleurs par défaut\n",
+        "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n",
+        "# Définition des linestyles et des markers pour chaque tracé\n",
+        "linestyles = ['-', '--', '-.', ':']\n",
+        "markers = ['o', 's', '^', 'd']\n",
+        "methodes = [\"Vanilla\", \"Momentum\", \"Preconditionée\", \"Momentum \\n + Preconditionnement\"] # en français\n",
+        "for i, m in enumerate(methods):\n",
+        "    plt.plot(distances, convergence_rates[m], marker=markers[i], linestyle=linestyles[i], color=colors[i], label=methodes[i])\n",
+        "\n",
+        "plt.xlabel(r\"Distance initiale ($\\|S(\\theta_0 - \\theta^\\star)\\|_{\\infty}$)\", fontsize=size)\n",
+        "plt.ylabel(\"Taux de convergence\", fontsize=size)\n",
+        "#plt.title(\"Bassin d'attraction : taux de convergence vs distance S_norm\")\n",
+        "plt.legend()\n",
+        "plt.grid(True)\n",
+        "\n",
+        "plt.xticks(fontsize=size)\n",
+        "plt.yticks(fontsize=size)\n",
+        "plt.legend(fontsize=size)\n",
+        "\n",
+        "# Save the figure as a PDF\n",
+        "pdf_filename = \"/content/CompBassin.pdf\"\n",
+        "plt.savefig(pdf_filename, format=\"pdf\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 567
+        },
+        "id": "mk6gKpCZNjP8",
+        "outputId": "122e554f-bf96-4c7b-a2d6-23498834748d"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "nnPzQ7OmZTHH"
+      },
+      "execution_count": 11,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file