diff --git a/notebooks/INLA_testing.ipynb b/notebooks/INLA_testing.ipynb
new file mode 100644
index 00000000..e7f679bb
--- /dev/null
+++ b/notebooks/INLA_testing.ipynb
@@ -0,0 +1,782 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ffd6780e-1bfb-42f0-ba6a-055e9ffd1490",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Exception reporting mode: Verbose\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%xmode Verbose"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5a2819fd-6e01-47c0-88b2-f2b5e4215b9b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pymc as pm\n",
+    "import pytensor.tensor as pt\n",
+    "import pymc_extras as pmx\n",
+    "\n",
+    "import pytensor\n",
+    "\n",
+    "# from pytensor.tensor.optimize import minimize\n",
+    "from pymc_extras.inference.inla import *\n",
+    "\n",
+    "# from pymc.model.fgraph import fgraph_from_model, model_from_fgraph\n",
+    "# from pymc_extras.model.marginal.marginal_model import marginalize"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "59f0123d-a58b-4df4-827d-dd408be5bee5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# - Will need to figure out how to get p(x | y)\n",
+    "# - dims_connections"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "47d6057b-b459-43ee-afdb-32e63cee5e62",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<!-- Generated by graphviz version 13.0.1 (20250616.1512)\n",
+       " -->\n",
+       "<!-- Pages: 1 -->\n",
+       "<svg width=\"268pt\" height=\"404pt\"\n",
+       " viewBox=\"0.00 0.00 268.00 404.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 400)\">\n",
+       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-400 264,-400 264,4 -4,4\"/>\n",
+       "<g id=\"clust1\" class=\"cluster\">\n",
+       "<title>cluster3</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M20,-141.75C20,-141.75 240,-141.75 240,-141.75 246,-141.75 252,-147.75 252,-153.75 252,-153.75 252,-376 252,-376 252,-382 246,-388 240,-388 240,-388 20,-388 20,-388 14,-388 8,-382 8,-376 8,-376 8,-153.75 8,-153.75 8,-147.75 14,-141.75 20,-141.75\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"239.5\" y=\"-149.7\" font-family=\"Times,serif\" font-size=\"14.00\">3</text>\n",
+       "</g>\n",
+       "<g id=\"clust2\" class=\"cluster\">\n",
+       "<title>cluster10000 x 3</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M20,-8C20,-8 240,-8 240,-8 246,-8 252,-14 252,-20 252,-20 252,-121.75 252,-121.75 252,-127.75 246,-133.75 240,-133.75 240,-133.75 20,-133.75 20,-133.75 14,-133.75 8,-127.75 8,-121.75 8,-121.75 8,-20 8,-20 8,-14 14,-8 20,-8\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"208.38\" y=\"-15.95\" font-family=\"Times,serif\" font-size=\"14.00\">10000 x 3</text>\n",
+       "</g>\n",
+       "<!-- mu -->\n",
+       "<g id=\"node1\" class=\"node\">\n",
+       "<title>mu</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"130\" cy=\"-337.75\" rx=\"114.2\" ry=\"42.25\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-350.32\" font-family=\"Times,serif\" font-size=\"14.00\">mu</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-333.07\" font-family=\"Times,serif\" font-size=\"14.00\">~</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-315.82\" font-family=\"Times,serif\" font-size=\"14.00\">Multivariate_normal</text>\n",
+       "</g>\n",
+       "<!-- x -->\n",
+       "<g id=\"node2\" class=\"node\">\n",
+       "<title>x</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"130\" cy=\"-217.25\" rx=\"114.2\" ry=\"42.25\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-229.82\" font-family=\"Times,serif\" font-size=\"14.00\">x</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-212.57\" font-family=\"Times,serif\" font-size=\"14.00\">~</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-195.32\" font-family=\"Times,serif\" font-size=\"14.00\">Multivariate_normal</text>\n",
+       "</g>\n",
+       "<!-- mu&#45;&gt;x -->\n",
+       "<g id=\"edge1\" class=\"edge\">\n",
+       "<title>mu&#45;&gt;x</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M130,-295.3C130,-287.5 130,-279.24 130,-271.15\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"133.5,-271.38 130,-261.38 126.5,-271.38 133.5,-271.38\"/>\n",
+       "</g>\n",
+       "<!-- y -->\n",
+       "<g id=\"node3\" class=\"node\">\n",
+       "<title>y</title>\n",
+       "<ellipse fill=\"lightgrey\" stroke=\"black\" cx=\"130\" cy=\"-83.5\" rx=\"114.2\" ry=\"42.25\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-96.07\" font-family=\"Times,serif\" font-size=\"14.00\">y</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-78.82\" font-family=\"Times,serif\" font-size=\"14.00\">~</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-61.57\" font-family=\"Times,serif\" font-size=\"14.00\">Multivariate_normal</text>\n",
+       "</g>\n",
+       "<!-- x&#45;&gt;y -->\n",
+       "<g id=\"edge2\" class=\"edge\">\n",
+       "<title>x&#45;&gt;y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M130,-174.56C130,-162.67 130,-149.56 130,-137.11\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"133.5,-137.43 130,-127.43 126.5,-137.43 133.5,-137.43\"/>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "<graphviz.graphs.Digraph at 0x7f07b63d0050>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rng = np.random.default_rng(12345)\n",
+    "n = 10000\n",
+    "d = 3\n",
+    "\n",
+    "# mu_mu = np.zeros((d,))\n",
+    "# mu_true = np.ones((d,))\n",
+    "\n",
+    "mu_mu = 10 * rng.random(d)\n",
+    "mu_true = rng.random(d)\n",
+    "\n",
+    "cov = np.diag(np.ones(d))\n",
+    "Q_val = np.diag(np.ones(d))\n",
+    "cov_true = np.diag(np.ones(d))\n",
+    "\n",
+    "with pm.Model() as model:\n",
+    "    x_mu = pm.MvNormal(\"mu\", mu=mu_mu, cov=cov)\n",
+    "\n",
+    "    x = pm.MvNormal(\"x\", mu=x_mu, tau=Q_val)\n",
+    "\n",
+    "    y_obs = rng.multivariate_normal(mean=mu_true, cov=cov_true, size=n)\n",
+    "\n",
+    "    y = pm.MvNormal(\n",
+    "        \"y\",\n",
+    "        mu=x,\n",
+    "        cov=cov,  # cov_param.reshape((d, d)),\n",
+    "        observed=y_obs,\n",
+    "    )\n",
+    "\n",
+    "pm.model_to_graphviz(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "c3c1cca7-a743-4bbb-9bb7-7d10d9b1a2a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Initializing NUTS using jitter+adapt_diag...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1.47480745 1.77934647 4.15323425]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Multiprocess sampling (4 chains in 4 jobs)\n",
+      "NUTS: [mu_param, x]\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e8ff031bf2874b88b1f23ce5f573218f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 8 seconds.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([[<Axes: title={'center': 'mu_param\\n0'}>,\n",
+       "        <Axes: title={'center': 'mu_param\\n1'}>,\n",
+       "        <Axes: title={'center': 'mu_param\\n2'}>],\n",
+       "       [<Axes: title={'center': 'x\\n0'}>,\n",
+       "        <Axes: title={'center': 'x\\n1'}>,\n",
+       "        <Axes: title={'center': 'x\\n2'}>]], dtype=object)"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABsMAAAOzCAYAAADtAHi1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XeYlOW5x/HfOzNb2M72ZRcWlt67FEE6KqDYjyWxJGpMYo9RE/WkqElONNHEE3NMJZrYsKGAoHRBQHpnqUtZ2L5srzPv+WNmV5C2C7v7Tvl+rssrZGb2nd8iss+89/Pct2GapikAAAAAAAAAAADAD9msDgAAAAAAAAAAAAC0FophAAAAAAAAAAAA8FsUwwAAAAAAAAAAAOC3KIYBAAAAAAAAAADAb1EMAwAAAAAAAAAAgN+iGAYAAAAAAAAAAAC/RTEMAAAAAAAAAAAAfotiGAAAAAAAAAAAAPwWxTAAAAAAAAAAAAD4LYphAAAAAAAAAAAA8FsUwwAAAAAAAAAAAOC3KIYBAAAAAAAAAADAb1EMAwAAAAAAAAAAgN+iGAYAAAAAAAAAAAC/RTEMaAbDMGQYhiTpww8/1OjRoxUREaGkpCTdcccdysnJaXztP//5Tw0dOlTh4eFKTEzUfffdp5KSktOu+fOf/1yGYejnP//5Gd9z1qxZMgxDd9555wXnPvkaZWVlevTRR9W5c2eFhoYqIyNDTz31lCorK8/4tZ9//rnuv/9+DRw4ULGxsQoNDVXXrl31/e9/X4cPHz7j19x5550yDEOzZs3SwYMHdeeddyo1NVUOh6Px+3Q6nZozZ46+853vqG/fvoqOjlZYWJh69+6txx9/XAUFBWe89vjx42UYhpYtW6atW7dq5syZio+PV1RUlCZPnqz169c3vvaLL77QFVdcodjYWEVGRmr69OnavXv3Bf8+AgCA1sd6i/UWAABoXay3WG8BgYhiGHABXnnlFV133XU6cuSIunXrppKSEr3++uuaNGmSqqur9dBDD+k73/mOTpw4oS5duqi4uFivvfaaZs6cKdM0LctdU1OjcePG6eWXX1ZERIS6d++urKws/epXv9KkSZPOuGC48sor9eqrryonJ0fp6enq3r27cnNz9X//938aMmSIdu7cedb3y8zM1JAhQ/T2228rOTlZ3bt3b1xsHT9+XNdcc43+9a9/qbi4WN26dVN6erqysrL0wgsvaPjw4crNzT3rtdeuXauRI0dqxYoV6ty5s2w2mxYvXqyJEydqx44dmj17tiZOnKhNmzapS5cucrlcmj9/vi677LJzXhcAAHgH1lustwAAQOtivcV6CwgoJoAmk2RKMsPDw80333yz8fEjR46Y3bp1MyWZ11xzjRkdHW0uWrSo8fmtW7easbGxpiRz/vz5p1zzZz/7mSnJ/NnPfnbG9/znP/9pSjLvuOOOC87dcA2Hw2Gmpqaamzdvbnxu27ZtZseOHU1J5mOPPXba17722mtmdnb2KY9VVlaazz//vCnJHD9+/Glfc8cdd5iSTLvdbl599dVmYWFh43NVVVWmaZrmiRMnzFmzZp3ynGmaZnFxsXn//febksw777zztGuPGzfOlGQGBQWZjz76qFlTU2OapmlWV1ebM2fObMwUExNj/u53vzOdTmfjdS+55BJTkvn444839bcOAAC0MdZbbqy3AABAa2G95cZ6CwgsFMOAZmhYLDz00EOnPffaa681Pv/SSy+d9vyTTz5pSjIffPDBUx5vy8WCJPODDz447fmPP/64cRFUWlra5OuOGTPGlGQePXr0lMcbFgvJyclmeXn5BWXu2LGjGRYWZtbV1Z3yeMNiYfDgwabL5TrluczMzMbvc+bMmaddc8GCBaYkc8CAAReUCQAAtD7WW6divQUAAFoa661Tsd4CAoOjqSfIAHztu9/97mmPDRo0qPHX3/nOd057fvDgwZKkAwcOtFqu80lNTdXMmTNPe3zGjBnq1KmTDh8+rFWrVumKK6445fn169frvffe086dO1VSUiKn0ylJ2rt3ryRp69atSk1NPe26119/vcLDw8+ZacmSJfrkk0+0Z88elZWVyeVySZJKSkpUWVmpvXv3qnfv3qd93V133dV4JL1Bjx49FBYWpsrKyjP+O/KGfwcAAKBpWG+x3gIAAK2L9RbrLSCQUAwDLkDXrl1PeywhIaHxf6Oios76fHl5eeuGO4eePXvKZjt9VKBhGOrZs6cOHz6sPXv2NC4WTNPU/fffr1dfffWc1y0qKjrj42f6Id+gtrZW//Vf/6WPPvrogq59pn8HkhQfH6/Dhw+f89+Rlf8OAABA07DeOhXrLQAA0NJYb52K9Rbg307/WwPAeYWFhZ32WMMujjM9d/LzpoUDRhMTE8/6XFJSkiSprKys8bE33nhDr776qsLDw/Xqq69q7969qqyslOlusarbbrtNklRXV3fGa55r18xvfvMbffTRR0pOTtbrr7+urKwsVVdXN1770ksvPee1z/f7fK5/RwAAwPux3mK9BQAAWhfrLdZbQCDhZBhgsfMtIioqKlrsvfLz88/6XF5eniQpMjKy8bH//Oc/kqTf/e53+t73vnfa1xw5cuSCszRce9asWbr88stb9NoAAAAnY73FegsAALQu1lustwBvx8kwwGINu0vO9oN83759LfZemZmZjT2LT2aapjIzMyW5+xI3yMrKkiSNHj36tK+pq6vTrl27LjjLua5dWFio7OzsC742AADAyVhvsd4CAACti/UW6y3A21EMAyyWkZEhSVq3bt1pz1VUVOjtt99usfc6evSoPvnkk9Menzdvng4dOqTw8PDG49uS1K5dO0lSbm7uaV/zz3/+85w7cc7nXNf+3e9+1zjEFAAA4GKx3mK9BQAAWhfrLdZbgLejGAZYbMKECQoNDdX69ev1l7/8pfHxEydO6M4771RhYWGLvZfD4dADDzygbdu2NT62c+dO3X///ZKk++6775Rj5GPGjJEkPf3006csDBYsWKAf//jHCg0NveAsDdf+0Y9+1Djw0zRNvf7663rxxRcv6toAAAAnY73FegsAALQu1lustwBvRzEMsFj79u311FNPSZK+973vKS0tTcOGDVOHDh30xRdfND7XEm644QbFx8dr4MCB6t+/vwYMGKB+/frp0KFDGj58uH7xi1+c8vrHH39csbGxWrt2rdLT0zV48GB16dJFV155pYYOHarrr7/+grP84he/UEhIiD7++GOlpqZq2LBhSktL0x133KGbb75ZI0aMuNhvFwAAQBLrLdZbAACgtbHeYr0FeDuKYYAXePrpp/WnP/1Jffr0UX5+vo4cOaIbbrhB69evV3p6eou9T0hIiJYvX66HHnpIpaWlyszMVKdOnfTkk09q6dKljf2dG3Tq1EmrV6/Wddddp+DgYO3evVuhoaH6xS9+oQULFsjhcFxwlqFDh2rFihWaMmWKXC6Xdu/ercTERP3xj3/Uv/71r4v9VgEAAE7Beov1FgAAaF2st1hvAd7MME3TtDoEgNY1a9Ys3XXXXbrjjjs0a9Ysq+MAAAD4HdZbAAAArYv1FoCLwckwAAAAAAAAAAAA+C2KYQAAAAAAAAAAAPBbF94QFYAlfvWrX2n+/PlNem1KSopmz57dyokAAAD8C+stAACA1sV6C0BboxgG+Jg9e/Zo1apVTXptSw4nBQAACBSstwAAAFoX6y0Abc0wTdO0OgQAAAAAAAAAAADQGpgZBgAAAAAAAAAAAL9FMQwAAAAAAAAAAAB+i2IYAAAAAAAAAAAA/BbFMAAAAAAAAAAAAPgtimEAJEnz58/X5MmTFRsbq/DwcA0ZMkSvvPKKXC6X1dEAAAB82sGDB/XXv/5V99xzjwYOHCiHwyHDMPTcc89ZHQ0AAMDnmaaplStX6sc//rFGjhypmJgYBQcHq0OHDrr++uu1dOlSqyMC8AKGaZqm1SEAWOs3v/mNfvKTn0iSMjIyFBERoe3bt8vlcunqq6/Whx9+KJuN2jkAAMCFePjhh/WHP/zhtMefffZZPf300xYkAgAA8B+LFy/W5MmTJUk2m03dunVTeHi49u7dq/LycknS008/rWeffdbKmAAsxt1tIMCtXr1aP/3pT2Wz2fTmm29q//792rJlizZu3KikpCR9/PHH+v3vf291TAAAAJ8VHx+vGTNm6Je//KU+/fRTXX/99VZHAgAA8Bumaapbt2569dVXVVBQoMzMTG3cuFGFhYWNm7+fe+45zZ071+KkAKzEyTAgwE2fPl3z58/Xvffeq9dee+2U5958803ddtttiouL0/HjxxUUFGRRSgAAAP9x55136l//+hcnwwAAAFpAaWmpwsLC5HA4zvj8tGnT9Omnn+rqq6/WnDlz2jgdAG/ByTAggJWWlmrRokWSpO9+97unPX/jjTcqKipKhYWF9FcGAAAAAACA14mKijprIUySpkyZIknas2dPW0UC4IUohgEBbNOmTaqtrVVoaKiGDBly2vNBQUEaPny4JGnt2rVtHQ8AAAAAAAC4KNXV1ZKkdu3aWZwEgJUohgEBbO/evZKkTp06nXUHTUZGximvBQAAAAAAAHyBaZqaPXu2JOnSSy+1OA0AK1EMAwJYcXGxJKl9+/ZnfU3Dcw2vBQAAAAAAAHzBX//6V23atEnBwcF6+OGHrY4DwEIUw4AA1nBMPDg4+KyvCQkJkSRVVVW1SSYAAAAAAADgYm3cuFEPPfSQJOm5555T165dLU4EwEoUw4AAFhoaKkmqra0962tqamok0VcZAAAAAAAAvuHgwYOaMWOGqqurdeutt+qxxx6zOhIAi1EMAwJYU1ogNqWVIgAAAAAAAOANcnJyNGXKFB0/flzTp0/XrFmzZBiG1bEAWIxiGBDAunfvLkk6fPiw6uvrz/iaAwcOnPJaAAAAAAAAwBsVFRVpypQp2r9/v8aNG6fZs2crKCjI6lgAvADFMCCADR48WEFBQaqurtbGjRtPe76urk7r1q2TJI0YMaKt4wEAAAAAAABNUl5ermnTpmn79u0aPny4PvnkE8Z+AGhEMQwIYFFRUZo8ebIk6e9///tpz8+ePVulpaWKi4vT+PHj2zgdAAAAAAAAcH41NTWaOXOm1q5dq759+2rBggWKjIy0OhYAL0IxDAhwTz31lAzD0N/+9je99dZbjY9v2bJFjz76qCTp8ccfV3BwsFURAQAAAAAAgDNyOp26+eabtWTJEnXt2lWff/65YmNjrY4FwMsYpmmaVocAYK3nn39eTz/9tCQpIyNDERER2r59u1wul6ZPn645c+bIbrdbnBIAAMA3rVq1SjNnzmz8/+Xl5aqpqVFYWNgprXs2bdqkjh07WhERAADAZ7311lu69dZbJbln3icmJp7xdSkpKZo9e3ZbRgPgRRxWBwBgvaeeekoDBw7USy+9pA0bNignJ0f9+/fXXXfdpfvvv59CGAAAwEWoq6tTYWHhaY9XVlaqsrKy8f87nc62jAUAAOAXampqGn+9d+9e7d2794yvS09Pb6tIALwQJ8MAAAAAAAAAAADgt5gZBgAAAAAAAAAAAL9FMQwAAAAAAAAAAAB+i2IYAAAAAAAAAAAA/BbFMAAAAAAAAAAAAPgtimEAAAAAAAAAAADwWxTDAAAAAAAAAAAA4LcohgEAAAAAAAAAAMBvUQwDAAAAAAAAAACA36IYBgAAAAAAAAAAAL9FMQwAAAAAAAAAAAB+i2IYAAAAAAAAAAAA/BbFMAAAAAAAAAAAAPgtimEAAAAAAAAAAADwWxTDAAAAAAAAAAAA4LcohgEAAAAAAAAAAMBvUQwDAAAAAAAAAACA36IYBgAAAAAAAAAAAL9FMQwAAAAAAAAAAAB+i2IYAAAAAAAAAAAA/JbD6gAAvM/hwkqt2JuvA/kVMmWqe2KkruiXrNjwYKujAQAABLQ6p0tf7i/Uhqwildc41Tk+TJN7J6lDTDurowEAALS5vbllWpqZp2MnqtUu2K4RXWI1tnuC7DbD6mgAvIxhmqZpdQgA3mHVvgL9dsFubTlactpzoUE23Ti0o340tYdiwiiKAQAAtLWlu/P07NydOlBQccrjDpuh20d11o8v76l2wXaL0gEAALSd4yVV+ukH27Q0M/+05zISwvXD8d103ZBUGQZFMQBuFMMAqKy6Tk9+sE3zth6X5L6hMjS9vQZ2jJFpmvpyf6F2HCuVJKXGtNPr371EXRMirIwMAAAQMGrrXfrvOdv19rojkqT2YUGa1DtJceHB2nCoWOsPFUuSBqZF6x93DldcRIiVcQEAAFrVssw8PfLOZhVX1sluM3RZ93j1TolSUUWt5m87rtLqeknS+J4J+u31A5QYFWpxYgDegGIYEOD255frntfX60B+hRw2Q98ama77J3ZT/Ek3UUzT1Or9hfrJh9t0qLBSiZEheuvekRTEAAAAWllpdZ3ufX291hwoks2Qvjumix6Y1F1RoUGNr1mamadHPTeE+naI0lv3jjzleQAAAH/x6bbjuv+tTXK6TPVLjdIfbh58yv2p8pp6/evLLP1h8V7V1ruUFBWit+4ZqQzuYQEBj2IYEMD25pbplr+uVUF5jTpEh+pPtw3R4E7tz/r6wvIa3fa3tdqdU6akqBB9cv8YdtcAAAC0kqpap+74x1f6KqtIESEOvXLrYE3omXjG1+7LK9fNf1mtgvJazRiQolduGUxbIAAA4Fc2Hi7Wza+tUa3TpWsHp+o31/dXiOPMLaL35pbpB//ZqL155WzqBiBJslkdAIA1MnPKdMtf16igvEa9U6L08QNjzlkIk6S4iBD95+4R6p4YodzSGt3/5ibVOV1tlBgAACBw1Dtd+uGbG/VVVpEiQx16+96RZy2ESVK3xAj99fZhstsMzd16XHM2H2vDtAAAAK3reEmVvvfGBtU6XZrSJ0kv3jjwrIUwSeqeFKm37x2pnkmRyiur0R3/+EoF5TVtmBiAt6EYBgSgrIIK3frXNSoor1XfDlF68+4Rp7RFPJe4iBC99u2highx6KusIr24MLOV0wIAAASelxbt0ZLdeQoNsumfdw5Xv9To837N4E7t9dCk7pKkZz7aruMlVa0dEwAAoNW5XKYefnuz8stq1DMpUi/91yDZbec/AR8XEaI37xmh9LgwHS2u0n1vbFBNvbMNEgPwRhTDgABTUlWn7/5rnQor3IWw/9w9Qu3Dg5t1jYyECL144wBJ0l++OKCNh4tbIyoAAEBAWro7T39aul+S9MINAzWsc2yTv/YH47tqUMcYldXU64UFbFoCAAC+7531R7T2YJHaBdn1l9vdG7SbKi4iRH+/Y7giQx1af6hYP3l/m5gaBAQmimFAAKl3unT/mxu1P79CKdGh+uedwxUT1rxCWIMr+qXouiGpMk3pJ+9vU2097RIBAAAuVvaJKj3y7mZJ0u2j0nXVwA7N+nqH3aZfXN1XkvTBpmxtPXqihRMCAAC0nbzSav1q/i5J0o+m9lB6XHizr9EtMUKv3jZEdpuhDzZl65+rslo4JQBfQDEMCCC/nLtTX+wtULsgu/56+zAlRoVe1PWent5HseHByswt01+/ONBCKQEAAAJTbb1LP/zPRp2orNOAtGg9Nb33BV1nYMcYXTs4VZL03Lxd7H4GAAA+638WZKqsul4D0qJ116VdLvg6Y7sn6Klp7rXVbz7dre3ZJS0VEYCPoBgGBIjXV2fp9dWHZBjSyzcPatLcifOJDQ/W056bNK8u3af8MgaRAgAAXKhff7pLm4+cUFSoQ3+6dcg5h8Kfz48v76kQh01fHSzSl/sLWzAlAABA29h5rFQfbDoqSfrlzH5NmhN2Lndd2llT+iSp1unSA29tUkVNfUvEBOAjKIYBAeCLvfn6xSc7JUmPX95Ll/dNbrFrXzMoVQPTolVR69TLi/a02HUBAAACyafbjje27PndTYPUMTbsoq7XIaadbrmkkyTpf5fsu9h4AAAAbe7Xn+6SaUozBqRoUMeYi76eYRj67fUDlBIdqoMFFfrvOTsuPiQAn0ExDPBz+/LK9YP/bJTTZeq6Iam6b1xGi17fZjP0U88x87fXHdG+vLIWvT4AAIC/yyqo0OPvbZUkfe+yDE3pk9Qi1733sgw5bIZWHyjUhkPFLXJNAACAtrB6f6G+2FugILuhxy/v1WLXbR8erD/cPFg2Q3p/41HN23q8xa4NwLtRDAP8WHFFrb77r3Uqq67XsPT2+vV1/WUYF3ek/ExGZMRpSp8kOV2mXlq0t8WvDwAA4K8qaur1vTc2qKymXsM7t9djl/dssWt3iGmn64a4Z4f9eRmnwwAAgO941bN2uXl4J3WKu7gT8990SZdY/XBCN0nSUx9tU15pdYteH4B3ohgG+Knaepfu+/cGHSqsVFr7dnrt20Mvau7E+Tw6pYckaf6249qby+kwAACA8zFNU4+/v1WZuWVKiAzRK7cMUZC9ZT+i3TeuqyRp8e48ZRVUtOi1AQAAWsP27BJ9sbdAdpuhey9r2Q5HDR6c1F39UqN0orJOj7+/VaZptsr7APAeFMMAP2Sapv57znatPVikiBCH/n7HcMVFhLTqe/ZOidLlfZNkmtIrzKUAAAA4r7+sOKB5W4/LYTP059uGKDk6tMXfIyMhQuN7Jsg0pTfWHGrx6wMAALS0/1u+X5J7VtjFzlE9myC7TS/dNEjBDpuWZebrP2sPt8r7APAeFMMAP/T3lQf19rojshnSK7cMVs/kyDZ53wcndZckfbL1mPbllbfJewIAAPiihTty9D8LdkuSfnZ1Xw3rHNtq73XH6M6SpHfXH1FlbX2rvQ8AAMDFOlRYofnb3HO8Gk64t5buSZF64gr3PLLn5+3SQU7RA36NYhjgZ5bsztXz83dJkp6a3kcTeiW22Xv37RCtKX3cp8P+tJTTYQAAAGey9kChHnhrk1ymdMslHfWtEZ1a9f3GdU9Q57gwlVXX68NN2a36XgAAABfjLysOyGVK43smqHdKVKu/312jO2t01zhV1Tn16LubVe90tfp7ArAGxTDAj2TmlOmBNzfJ9NxY+c6lnds8w4MT3afD5mzOZkcNAADAN6w9UKjv/mu9autdmtw7Sc/O7CfDMFr1PW02Q98amS5JevurI636XgAAABequKJW7204Kqn1T4U1sNkMvXDjQEWGOLTp8InGFo0A/A/FMMBPFJTX6Duz1qmi1qmRGbH6ZRvcWDmT/mnRmtgrUS5T+r9lLCAAAAAafL4zV7f/4yuV19RrZEas/vfWwXLY2+Yj2XVD0hRkN7Qtu0S7c0rb5D0BAACaY/aGI6qpd6lvhyiN6NJ6LaS/KTWmnX4xs68k6eVFe7U9u6TN3htA26EYBviB6jqn7n19vbJPVKlzXJj+fNtQBbXRjZUz+eGEbpKkDzYd1bETVZblAAAA8AYul6mXF+3RPa+vV029S5N7J2rWXZcoNMjeZhliw4M1qVeSJGn2+qNt9r4AAABN4XKZ+veaw5Kkb49Mb/MN3tcOTtWV/ZJV7zL1yDubVV3nbNP3B9D6KIYBPs40TT3x/lZtPHxCUaEO/ePO4WofHmxppqHp7TUqI051TlN/WXHA0iwAAABW2p1TqpteW62XF+2VJH1rZCf9+VtD27QQ1uDGYWmSpI82ZauOeRgAAMCLLN+br8NFlYoMdWjmoNQ2f3/DMPT8tf0VHxGivXnlemFhZptnANC6KIYBPu6VJfs0Z/MxOWyG/vytocpIiLA6kiTp/onu02FvfXVY+WU1FqcBAABoW/vyyvTou5s1/Y8rtf5QscKC7XrhhgF67pr+lp3gH9cjQQmRISqsqNWS3XmWZAAAADiTf68+JEm6cWhHtQtu+01Dkvsk/W9v6C9J+vvKg/pyf4ElOQC0DophgA+bt/W4fv/5HknSs9f006Xd4i1O9LXRXeM0qGOMaupd+vvKg1bHAQAAaFX5ZTVatDNXLy7M1LQ/fKHJv1+hDzZmy+kydUXfZC16dJxuHNbR0owOu03XDXbvtKZVIgAA8BZHiiq1JNO9UedbIztZmmViryTdcok7w2PvblFpdZ2leQC0HIfVAQBcmO3ZJfrR7M2SpO+O6dL4g9pbGIah+yd0092vr9cbq7N037gMxYRZ274RAADgYuSVVWv38TIdKqrUoYIKZRVW6mhxpbJPVKmsuv6U19pthib2StT9E7ppYMcYawKfwY3D0vTaigNampmn/LIaJUSGWB0JAAAEuDe/OizTlMZ2j/eKjkdPT++tL/cX6FBhpX4+Z4d+/1+DrI4EoAVQDAN8UH5Zje59fb2q61wa1yNBP53W2+pIZzSpd6J6JUdqd06ZZn2ZpYcn97A6EgAAQJM5XaY2HCrW/G3HtSwzT1mFlWd9rWFI3RIiNLBjjC7pHKvJfZIUa/Ec1zPplhipQR1jtPnICX285Zi+O6aL1ZEAAEAAq3e69N4G94n120Z4x0bv8BCHfn/TQN34f6v1waZsTemTpCv7p1gdC8BFohgG+Jjaepe+/+8NOlZSrYz4cP3xlsGy2wyrY52RYRj64YRueuCtTfrnqizdPTZDESH8tQMAALxbbb1Lb687rFeX7ldOaXXj44YhZcSHq0t8hNLjwpQeF6aOsWHq2L6dUmPCLJtv0VzXDk6lGAYAALzC8j35yi+rUWx4sCb2SrI6TqOh6bG6b1xXvbpsv3764TYNTW+vxKhQq2MBuAjclQZ8zM8+3q71h4oVGeLQX+8Ypuh2QVZHOqdp/VP00ud7dKCgQv9Zc0jfG9fV6kgAAABnteFQsR6bvUUHCyokSZGhDk3pk6Qr+iZrREac16+9mmJa/xT9cu5ObTlyQlkFFeocH251JAAAEKAa5pheOzhVwQ6bxWlO9fDkHlqWma+dx0v1xPtb9Y87h8swvHNDOoDz866/YQCc07vrj+itr47IMKQ/3jpYXb2gj/L52G2Gvj/eXQD76xcHVV3ntDgRAADA6UzT1J+W7tNNr63WwYIKxUeE6Nlr+mn905P1+5sGaWrfZL8ohElSQmSILu0WL0n6eMsxi9MAAIBAVVheo0W7ciVJNw3raHGa0wU7bHrpvwYp2G7T0sx8vfXVEasjAbgIFMMAH7HreKme+Wi7JOlHU3poQs9EixM13TWDU5Ua004F5TV6dz0LBwAA4F1q61360ewtemFhppwuUzMHddDiH43Tt0emK8ThG60Pm2vmwA6SpI82Z8s0TYvTAACAQPThpmzVu0wNSItWz+RIq+OcUc/kSP348p6SpGfn7mzsHgDA91AMA3xAeU29fvifjaqpd2lcjwT9YHw3qyM1S5DdpvvGZUiSXlt+QHVOl8WJAAAA3OqcLv3gPxv0wcZs2W2GfnVtf/3h5sF+cwrsbKb2TVKIw6YD+RXacazU6jgAACDAmKap9za4WyTe6IWnwk723TFdNCojTlV1Tj38zmbuawE+imIY4AOe/nCbDhRUKCU6VC/91yDZbL7Xn/jGYR2VEBmi7BNV+nBTttVxAAAA5HKZeuL9rVq0K08hDpv+dscw3Tqik9Wx2kRkaJAm93YPqadVIgAAaGvbsku0O6dMwQ6brh7Qweo452SzGfrdTQMVGerQliMn9L9L9lkdCcAFoBgGeLlPtx3XR5uPyWZIr9wyWLHhwVZHuiChQXbdM7aLJOnPy/bL6aIdDwAAsNbLi/Y0ngj787eG+FQb6pZw9SD3jaePNx+Ti7UZAABoQ7PXu0+FXdE3WdFh3n8iv0NMOz1/bX9J0v8u3acNh4otTgSguSiGAV6soLxGT3nmhH1/fFcN6xxrcaKLc9uIdMWEBelgQYXmbztudRwAABDAlu7O0x89u3p/c11/TeyVZHGitje+Z4IiQx3KKa3WV1lFVscBAAABorrOqTmb3V2DbvLyFoknu3pgB10zqIOcLlOPvrtZ5TX1VkcC0AwUwwAvZZqmnv5wu4oqatUrOVIPTupudaSLFh7i0F2j3afD/rR0H8PaAQCAJbJPVOnhdzZLkm4fle71cypaS4jDrmn9UiRJczbTKhEAALSNRbtyVVpdr9SYdhrdNc7qOM3yi5n9lBrTTocKK/XsJzutjgOgGSiGAV7qk63HtWBHjhyevsQhDrvVkVrEnaM7KyLEod05ZZrH6TAAANDGTNPUTz7YppKqOg1Mi9ZT03tbHclSMz2tEj/dfpxh8AAAoE18sNF9KuyawR1ksxkWp2me6HZB+t1NA2UY0jvrj2jB9hyrIwFoIophgBcqqarTLz27Sx6Y2F19O0RbnKjlRIcF6Z6xGZKk/1mwWzX1TosTAQCAQPLehqNasSdfwQ6bfv9fg/xmw9GFGpERp/iIYJ2orNOX+wutjgMAAPxcQXmNlu/JlyRdOzjN4jQXZmRGnL53WVdJ0k8+2Kq80mqLEwFoCophgBd6cWGmCsprlJEQrvvGZ1gdp8Xdc1kXJUWF6EhRlV7/8pDVcQAAQIAoLK/Rs3PdG44endJDXRMiLE5kPbvN0JWeVonzttIqEQAAtK5PthyT02VqYFq0uiX67lrs0Sk91CclSsWVdfrxe1sZBQL4AIphgJfZdrRE/17rLhA9d00/v9ytHBbs0I+m9pQkvbJkr4orai1OBAAAAsHvP9+j0up69e0QpbvHdLE6jteY1t9dDFu4I5dWiQAAoFV9uMndIvHawakWJ7k4wQ6b/nDzIIU4bFq+J19vrGGzN+DtKIYBXsQ0TT07b6dM0z2/YXTXeKsjtZrrh6Spd0qUSqvr9YfFe62OAwAA/NzunFK99dVhSdJ/z+gjh52PQg0u6RKr+IgQlVTVadW+AqvjAAAAP7Uvr0xbj5bIYTN01cAOVse5aN2TIvWTK3tJkp6ft0v78sosTgTgXPgECHiRz3bm6quDRQpx2PTEFb2sjtOq7DZDT01zD6x/Y80hbc8usTgRAADwZ8/P2yWXKU3rn6wRGXFWx/Eqdpuhaf2TJUnzth63OA0AAPBXH2x0nwob3zNBcREhFqdpGbeP6qzLeiSopt6lh97erNp6TtkD3opiGOAlautd+vX8XZKke8ZmqENMO4sTtb4x3eM1fUCKnC5TT36wVfW05QEAAK1gXVaRvthboCC7oSev6G11HK80vbFVYg43cQAAQItzuUzN2eyeT3rt4DSL07Qcm83QCzcMUPuwIO04Vqo/LN5jdSQAZ0ExDPAS/15zSFmFlYqPCNF947taHadNFBQUqGvRWpV+/id99twdCgkJlmEYevvtty/oej//+c9lGMZZ/3nyySdb+DsAAAC+4A+L3C2ZbxjaUZ3iwixO03oKCgr0t7/9Tffee68GDRokh8PR5LXVsM6xSogMUWl1/SmtErOzs/X9739fGRkZCgkJUUREhIYMGaIXXnhBNTU1rfntAAAAP7L2YJGyT1QpMtShSb0TrY7TopKiQvXr6/pLkl5bfkC7c0olSd/5znca70mtWbOmWdc8cuSIXn31Vd1xxx3q3bu3bDbbBV0HwNccVgcAIJVV1+mPS9w3aR6d0kMRIYHxn+bKlSv1owd+0OLXvfTSS9WtW7fTHh86dGiLvxcAAPBu67OKtHJfgRw2Qz/w8w1HK1eu1D333HNBX2u3GZrWL1n/Wn1I87Yd14ReidqzZ48uvfRSFRQUKCMjQ1dddZUqKiq0cuVKPf744/r444+1ZMkSBQUFtfB3AgAA/M2Hm45Kcp9GDw2yW5ym5V3RL0WX903Swh25+skH23R/zxr985//lGEYMk2z2dd7//339cgjj7RCUiBwBcYdd8DLzVqVpROVdcpICNdNw/znqPj5JCUl6Qc/+IGGDRumd7KCtfL9v6tix1I5XRfXmufuu+/WnXfe2TIhAQCAT/vT0n2SpBuGpqljrP+eCpO+XlsNHz5cw4cP1//8z//ojTfeaPLXTx/QQf9afUgLd+ToV9f215NPPqmCggLdf//9evnll2W3u29c5eXlacyYMVq5cqX+/e9/66677mqtbwkAAPiBqlqn5m/LkSRdN8R/73v94up+WrWvUBsP5Om23zyqvn37Kjo6Wl9++WWzr5WRkaFHHnmkcV139913a/ny5a2QGggcFMMAi5VW1+mvXxyQJD00qbsc9sDpXjpq1CiNGjVKkjSxsEKD5sySJC3cnqvbLMwFAAD8w/78ci3NzJdhSPeN8+9TYdKpaytJstmat64clt5eiZEhyiur0cp9+VqxYoUk6emnn24shElSYmKifvCDH+iRRx7RunXrKIYBAIBz+nxXrspr6pXWvp2Gpbe3Ok6rSY4O1Y8v76kHH3tCpUcO6S8LPtfvf/3sBV3r6quv1tVXX93CCYHAFjh33YE2kJWVJcMwNH78eFVUVOjRRx9Vx44d1a5dOw0ZMkSffPJJ42tnz56tSy65RAnto7XjhZvlXPUPTep++oKgvLxcv/zlL9W/f3+FhYUpKipK48aN00cffXTGDPPmzdN3vvMd9e7dW1FRUQoPD9fAgQP1q1/96oxzHWbNmiXDMPTzn/9chw8f1q233qqEhAS1a9dOw4YNOyVza0qPC9fgTu7vf8GO41q9v7BN3hcAAHivC1lbhYeHKykpSQ8++KD+umS3JGlSr0R1jg+XFDhrqwthsxma1j9FkjR363GFhISc92tiY2NbOxYAALDAxa7DqqqqGp//aFO2JGlarxg999yzfr0OGxRRprKvPlDEgCladiKu1d8PQNNRDANaQW1trSZNmqQ33nhDgwYN0siRI7VlyxZde+21WrRokV566SXdeuutMmx2hXQeLJkuHV35gb5376kzHnJzczVixAj97Gc/U3FxsaZMmaIRI0Zow4YNuvbaa/Wb3/zmtPf+7ne/q9mzZys6OlpXXHGFxo4dqyNHjuipp57StGnT5HQ6z5g5KytLw4cP16pVqzRmzBgNHjxYGzZs0DXXXKPPPvusVX6fvqmTp3WRaUoPv7NJRRW1F3SdJUuW6OGHH9Z9992n5557Ths2bGjJmAAAoI01dW3lcDg0depUOZ1OvfLKK/rzcz+WJH3n0i6SAm9tdSGmD3AXwz7fmauJkyZLkp5//nm5TmpjnZeXp1dffVUOh0O33cZ5fgAA/NmFrsPuvvtuSVJxRa1W7MmXs6JY/3ziNr9eh7lcLt33vXsVEx2tmPF36YNN2SqvqW+19wPQTCaAFnPw4EFTkinJHD9+vFlUVNT43D//+U9TktmtWzczNjbWXLFihfnS55lm+hNzzbE/e89MTEw0JZn79+9v/Jorr7zSlGQ+/vjjZm1tbePj+/fvN7t27Wra7XZzy5Ytp2T48MMPzfLy8lMeKy0tNWfMmGFKMv/1r3+d8lxDLknmAw88YNbV1TU+9/LLL5uSzLFjx572vaanpzd+XVP/OXjw4Dl//+644w5TktnntmfM9Cfmmnf8Y63pdLrO+TUn+9nPfnbW977++uvNsrKyJl8LAABYr7lrqwbZ2dlmZPs4U5I55qm3TJfLvZ4I1LXVW2+9dc7XnczpdJmXPP+5mf7EXPOd5VvMvn37mpLMjIwM84YbbjCvvPJKMyIiwkxPTzfnzp3b5OsCAADfcjHrsJPvcf17TZaZ/sRcM6H3CL9fh/3xj39szPXYu5vN9CfmmnHdBpmSzNWrVzftN/4sxo0b1yLXAQIZM8OAVmC32/XXv/5V7dt/3fbw9ttv1+OPP659+/bpv//7vzV0xCg98JslkqQfXztKS0tv00svvaQVK1YoIyNDmzdv1qeffqrRo0frN7/5jQzDaLxWRkaGfve73+maa67R3/72N/3xj39sfO6aa645LU9kZKReeuklzZ07V3PmzNHtt99+2msarulwfP3Xwg9/+EP94he/0Jo1a1RbW6vg4ODG52644QYVFBQ06/clIiKiSa/7zqWd9Zdsm5Zl5usvXxxo8oyPbt266cUXX9SVV16p9PR0FRcXa8WKFXr88cf1/vvvy+l06sMPP2xWZgAAYL2mrK3Gjh3b+FxiUrIi+oxX2ar31c+WLcMwAnpt1Rw2m6Er+6Vo1pdZWnPcpeXLl+uWW27R559/rgMH3HNuDcPQ9ddfrz59+rT4+wMAAO/S3HVYhw4ddNttX9/jml/TU7W5B5S/a61fr8OOHj2qp556SuPHj9ftt9+uvLJqzd92XDmcDAO8BsUwoBV07txZ3bp1O+Uxm82m9PR05efna8qUKXp33RGdqKxTp9gwTeufosNd3QWf48ePS5I+//xzSdLMmTNPWSQ0GDNmjCRp3bp1pz23d+9ezZ8/X/v27VNFRYVcLpdM02x87kzGjx+voKCgUx5zOBzKyMjQhg0bVFhYqJSUlMbnXnzxxSb9XlyI1PZh+vnQvvrJB9v0wsJMDUtvr2Gdzz+P4lvf+tYp/z88PFy33nqrJkyYoP79++ujjz7Sl19+qdGjR7dWdAAA0AqasrY62eLdeaoJS5AkdQiulhTYa6vmmjHAXQz7ZOlqvfvYVXLY7ZozZ44uu+wyVVRU6L333tNPfvITLViwQKtWrVLXrk3buAQAAHxPc9dhkhrXBpkHDmtdXYKqsjZJ8u912A9/+EPV1NToz3/+syQpMTJUD0zqrodnuZ+vrKUoBliNYhjQClJTU8/4eHi4e3B7UnKKnnz/oCTpnssyZLcZjc81DADNysqSJD3xxBN64oknzvpeJ+9cMU1Tjz32mF566aXGhcE3lZWVnfHxtLS0Mz7esNPlTINJW9PNwztqzYFCzdl8TA+8tUnzHxyr9uHB5//CM0hJSdFdd92lF198UQsXLqQYBgCAjznf2uqbz7/11WEZQaGSJGd9nSTWVs0xpFN7JYY7tOmvz8t14rjWr1+vwYMHS5JiYmL00EMPyel06kc/+pGeeeYZvfnmmxYnBgAAraW567CTn9t+pEBmkhTnKtEJ+e867P3339fHH3+sZ555Rr169Wp8/K5LO+vJILtqJL2/4agmXtaibwugmSiGAa3gTLtcTrZsT4GOFlcpNjxYNw498w/ohiGgY8eOVUZGxlmvFR8f3/jrd955R7///e+Vlpaml19+WaNGjVJCQoKCgoJUW1urkJCQsy4gzpf5mx577LFmHyF/8cUXT8l7LoZh6Plr+2vb0RIdKKjQj2Zv0d9uHyabrXk5G3Tv3l3S1yfvAACA7zjfOuXk54+dqNLyPfmnvSbQ11bNYbMZ6heUq3VF2YpJ7thYCDvZTTfdpB/96EdatmxZi78/AADwHs1Zh31TZk6ZlCSlx4Zqv/x3HfbJJ59IcnciWLFixSmvq893b4b/+/88rU3vv6pHH35QN9xwQ7PeC0DLoBgGWOCtrw5JCtcdozorNMh+xtc07GK54YYb9OCDDzbpug3zsP785z9rxowZpzzXMOOhpbz33ns6dOhQs77m5z//ebNu2ESEOPS/tw7RNa+u0pLdefrrFwf0vSbOD/um4uJi9zVbYbYGAADwHrPXH5VpSl0TwlV40uOsrZonI8y9Y7raCFFtvUvBDtspz0dFRUmSioqKWuX9AQCA78srq1G8zdCI/j205CP/X4etWbPmrK+vyd2v1bn7dfSG6y4oI4CLZzv/SwC0tD255QoNsunbo9LP+prJkydLkj766KMmX7eh4NOxY8fTnnv33XebF/I8srKyZJpms/7p3Llzs9+nT4co/fyqvpKk3y7M1IZDzb/hYppm4yJq6NChzf56AADgG5wuU++uPyJJGtEl7pTnWFs1z6i+7g1INQVH9fmWrNOeb5jp0ZoZAACA7xvbPV5XT7tckv+uw2bNmnXW140bN06SlPytF9Xlybm66ra7WzQ7gKajGAZY5IahaYo9xwyskSNHatKkSVq6dKkeeeQRlZeXn/K8y+XSZ599ppUrVzY+1qNHD0nSX/7yl1OOin/xxRd64YUXWvg7aDu3XNJRVw3sIKfL1L1//lw9evQ8pQez5O4r/frrr5/W97m8vFzf//73tXbtWiUnJ+vaa69ty+gAAKANrdpXoOwTVYoKdah/WvQpz7G2OrPs7Gz16tXrtLXVpZeOVnh0rMy6aj3xo4dOWWMdO3ZMjzzyiCTR5gcAAJzm5HXT1YM6sA6TNLxze7lM6fef7Wl87GzrMACtg2IY0IZq612Nv/72yM7nff1//vMfDRgwQC+//LLS09M1adIk3XzzzRo7dqySk5N1+eWXa/369Y2vf/DBBxUeHq5XX31V/fr10y233KLLLrtM48aN03333dca39JFGzlyZOM/8+bNkyQ988wzjY/94Ac/kGEY+tW1/dQlPly5JRXau3ePMjMzT7lOeXm57rjjDiUmJmrkyJG66aabNHXqVHXu3FmvvfaaYmJi9N577yksLMyKbxMAALSBd9a5T4VdOzhVQfbTP+qwtnKvrU5WV1enzMzM09ZWoaGhevo3L0s2u3Ysn6uuXbvqmmuu0eWXX65evXpp27ZtGjJkiJ588sm2+tYAAICPyC6ukiQ5bIam9EmWFBjrsHO5dWS6DEOat+24tmeXSDr7Okxyz7w/eV23ceNGSdLdd9/d+Nizzz7bpt8D4OuYGQa0obwy947agWkx6pkced7XJyUlac2aNfq///s/vfPOO1q3bp1qa2uVkpKiwYMHa+bMmbrpppsaX9+jRw+tW7dOTzzxhNauXauPP/5YPXv21GuvvaZ77rlHL774Yqt9bxdq7dq1pz22b98+7du3T5L7RowkRYYG6X9vHawZv8o643Xi4uL0xBNPaM2aNdq3b582b94su92uLl266M4779Qjjzyi1NTUVvs+AACAtYoqavXZzhxJ0n8N76SvPlt/2mtYW329tmqKH9/7Lf1ra7kOL39HtUV7NX/+fAUHB6t79+666aab9PDDD6tdu3Ytlh0AAPiHTUfcLQ67JEQoIsR9+zkQ1mHn0jkuXDMHxuqjzcf0+8/36B93Dj/n62tqas64rtuxY0fjrzlRBjSPYZ58zhRAq6lzunTpb5Yor6xGr9wyWFcN7GB1JJ/07zWH9PRH22W3GXr3e6M0NL291ZEAAIAXeGN1lp6Zs0N9O0Rp3oNjrY7jN3764Ta9ufawbrmko3593QCr4wAAAC/ncpka/Zslyimt1l++PVRT+yZbHclrHCyo0KTfLZPLlOY+MEb9UqPP/0UAWgxtEoE28vnOXOWV1Sg+IkSXsxC4YLeN6KQZA1LkdJl64M2NKqmqszoSAADwAh9uypbkbpGIljOtX4okaeGOXNU7Xed5NQAACHRfZRUpp7RaUaEOjeuZYHUcr9IlPrxxc/z/LtlncRog8FAMA9rIG6sPSZJuuaSjgh38p3ehDMPQr6/rr/S4MB0rqdZvF+y2OhIAALDYocIKbTx8QjZDuprT9y1qREas2ocFqaiiVl8dLLI6DgAA8HJzNh+TJF3RL1khDrvFabzP/RO6yTCkBTtytCe3zOo4QEDhjjzQBg7kl2v1gULZDOmWSzpZHcfnRYYG6TeeNj1vfnVYGw4VW5wIAABY6aNN7psul3aLV2JU02di4fyC7DZN9Qy+n7/9uMVpAACAN6utd+lTz3ph5iBO659J96RIXdnPvbbidBjQtiiGAW3gvQ1HJUnjeiSoQwxDxlvCqK5xumFomkxTeurDbbTtAQAgQJmmqQ83uddatEhsHdMGuFslLtieK6eLkdMAAODMvtibrxOVdUqIDNHIjDir43it+yd0lyTN3XpMB/LLLU4DBA6KYUArc7pMfbDRPcPixmEdLU7jX346rbdiwoK0O6dM7288anUcAABggc1HTiirsFLtguzMZW0lo7vGKbpdkArKa7Q+i1aJAADgzD7e4j6tP2NAiuw2w+I03qtPhyhN7p0olyn9beVBq+MAAYNiGNDKvtibr5zSasWEBWlS70Sr4/iV2PBg3T+hmyTpd5/tUWVtvcWJAABAW/tok3vT0dS+SQoPcVicxj8F2W2a0idJkvTp9hyL0wAAAG9UWVuvz3bkSmKGa1Pce1lXSdL7G46qsLzG4jRAYKAYBrSy2Z4WidcMSmVwaCv49qh0dYxtp7yyGv39C3bTAAAQSOqcLn2y1T2XghaJrWtaf/epu0+3H5eLVokAAOAbFu3KU1WdU51iwzSoY4zVcbze8M7tNbBjjGrqXXpjzSGr4wABgWIY0IpOVNbqc8+umBuGplmcxj+FOOz68eW9JEn/t3y/CthNAwBAwPhib76KKmoVHxGsMd3irY7j1y7tFq/IEIdyS2u06Uix1XEAAICX+Xiz+7T+1QM7yDBokXg+hmHonrFdJEmvrz6k6jqnxYkA/0cxDGhFczYfU63Tpd4pUeqXGm11HL81o3+KBqRFq6LWqVcW77U6DgAAaCMfbnLPpbhqYAc57Hy0aU0hDrsme1olzt9Gq0QAAPC1kqo6Ld+TL0m6ehAtEpvqir7JSmvfTkUVtXp/41Gr4wB+j0+MQCtq+EF2I6fCWpXNZuiJK9ynw95ad0R5pdUWJwIAAK2tqtapxbuYS9GWruznaZW4jVaJAADga4t25qrOaap7YoR6JEVaHcdnOOw2fXeM+3TY3744yPoKaGUUw4BWciC/XFuPlshuM9gV0wZGd43TkE4xqq136W8rmR0GAIC/W7I7T5W1TqW1b8dcijZyWY8EhQfbdaykWluOnrA6DgAA8BLztrlnuE4fkGJxEt9z07COigx16GBBhVbtL7A6DuDXKIYBrWTOZnfbnjHd4hUfEWJxGv9nGIbun9hNkvTvNYdUXFFrcSIAANCa5m51r7WmD0hhLkUbCQ2ya2Jvd6vET7fTKhEAALhbJH6x190icXp/imHNFR7i0PVD3B2l/rPmsMVpAP9GMQxoBaZpao5ncOg1gzkV1lYm9ExUn5QoVdY6NevLLKvjAACAVlJeU68lu/MkSVcNYK3VlqZ5WiXO33ZcpkkrHwAAAt3nnhaJPZMi1Z0WiRfk1hGdJEmf78pVTgmjP4DWQjEMaAVbjpYoq7BS7YLsmton2eo4AcMwDP1wgvt02Kwvs1ReU29xIgAA0BoW78pVTb1LnePC1LdDlNVxAsr4nolqF2TX0eIqbc8utToOAACw2DzPaf1pnAq7YD2SInVJ51g5XabeWXfE6jiA36IYBrSChlNhU/okKTzEYXGawHJFv2RlJISrpKpOb3/F8XIAAPzR3K3uuRQzBnSgRWIbaxds14ReCZKk+duPW5wGAABYqaSyTl/sdc+5mj6AzeAX47aR7tNhb687rHqny+I0gH+iGAa0sHqnS59scd8YmDmItj1tzW4zdPeYDEnSG2sOyeWifQ8AAP6ktLpOyzPdcylmDGQHshUadn5/SqtEAAAC2sKdOap3meqVHKluibRIvBhX9EtWbHiwjpdUa6lnrQugZVEMA1rYl/sLVVBeo/ZhQbqsR4LVcQLSNYM7KCrUoUOFlVq2J8/qOAAAoAV9viNXtU6XuiVGqCdzKSwxoWeiQhw2ZRVWaudxWiUCABCo5m9zbwanReLFC3HYdeOwNEnSv9ccsjgN4J8ohgEtrGEhcGX/FAXZ+U/MCmHBDv3X8I6SpFlfsoAAAMCfzPXMpZjeP4UWiRYJD3FonGfT18IduRanAQAAVjhRWauVnhaJFMNaxq2XuFslrtibr8OFlRanAfwPd+qBFlTvdOmzne4bAtNZCFjq2yM7yzCkFXvytT+/3Oo4AACgBZyorG2cS3EVLRItdXlf91yQz3bkWJwEAABY4bMduSe1SIywOo5fSI8L19ju8TJN6a11h62OA/gdimFAC/rqYJGKKmrVPixII7rEWh0noHWKC9OkXomSpDdWczoMAAB/cOpNF1okWmlir0TZbYZ255SxcxkAgAA019MZacYANii1pIbTYR9sPCqni9msQEuiGAa0oE+3u3fGTu2TLActEi13x+jOkqT3NhxVRU29tWEAAMBF+8TTIpGbLtZrHx6sSzq7N399tpPTYQAABJLiilp9uY8Wia1hYu9ExYQFKbe0Rqs8v8cAWgZ364EW4nKZWuBpE3Nl/2SL00CSxnSLV5f4cJXX1DfOcgMAAL6psLxGX+4vlCTNGNDB4jSQpKl9kySpsU04AAAIDJ/tzFG9y1TvlChlJNAisSWFOOy6eqB7rfvehqMWpwH8C8UwoIVsOFys/LIaRYY6NLprvNVxIMkwDN04LE2SNHs9CwgAAHzZgh05crpM9UuNUuf4cKvjQNKUPu5i2PqsIhWW11icBgAAtJW5W2mR2JpuGOq+l7VwR45Kq+ssTgP4D4phQAtpOHk0pU+Sgh38p+Utrh+SJpshfZVVpAP55VbHAQAAF2juloabLpwK8xZp7cPUt0OUXKa0eHee1XEAAEAbKK6obTytT4vE1tE/NVrdEyNUU+/SvK10OgJaCnfsgRZgmqYWeuaFTevHQsCbJEWFalyPBEkcLwcAwFfllVVr7UH3TZfp3HTxKlP7uNuDf7aDVokAAASChZ7T+n1SotSF0/qtwjCMxtNh3MsCWg7FMKAFbMsu0bGSaoUH2zWmOy0Svc1NwzpKkt7feFT1TpfFaQAAQHN9ui1HLlMa2DFGHWPDrI6DkzTMDftib74qa+stTgMAAFrbPE9npOm0SGxV1w5Olc2QNhwq1sGCCqvjAH6BYhjQAhbtcreFuaxHgkKD7BanwTdN6p2k2PBg5ZbW6Iu9BVbHAQAAzdTQHuYqbrp4nV7JkeoY20419S6t2JNvdRwAANCKik5qkchp/daVGBWqsd3dnY7mbM62OA3gHyiGAS1g0U53W5jJvZMsToIzCXbYdM2gVEnSu+uPWJwGAAA0R05JtdYdKpLEXApvZBgGrRIBAAgQDS0S+3aIUmdaJLa6qwe6Z+V+vOWYTNO0OA3g+yiGARfp2Ikq7TxeKpshTeiVaHUcnMVNw929lhftylVheY3FaQAAQFPN23ZcpikNS2+vDjHtrI6DM5jax70hbPHuPNXRkhoAAL/VcFqfFoltY2rfJIU4bDqQX6Edx0qtjgP4PIphwEVavMu9A3ZoenvFhgdbnAZn0ys5SgPSolXnNPXhJo6XAwDgK+ZuPSZJmsFNF6/VsA4uqarTuoNFVscBAACtoLC8Rl/ud4+eoEVi24gMDdKk3u6N959sOWZxGsD3UQwDLlLDvLBJtEj0ejcOdZ8OoxgGAIBvOFpcqU2HT8gwaJHozRx2myZ5OiR8tpNWiQAA+KOFO3LlMqV+qVFKj6NFYls5uVWiy0WrROBiUAwDLkJ5Tb1WewaHMi/M+00f0EEOm6Edx0q1L6/M6jgAAOA8GlrxjOgSq8SoUIvT4Fym9m2YG5bDTAsAAPzQvG3uk0nT+3ewOElgGd8zUZEhDh0vqdb6Q8VWxwF8GsUw4CJ8sSdftU6XOseFqWsCu2K8XWx4sC7rkSBJmrOZ4+UAAHi7uY1zKbjp4u3Gdo9XuyC7jpVUM9MCAAA/U1Be07gZnBaJbSs0yN646ejjLXQ6Ai4GxTDgIjS0SJzcO0mGYVicBk0xc5D7ZtqczcfYtQwAgBc7VFihbdklshnSlf2SrY6D8wgNsmucZ9PRwh05FqcBAAAtacH2HLlMaUBatDrFhVkdJ+Bc7bmXNX9bjuqdLovTAL6LYhhwgVwuU8v3uIthEz3DLOH9pvRJUliwXYeLKrXpyAmr4wAAgLNoOBU2umu84iNCLE6DppjSx902/HPmhgEA4Ffmb3Ovy5jhao1Lu8apfViQiipqtS6LVonAhaIYBlygncdLVVBeq/Bgu4alx1odB00UFuzQVM+Nmo9plQgAgNdqKIbNGMBNF18xoVeibIa0O6dM2SeqrI4DAABaQH5ZjdYcoEWilRx2myb3dt/L4gQ+cOEohgEXaPmefEnSqK7xCnbwn5IvmTkoVZI0d+sxjpcDAOCF9ueXa9fxUjlshq6gRaLPiA0P1pBO7SVJS3ZxOgwAAH+wYIe7ReLAtGh1jKVFolUu98wNW7gjh7EfwAXiDj5wgVZ4imHjesRbnATNNaZ7vGLDg1VQXqtVngGwAADAe8zd4j4VNqZ7vGLCgi1Og+ZoaB++eHeexUkAAEBLmLfV3VWHFonWGtM9XmHBdh0vqdbWoyVWxwF8EsUw4AKU19RrwyF3j97LPIPC4TuC7LbGo/1zNmVbnAYAAJzMNE3N2eL++XzVgA4Wp0FzTerlbuHz5f5CVdbWW5wGAABcjLyyan11sEgSxTCrhQbZNaGXe9PRAlolAheEYhhwAb7cV6B6l6nOcWFKjwu3Og4uwDWD3TfXFu7IUVWt0+I0AACgwY5jpTqQX6EQh01T+yZZHQfN1CMpQmnt26m23qWVewusjgMAAC7Cwu2eFokdY2iR6AWuaGiVuJ1WicCFoBgGXIAVe90tEjkV5ruGdGqvtPbtVFHr1BLa+AAA4DU+3uJuxTO5d5IiQ4MsToPmMgxDkzy7llljAQDg2+ZudbeunsGpMK8wvmeCgu02HSio0L68cqvjAD6HYhjQTKZparlnXthl3SmG+SrDMBpbJc7fdtziNAAAQJJcLlMfb3YXw64eRItEXzWpt/tE35LdeXK52LUMAIAvyiur1ldZ7haJV/ZPtjgNJCkyNEhjusdLkhZsp1Ui0FwUw4Bmyiqs1JGiKgXZDY3qGmd1HFyE6QPcxbAlu/NolQgAgBf4KqtIOaXVigx1aHxPNh35qhEZsQoPtiuvrEbbjzHgHQAAX7Rge45MUxrUMUZp7WmR6C0aWyXupBgGNBfFMKCZVnhOhQ1Lj1V4iMPiNLgY/VOjlda+narqnFqaSRsfAACsNsdzKmxavxSFOOwWp8GFCnHYNdbTQWHxLtZYAAD4osYWiQNokehNJvVOlM2QtmeX6khRpdVxAJ9CMQxopoYWiePYrezzTm6VOI9WiQAAWKq23tXYupgWib5vYm/33LDFu3MtTgIAAJorr7Ra6xpbJFIM8yZxESG6pEusJGnhDk6HAc1BMQxohpp6p1bvL5TEvDB/Mc2zqFuyi1aJAABYacWefJVU1SkhMkQjM2hF7esm9EyU4dm1nFNSbXUcAADQDJ96WiQO7hSj1Jh2VsfBN0zt426VyAl8oHkohgHNsCGrWFV1TiVEhqh3SqTVcdACBqR93SpxGa0SAQCwzJwt7haJVw3oILvNsDgNLlZCZIgGpsVIEu2oAQDwMfM8LRKncyrMK03unSRJWpdVpJKqOovTAL6DYhjQDCv3FUiSxnaLl2Fwk8YfGIbReDqMVokAAFijoqZen3uGgM+kRaLfmNTL0ypxF60SAQDwFbml1Vp3yN0icRrFMK/UKS5M3RMjVO8yG8e5ADg/imFAM3zpaZE4ulu8xUnQkhp2Oi3ZnafqOlolAgDQ1j7fmavqOpc6x4VpQFq01XHQQiZ5di2v3FfAGgsAAB8xf9txmaY0pFOMOtAi0Ws1rLOWsOkIaDKKYUATlVbXaevRE5KkUV2ZY+FPGlolVtbSKhEAACvM2ZwtSbp6UCqn7/1I75RIpUSHqrrO1Th3FwAAeLe5nhaJMwZwWt+bTertPoG/NDNf9U6XxWkA30AxDGiidQeL5DKlznFhDA/1Mye3SmxY9AEAgLZRWF6jL/a6W1FfPZCbLv7EMAxN9LRKXMSuZQAAvN6xE1XacKhYhkGLRG83pFN7tQ8LUklVnTYcKrY6DuATKIYBTbRqHy0S/dk0WiUCAGCJuVuPq95lqn9qtLolRlgdBy2sYcD7kt15Mk3T4jQAAOBc5nk2CA9Pj1VydKjFaXAudpuhCT0981l30+UIaAqKYUATfbnfvWN5NC0S/dLAtGilxtAqEQCAtvbhJneLxGsGp1qcBK1hVNc4hQbZdLykWjuPl1odBwAAnMPcbZ4WiQM5FeYLJnpaJS7mBD7QJBTDgCYoLK/R7pwySdLIDIph/sgwDE0f4F7szduWY3EaAAACw4H8cm0+ckJ2m0GLRD8VGmTXmG4JkqQlu9hwBACAtzpSVKktR07IZkhX9Eu2Og6a4LIeCXLYDO3Pr1BWQYXVcQCvRzEMaII1B4okSb2SIxUfEWJxGrSWhlaJi3fl0ioRAIA28NHmY5KkMd3ilRDJGstfNQx4p4UPAADeq2GG+ogucUqMpEWiL4gKDdKIjFhJzGcFmoJiGNAEDS0SR9Ei0a+d2iox3+o4AAD4NdM09ZGnReJ1Q2iR6M8m9nIXw7YcPaH8shqL0wAAgDOZt829SYkWib5lYq+v57MCODeKYUATfLm/UJJ0add4i5OgNRmGoWn93a0A5nv6ZAMAgNax8XCxDhdVKizYril9kqyOg1aUFBWq/qnRMk1pKbNZAQDwOlkFFdqeXSq7zdCV/SiG+ZLJnhP4Xx0sUklVncVpAO9GMQw4j2MnqnSwoEI2Q7rEc/QY/utKT6vEpbvzVFNPq0QAAFrLh55TYVf0TVZYsMPiNGhtDafDGPAOAID3mbvVfSpsdNc4xYYHW5wGzZEeF65uiRGqd5n6Yi9djoBzoRgGnMdqz6mw/mkxigoNsjgNWtugtBglRYWorKZeq/YVWB0HAAC/VFvvapxLcS0tEgPC5N7u038r9xaott5lcRoAAHCyhnXZjAGcCvNFDZuOluziBD5wLhTDgPNoaJE4mnlhAcFmM3RFX3erxE+35VicBgAA/7QsM08nKuuUEBmi0bShDgh9O0QpPiJEFbVOrc8qsjoOAADw2JdXpt05ZXLYDF3uuR8C39JQDFu2J19Ol2lxGsB7UQwDzsE0TX253306iGJY4LjC0x/78125qneycxkAgJb20WZ3i8SZAzvIbjMsToO2YLMZGtcjQRJzwwAA8CYNp8LGdo9XTBgtEn3R0PT2igp1qKiiVpuPnLA6DuC1KIYB55BVWKnjJdUKtts0LJ15YYFieOf2ig0P1onKOq09yM5lAABaUklVnRZ5WrjQIjGwTOjlLoYty2SeBQAA3sA0zZNaJHawOA0uVJDdpnE9Pa0SdzOfFTgbimHAOTScChvcKUbtgu0Wp0FbcdhtmtrHPdfi0+3HLU4DAIB/+XTbcdXWu9QjKUJ9UqKsjoM2NLZbgmyGtDevXEeLK62OAwBAwMvMLdO+vHIF222a0jfJ6ji4CJM8rRIXMzcMOCuKYcA5fD0vjFkWgeaKfu4+2Qt35MpFv2UAAFrMh5vcLRKvHZwmw6BFYiCJDgvS0PT2kjgdBgCAN5jnORV2WY8ERYUGWZwGF2NcD/emo905Zco+UWV1HMArUQwDzsI0Ta3xFMNGMS8s4IzuGq/IUIfyy2q08XCx1XEAAPAL2SeqGlsQzxxEK55ANN7TwmcZc8MAALDUyS0SrxqYYnEaXKz24cEa0sm96WjJbtZZwJlQDAPOYl9euQorahUaZNPAjtFWx0EbC3bYNLl3Q6vEHIvTAADgHz7ynAobmRGrDjHtLE4DK4zv6Z4btmpfoarrnBanAQAgcO04VqqDBRUKcdg0qTctEv3BxN7uTUdLKYYBZ0QxDDiLNQfcp8KGprdXiIN5YYHo8r7uVokLtufINGmVCADAxTBNs7FF4nWD0yxOA6v0SYlSYmSIquqcWpdVZHUcAAACVsOpsAk9ExUR4rA4DVrCpF7uouaqfQWqqmXTEfBNFMOAs1hzwP3hfGQXWiQGqnE9EtQuyK7sE1Xanl1qdRwAAHzajmOl7gHtDpuu6J9sdRxYxDCMxtNhS3czNwwAACuYpql5245JkmbQItFv9EiKUGpMO9XUu/Tl/gKr4wBeh2IYcAamaTaeDBvJvLCA1S7Yrgm93DdrPt1+3OI0AAD4toZTYVN6JzGgPcBNaJgbtocWPgAAWGHr0RIdKapSuyC7JvZKtDoOWohhGJrkaZW4mFaJwGkohgFncPK8sAFpzAsLZLRKBADg4tU7Xfp4i3v38bWDUy1OA6td2j1eDpuhA/kVOlRYYXUcAAACztyt7nXZxN6JCgumRaI/meApbi7Zlcd9LOAbKIYBZ8C8MDSY2CtRwXabDhRUaE9uudVxAADwSV/uL1R+WY3ahwXpsh4JVseBxaJCgzQ0vb0kaVkmrRIBAGhLpmlqnmde2FUDaJHob0ZlxKldkF05pdXaeZyRH8DJKIYBZ8C8MDSIDA3S2O7xktynwwAAQPM1tEi8amAHBTv4CIKvdy0vy6SFDwAAbWnj4RM6VlKt8GC7xvekRaK/CQ2y69Ju7vtYS2mVCJyCT6LANzAvDN90eT93q0TmhgEA0HwVNfVauMO9oeQaWiTCY3xP9wnBL/cXqrrOaXEaAAACR8OpsMl9khQaRDckf8TcMODMKIYB38C8MHzTlN5JstsM7c4pU1YBcy0AAGiOhTtyVFnrVOe4MA3uGGN1HHiJnkmRSokOVU29q3EjGgAAaF0ul6n529zFsOn9aZHoryZ4TvxtPnJCBeU1FqcBvAfFMOAbmBeGb2ofHqxRGe5Tggt20CoRAIDm+GCju0XidUPSZBiGxWngLQzDaGzNxNwwAADaxqYjxcoprVZEiIM5rn4sOTpU/VKjZJqss4CTUQwDvoF5YTiTr1slUgwDAKCpjp2o0qr9BZKka2mRiG9oaJW4lLlhAAC0ibmeFolTaJHo9yZ6Nh0t2Z1rcRLAe1AMA05imqbWHnSfDBuRQTEMX7u8T5IMQ9py5IRySqqtjgMAgE/4aHO2TFMa0SVWHWPDrI4DL3Npt3gF2Q0dKqzUQVpRAwDQqlwuU59uc2/wnUaLRL83sXeSJGnFngLV1rssTgN4B4phwEn255eroLxWIQ6bBnZkXhi+lhgV2jjn5LOdnA4DAOB8TNNsbJF4/ZA0i9PAG0WEODS8c6wkaSkD3gEAaFUbD7tbJEaGODS2e7zVcdDKBqRGKz4iWOU19VqfVWR1HMArUAwDTrLa0yKReWE4k8v7ulslfraDI+YAAJzPtuwS7csrV4jDpiv7J1sdB16qYcD7sj3MswAAoDXRIjGw2GxG4zprMZuOAEkUw4BTrDngbpE4khaJOIOpnmLYmgOFKqmsszgNAADereFU2OV9kxUZGmRxGnirCb3cc8PWHChUZW29xWkAAPBPLpepT7e7i2G0SAwck3o3zA2jGAZIFMOARqZpai3FMJxDl/hw9UiKUL3L1JJMTocBAHA2tfUuzdnsLoZdNyTV4jTwZl0TIpQa00619S6t3l9odRwAAPzShsPFyi2tcbdI7EGLxEAxpnuCguyGDhZU6EB+udVxAMtRDAM8mBeGppjax306bOF2imEAAJzNssw8FVfWKTEyRGO6ccMFZ2cYRuPpsGWZtEoEAKA1zDupRSJjQQJHRIhDI7q4N/xzOgygGAY0Yl4YmqJhbtjyPfmqrnNanAYAAO/U0CLxmsGpctj5yIFzG9/D3cJnaWaeTNO0OA0AAP7F5TI1f5u7GDZ9AC0SA83EXp65YbsohgF8MgU8mBeGpuiXGqUO0aGqqnPqi70FVscBAMDrnKis1eLd7hPUtEhEU4zuFqdgu01Hi6u0P7/C6jgAAPiV9YeKlVdWo8hQh8Z058R+oGmYG7Yuq0il1XUWpwGsRTEMEPPC0HSGYWiq53TYwh05FqcBAMD7fLLlmOqcpvqkRKlXcpTVceADwoIdGpERK8ndYhMAALSchlNhtEgMTOlx4eqaEK56l6kv9rCpG4GNYhgg5oWheab2TZIkLd6Vq3qny+I0AAB4l/c9LRI5FYbmGN/z61aJAACgZZzcInEGLRID1qTenvtYnu4NQKCiGAaIeWFonks6xyomLEjFlXVal1VsdRwAALzG/vxybT5yQnaboZmDKIah6Sb0TJAkfXWwSBU19RanAQDAP5zSIrFbgtVxYJEJnk1HyzLz5XQxnxWBi2IYIOaFoXkcdpsm9XLvqqFVIgAAX/vQcypsXI8EJUSGWJwGvqRLfLg6xYapzmlq1T5a+AAA0BLmbT0mSZraJ1nBDm4DB6phndsrMtShoopabT5ywuo4gGX4WxABzz0vzH0ybESXWIvTwFdc7mmV+PnOXJkmu2oAAHC5TH24iRaJuDCGYTSeDlu2J9/iNAAA+D6Xy9QCzwbe6QOSLU4DKwXZbRrXw73OWkKrRAQwimEIePvzK1RQXuOZFxZjdRz4iLHdExQaZFP2iSrtOFZqdRwAACy35mChsk9UKTLUocmeuQRAczTMDVu2O4/NRgAAXKQtR08ot7RGESEOje4ab3UcWGxSb/c6a/Eu5rMicFEMQ8BraJE4pFN7hQYxLwxN0y7Y3rir5jNaJQIAoA88LRJnDOjAmgoXZGRGnEIcNh0rqdbevHKr4wAA4NMW7nCfABrfM4G1GTS+R6LsNkO7c8p0uLDS6jiAJSiGIeAxLwwX6vK+7jYDDQtMAAACVWVtvT7ddlySdD0tEnGB2gXbNaqre02+dDe7lgEAuFCmaTZu3G24d4HA1j48WCMz3ONh5nnW7UCgoRiGgGaaptZ45oU1/EAAmmpiL/eumszcMmUVVFgdBwAAy3y2I1cVtU51ig3T0PT2VseBDxvvOXm/NJNiGAAAF2pfXrkOFFQo2G7TeM9MTmBa/xRJ0nyKYQhQFMMQ0JgXhosRE/b1rprPdtIqEQAQuN7feFSSdN2QVBmGYXEa+LKGuWEbDhWrvKbe4jQAAPimhZ5TYZd2i1NkaJDFaeAtLu+bLJshbcsuoVUiAhLFMAQ05oXhYtEqEQAQ6HJKqrVyX4Ek6brBaRanga/rHB+uznFhqnOa+tLz5woAADRPwz2KK/rRIhFfi48IaRwTM387p8MQeCiGIaAxLwwXa0qfJEnSxsPFyiurtjgNAABt76PN2TJN6ZLOseoUF2Z1HPiBcZ5Wicv25FucBAAA33O0uFLbsktkM6TJvZOsjgMvQ6tEBDKKYQhYJ88LG8G8MFyglOh2GpAWLdNk0DsAIPCYpqn3N3zdIhFoCeM8s02WZ+bLNE2L0wAA4Fs+85wKG9Y5VnERIRangbe5op+7VeLWoyU6UkSrRAQWimEIWHvzylVQXqPQIJsGd4qxOg582KRe7p1Wi3ZRDAMABJYdx0q1N69cwQ6bpg1IsToO/MTIjDgFO2zKPlGl/fnlVscBAMCnNMwLaxjrAJwsPiJEI7p4WiVyOgwBhmIYAtYqzwyC4Z1jFeJgXhgu3KTe7kHvK/cWqLrOaXEaAADaznueU2FT+yQpiuHsaCFhwQ6N6OLu3LAsk1aJAAA0VWF5jdZlubsgTe1Di0Sc2XTPJraPtxyzOAnQtiiGIWCt2ueeFza6a7zFSeDr+naIUkp0qKrqnPpyP4PeAQCBobbe1fgB+vohaRangb9pmBu2nLlhAAA02eJdeXKZ7vsUHWOZ5Yozm94/RUF2QzuOlSozp8zqOECboRiGgFTvdGntgYZiWJzFaeDrDMNoPB1Gq0QAQKBYvCtXRRW1SowM0djubC5CyxrvmRu29mCRqmo5eQ8AQFM0tEi8ghaJOIf24cGa2Mt9H+uDTUctTgO0HYphCEjbj5WqrKZeUaEO9UuNtjoO/MCk3u72A4t35TLoHQAQEN5Zf0SSdMPQNDnsfKxAy+qaEKHUmHaqrXdpjWcTGwAAOLvymnp9sdfdrebyfhTDcG7XDnZ3dvhoU7acLu5jITDwqRUBqWFe2MiMONlthsVp4A9GZcQpLNiu3NIabc8utToOAACt6nhJlVZ42tfdOKyjxWngjwzD0DjP6bBlmZy8BwDgfJZl5qnW6VKX+HB1T4ywOg683IReCYoJC1JuaQ0jPxAwKIYhIK3eT4tEtKzQIHtji6hFu3ItTgMAQOt6b/1RuUzpki6x6hIfbnUc+CnmhgEA0HQLd7jvRUztmyTDYOM3zi3EYddVAzpIkj7YmG1xGqBtUAxDwKmuc2pdVpEk6dJuzLdAy5nsaZVIMQwA4M9cLlPvbnC3SPwvToWhFV3aLV4Om6GswkplFVRYHQcAAK9VU+/U0t3uk9SXMy8MTXTdkFRJ0oLtOaqoqbc4DdD6KIYh4Gw8XKyaepcSI0PUjWPjaEETeiXKMKQdx0p1vKTK6jgAALSKNQcKdaSoSpEhDk3rn2J1HPixiBCHhnVuL4nTYQAAnMvaA0Uqr6lXYmSIBqXFWB0HPmJQxxh1iQ9XVZ1T87YdtzoO0OoohiHgnNwikWPjaEnxESEa3DFGkrR4F7MtAAD+6Z317lNhVw3qoHbBdovTwN+N75koiWIYAADnssRzKmxS70TZbNzrQtMYhqEbh6VJkt766rDFaYDWRzEMAWfVPvdQyNFdaZGIlje5D60SAQD+q6SyTp9uz5Ek3USLRLSBhrlhX+4vUHWd0+I0AAB4H9M0G+9BTOyVZHEa+JobhqbJYTO06fAJ7TpeanUcoFVRDENAKauu05ajJZKk0d3iLE4Df9QwN+zL/YWqrKXfMgDAv3y8JVu19S71TIrUwLRoq+MgAPRKjlRSVIiq61yNc38BAMDX9uaV62hxlUIcNo3pxsZvNE9iZKimeDZ2v83pMPg5imEIKOuyiuR0mUqPC1Na+zCr48APdU+MUMfYdqqtd+mLvQVWxwEAoEU1tEi8aXhH2k2jTRiG0Xg6bFkmrRIBAPimhlNho7vG0cIaF+TWEZ0kSR9sylZVLSfx4b8ohiGgNBQnRnflVBhah2EYjafDFu2kVSIAwH/sOFai7dmlCrIbunZwqtVxEECYGwYAwNk1zCyf1JsWibgwl3aNV8fYdiqrrte8bcetjgO0GophCCgrPB+gL+ueYHES+LOGYtiS3XlyukyL0wAA0DLeXec+FTa1T7Jiw4MtToNAcmm3eNlthvblletocaXVcQAA8BpFFbXaeLhYkjSpd6LFaeCrbDZDNw93nw57c+0hi9MArYdiGALG0eJK7c+vkN1maDQ9lNGKhneOVWSIQ4UVtdp85ITVcQAAuGjVdU59tPmYJOnGYWkWp0GgiW4XpMEdYyRxOgwAgJMt3Z0n05T6pEQpJbqd1XHgw24cliaHzdDGwye07WiJ1XGAVkExDAFjxR53i8RBHWMU3S7I4jTwZ8EOm8b1dJ8+XLyLVokAAN+3YHuOSqrqlBIdqrGcsIcFxnvWVsuZGwYAQKMlu90tEidzKgwXKTEyVDMGpEiS/vrFAYvTAK2DYhgCBi0S0ZYaWiU29O4GAMCXvbHG3S7llks6yW4zLE6DQDSuh/sm36p9Baqtd1mcBgAA69XWuxpPTE9kXhhawN1jMyRJ87YdV/aJKovTAC2PYhgCQr3TpVX73SfDLutBi0S0vvE9E2S3GcrMLdORImZbAAB8185jpdpwqFgOm6Gbh3e0Og4CVN8OUYqPCFZFrVMbDhVbHQcAAMt9dbBI5TX1SogM0YDUaKvjwA/0S43WqIw4OV2mZq06aHUcoMVRDENA2HzkhMqq6xUTFqQBaTFWx0EAiAkL1rD09pKkRbRKBAD4sH97hmhf3jdZiVGhFqdBoLLZjMYOD8v2cPIeAIDFu933Gib2TJSNk/toIfdc1kWS9PZXR1RWXWdxGqBlUQxDQGhokTimWzytfdBmaJUIAPB1pdV1+mhTtiTpWyPTLU6DQDeOuWEAAEiSTNNsvNcwkXlhaEHjeySqa0K4ymrq9c66I1bHAVoUxTAEhIYeypf1YF4Y2s4kz4J07cFCdtMAAHzShxuzVVnrVLfECI3MiLU6DgLc2O4JMgxpd06ZckqqrY4DAIBl9ueX63BRpYIdNo3pxjgQtBybzWicHfb3lQdVU++0OBHQciiGwe8VVdRqa3aJJDW2VgHaQkZChLrEh6vOaWrFngKr4wAA0CymaeqNNe4Wid8emS7D4HQ9rBUbHqyBnpbnDZ0fAAAIRIs8p8JGZcQpPMRhcRr4m+uGpCopKkTHS6r1wcZsq+MALYZiGPzeyn0FMk2pZ1KkkqOZc4G2NamX+3RYQy9vAAB8xdqDRdqXV66wYLuuHZJqdRxAkjTO0+lhOcUwAEAAW+yZTT6ZFoloBSEOu+69rKsk6c/L9qve6bI4EdAyKIbB761obJHIsXG0vUmeuWHLMvPldJkWpwEAoOkaToXNHJSqqNAgi9MAbg1zw77Ym8+NGQBAQCquqNWGQ8WSpAm9KIahddxySUfFhgfrcFGlPtl6zOo4QIugGAa/ZpqmvtjLvDBYZ1jn9ooKdaioolabDhdbHQcAgCbJK63Wwu05kqRvjexkcRrgawPTYhQTFqTS6nptPnLC6jgAALS5ZXvy5DKlXsmRSmsfZnUc+KmwYIe+O6aLJOlPS/fLxQZv+AGKYfBrO4+XKre0RqFBNg3vzNB3tL0gu03je7p3ajX09AYAwNu9ve6I6l2mhqa3V98O0VbHARrZbYbGeuYAL8ukVSIAIPAs9txbmOzpRAO0lm+PSldkqEP78sq1cEeO1XGAi0YxDH5tiWeBMKZbgkKD7BanQaCa5Onh3dDTGwAAb1bvdOmtrw5Lkr49Mt3iNMDpxjM3DAAQoOqcrsaffxOZF4ZWFhUapLtGd5Yk/e/SfTJNTofBt1EMg19bkukuhk2khzIsNL5Houw2Q3vzynW4sNLqOAAAnNPi3Xk6XlKt2PBgXdk/2eo4wGka2p9vyy5RflmNxWkAAGg76w4Wqay6XnHhwRqUFmN1HASAuy7torBgu3YcK9WS3XQ8gm+jGAa/VVBe0zhHgGIYrBQdFqRh6e0lSYt3czoMAODd/r3mkCTppmEdFeLgZD28T0JkiPqlRklS43xgAAACwWJPMWJCr0TZbIbFaRAI2ocHN3aL+OPivZwOg0+jGAa/tSwzX6Yp9e0QpeToUKvjIMA19PJezNwwAIAXO1hQoS/2FsgwpNtGdLI6DnBW42iVCAAIMKZpNo5fmEyLRLShey7LUGiQTVuOlmgZay/4MIph8FtLPCdwJnEqDF6gYW7Y2oOFKquuszgNAABn9h/PqbAJPRPVMTbM4jTA2Y3r4V5brdiTL6eLHcoAAP93oKBCWYWVCrbbNKZ7gtVxEEDiI0L0rRHu02F/WMTpMPguimHwS7X1Ln2xp0CSNNFzIgewUkZChDLiw1XnNLXC82cTAABvUlXr1OwNRyWpsRUK4K2GdIpRZKhDxZV12pZdYnUcAABaXcOpsBEZsYoIcVicBoHm3nEZCnHYtPnICX2xl/ta8E0Uw+CX1mcVqaymXvERwRqQGm11HEDS16fDGhawAAB4k0+2HlNJVZ06xrbTZT3YbQzv5rDbNKZbvCRpKcPcAQABYJFn7MJkNn3DAomRobqt4XQYs8PgoyiGwS81DBQd35OBovAekzwL1qWZebTzAQB4nX97WiTeNiJddtZP8AETPO3Ql2ZSDAMA+LcTlbXacKhYkjSRcSCwyH2e02EbDhVr1b5Cq+MAzUYxDH5piacYxrwweJOh6e0V5Wnns+lwsdVxAABotOXICW09WqJgu003Dk2zOg7QJBN6utf6W4+WKK+02uI0AAC0nuWeGZk9kyKZ6wrLJEaF6pZLOkmS/rB4D6fD4HMohsHvHMgv18GCCgXZDY3pHm91HKBRkN2m8Z6bNg3tDQAA8AYNp8KmD0hRXESIxWmApkmIDNHANHdL9GWZ+RanAQCg9TTcQ2gYvwBY5b5xXRVst2ldVrFWH+B0GHwLxTD4nYZTYSO6xCkyNMjiNMCpmBsGAPA2Jypr9fGWY5Kkb41MtzgN0DwTe7nbUC/ezdoKAOCf6pwuLc+kGAbvkBwdqpsv6ShJ+sOivRanAZqHYhj8zuc73R+EJ9AiEV5ofI9E2W2G9uaV63BhpdVxAADQexuOqqbepT4pURrSKcbqOECzNMxNWbm3QDX1TovTAADQ8tZnFau0ul6x4cEa1LG91XEAfX+8+3TY2oNFWsPpMPgQimHwK4XlNVqXVSRJurxvksVpgNNFhwVpeGf34nURp8MAABZzuUz9Z+1hSdK3R6XLMAyLEwHN07dDlBIjQ1RR69RXB4usjgMAQItb4jn9PL5nguw21mqwXkp0O9003D1n+E9L91mcBmg6imHwK4t25cplSv1So5TWnoGi8E6Te7sLtQ0tPQEAsMqq/QU6WFChyBCHZg7qYHUcoNlsNqPxdNhiZrICAPxQw8+3hnsJgDf43mVdZbcZ+mJvgXYeK7U6DtAkFMPgVxZsz5EkXdE32eIkwNk13LBZe7BQZdV1FqcBAASyN1YfkiRdPzRNYcEOi9MAF6ahPfqS3XkyTdPiNAAAtJz9+eU6UFChILuhsd3jrY4DNOoYG6Zp/VMkSX/74oDFaYCmoRgGv1FWXadV+9x9aq/oRzEM3isjIUIZ8eGqc5pasafA6jgAgAB1vKSqsWXvt0Z2sjgNcOHGdItXsN2mw0WV2p9fYXUcAABazKKd7rXayIw4RYYGWZwGONU9Y7tIkj7eckzHTlRZnAY4P4ph8BtLM/NV63Spa0K4uiVGWh0HOKdJvRva+TA3DABgjbe/OiKXKY3oEsvaCT4tPMShERmxkqSltKEGAPiRho1LU/rQIhHeZ0BajEZmxKreZWrWl1lWxwHOi2IY/MZCT4vEy2mRCB8wydPre2lmnpwu2vkAANpWvdOld9YdkSTdNjLd4jTAxZvUMDdsNxuNAAD+obC8RhsOFUv6+h4C4G3uvSxDkvTm2sMqZRQIvBzFMPiF6jqnlma6d4HSIhG+YFh6e0W3C1JxZZ02Hi62Og4AIMAs2Z2nnNJqxYUH6/K+3FyB75vYy/3neF1WsUoquREDAPB9SzPz5TKlvh2ilBrTzuo4wBmN75Go7okRKq+p19tfHbY6DnBOFMPgF1buLVBlrVMdokPVPzXa6jjAeTnsNo3vmSBJWryLdj4AgLb1pueD6g3D0hTisFucBrh4neLC1DMpUk6X2bhJDgAAX9YwL2wyp8LgxWw2Q/eMdZ8O+8fKLNXWuyxOBJwdxTD4hQU7PC0S+yXLMAyL0wBNM7EXc8MAAG3vSFGllu/JlyTdekkni9MALWeq55TjZztzLE4CAMDFqa5zasVe93qNeWHwdjMHd1B8RIhySqs1b9sxq+MAZ0UxDD6vzulqHCjKvDD4kvE9EmW3GdqbV67DhZVWxwEABIi3vjos05TGdo9Xely41XGAFjO1j/uzwLLMfFXXOS1OAwDAhVu9v1CVtU4lR4Wqb4coq+MA5xTisOuuSztLkv6y4qBM07Q2EHAWFMPg89YcKNSJyjrFhgdreOdYq+MATRYdFqThndtLUmNBFwCA1lRb79K7649Kkm4bwakw+Jd+qVFKiQ5VZa1Tq/YVWB0HAIAL9rnnHsHkPol0QIJP+NaIdIUF27XreKlWHyi0Og5wRhTD4PPmbjkuSbqiX7LsNhYI8C0Nvb8X76YYBgBofZ/vzFVBeY0SIkM0ifkT8DOGYWiqp5XUZztYWwEAfJPLZTaOU2BeGHxFdFiQrh2cKkn6z5rDFqcBzoxiGHxabb2rcV7YjAEpFqcBmq/hRuTaA0Uqra6zOA0AwN+9+dUhSdLNwzsqyM5HAfifqZ626Yt25crpokUPAMD3bD9WotzSGoUH2zWqa5zVcYAm+9bIdEnSwh05yi2ttjgNcDo+AcOnrdpXoJKqOiVEhmhEFxYI8D1d4sOVkRCuepepL/bQzgcA0HoOFlRo1b5C2Qzp5ktokQj/dEmXWEWFOlRYUauNh4utjgMAQLM1nG6+rEeCQhx2i9MATdc7JUrDO7dXvcvUW19xOgzeh2IYfNonW49Jkqb3T6FFInzWpF6JktTYBgEAgNbw9jr3B9LxPROVGtPO4jRA6wiy2xpP3n/m6SABAICvME1T87e7x4FM7UuLRPieb4/qLEl666vDqnO6rA0DfAPFMPis6jpn424ZWiTClzXcsFmamUc7HwBAq6hzuvT+hmxJ7haJgD9rnBu2M1emydoKAOA79uaV60B+hYJP2twB+JIr+iYrPiJYuaU1WrSTTd/wLhTD4LOW78lXeU29UqJDNaRTe6vjABdsWHp7RbcLUnFlHe18AACtYnlmvgrKaxQfEawJnhPJgL+6rEeCgh02HSqs1J7ccqvjAADQZPO3uU+Fje0er6jQIIvTAM0X7LDp5uHuluyvrz5kcRrgVBTD4LPmbnUvEKb3T5GNFonwYQ67TeN7JkhyD3sHAKClvbv+iCTp2sGpCrLzEQD+LTzEobHd4iW5B7gDAOArFmx3/9y6sj8dkOC7bh3RSTZDWn2gUPvyyqyOAzTikzB8UmVtfeNR2xkDO1icBrh4De0PFu/KszgJAMDfFJTXaMlu98+XG4fRIhGB4fK+yZK+3mEPAIC3259frt05ZXLYDE2hRSJ8WIeYdprs+TP8BqfD4EUohsEnLdmdp6o6pzrGttPAtGir4wAXbVyPBDlshvblletAPu18AAAt56NN2ap3mRrYMUY9kiKtjgO0ial9k+SwGdqdU6Z9eaytAADer+FU2Ohu8YoOo0UifNu3RqZLkj7clK3qOqfFaQA3imHwSXO3uHd4zhjQQYZBi0T4vuh2QRrtaefz6Xba+QAAWoZpmnpnnbtF4k3D0ixOA7SdmLBgjenuXltxOgwA4Asafl5N65dscRLg4l3aLV6pMe1UWl2vz3YyEgTegWIYfE5JVV1jq5+rBtAiEf6jYcE7bys3bAAALWPL0RLtzStXiMOmq2gtjQAz3TNvZe7WYxYnAQDg3A4XVmrHsVLZbYam9qUYBt9ntxm6fqh7M95sz/xiwGoUw+Bz5m87rlqnSz2TItU7hVY/8B9T+ybLbjO083ipsgoqrI4DAPAD73o+eE7rn6KoUNrtILBM7ZOsILuhPbnl2pPL8HYAgPf6dLt7U+zIjFjFhgdbnAZoGTd6imEr9xXoaHGlxWkAimHwQR9uzJYkXTsklRaJ8Cux4cEalREnSZq/ndNhAICLU13n1Ceb3SdiGj6IAoEkOixIY7snSOLkPQDAu833jEu4sl+KxUmAltMxNkyju8bJNKX3N2RbHQegGAbfcqSoUl9lFckwpJmDaPUD/zPN087n023MDQMAXJxFu3JVVlOv1Jh2GunZbAEEmhkD3GureduOyzRNi9MAAHC6I0WV2nLkhAxDmto3yeo4QIu6aVhHSdLsDUfkcrEWg7UohsGnzNns3kUwKiNOKdHtLE4DtLypfZNkM6Rt2SU6XMgRcgDAhWs4TX/N4A6y2ThNj8A0uU+Sgu027csrVyatEgEAXugTz2zLURlxSowMtTgN0LKu6JesyFCHjhZXac2BQqvjIMBRDIPPME1TH27ytEgcnGpxGqB1xEeENO7e/5RWiQCAC1RYXqPle/IlsW5CYIsKDdJlPWiVCADwXh972lrTAQn+KDTIrqsGuv9sN8wzBqxCMQw+Y1t2ifbnVyjEYdMV/ZKtjgO0mis9rRIbeoYDANBcc7ceV73LVP/UaHVLjLQ6DmCpxlaJW2mVCADwLpk5ZdqdU6Ygu6Er+jIvDP6poVXip9tzVFJVZ3EaBDKKYfAZH3ha/Uztm6zI0CCL0wCt5/K+STIMacuREzpaTKtEAEDzcZoe+NrkPkkKdth0oKBCO46VWh0HAIBGH29xr9nG90xUdBj3uuCfBqZFq0dShGrqXZrraQsKWIFiGHxCndOlT7a4/7K8djDHxuHfEiNDdUnnWEnSp9s4HQYAaJ6DBRXafOSE7DajsSUJEMgiQhya1CtR0teFYgAArGaapubQIhEBwDCMxtNh764/anEaBDKKYfAJK/cWqLCiVnHhwRrbPcHqOECrm+5p5/MJO2YAAM3UcLN/bPd4JUSGWJwG8A7XDUmTJM3ZfEz1TpfFaQAAkDYePqGjxVUKD7ZrUq8kq+MAreqawaly2AxtOXJCmTllVsdBgKIYBp/QcFPnqoEdFGTnjy3837T+KbLbDG09WqID+eVWxwEA+AjTNPURLRKB04zrkaD2YUEqKK/Ryn0FVscBAEAfb3av2S7vm6x2wXaL0wCtKz4iRBM8J/U/2MTpMFiDqgK8XnlNvT7b6W4V54s3ddasWaOZM2cqPj5eoaGh6tGjh55++mlVVjZ9FtTkyZNlGIYMw1BOzult86qrq/XDH/5Q8fHxCg8P19VXX61Dhw6d8VolJSVKTk7WLbfc0uzvJSsrS4ZhqHPnzud83Z133inDMDRr1qwzPt7wj81mU3R0tDp37qyrrrpKv/3tb5Wbm9vs6/qj+IgQjekWL0mNbRMAADifjYeLdbioUmHBdk3pww7jBqzHTn880NZjwQ6brva0DaVVIgDAarX1Ln3sGQdylZ+1SGTddfrjgbbuOpvrh7jv6360KVtOl2lxGgQiimHwevO3Hld1nUsZCeEakBZtdZxm+c9//qMxY8bo448/VufOnTVt2jRVV1fr+eef1+jRo1VWdv5jwbNmzdLixYtlGMZZX/PQQw/p1VdfVXp6usaOHau5c+dq2rRpcjqdp732v//7v1VRUaEXX3zxor63i3HppZfqjjvu0O23366pU6cqLS1Nixcv1hNPPKFOnTrpf/7nf2Sa/FC8xjMfb87mbH4/AABN8tEm902VK/olKyzYYXEa78B67MwCcT12radV4sIdOSqvqbc4DQAgkC3elaviyjolRYVorGcjrD9g3XVmgbjuOpMJvRIV3S5IuaU1+nI/J/XR9iiGwevN3nBEknTD0LRz/iD0NkePHtXdd98tp9Opf/zjH1q/fr0++OAD7d27VzfeeKO2bNmixx9//JzXyM/P12OPPaapU6eqU6dOZ3zN8ePH9Y9//ENXXnml1q9frwULFujZZ5/Vzp079eGHH57y2u3bt+vVV1/VM888o9RU607Z3X333Zo1a5ZmzZql2bNna+XKlSosLNQf//hHORwOPfnkk3rqqacsy+ctpvZJVrsgu7IKK7X1aInVcQAAXq7e6dL8bcclSTMH+d5p+tbAeuzsAnE9NjAtWhnx4aquc+lTz38rAABY4d317ntd1w9Jk8NPxoGw7jq7QFx3nUmIw66rBqZIkj7YyEl9tD3/+NsWfutAfrnWZRXLZrgXCL5k1qxZqq6u1pQpU3TXXXc1Ph4SEqI//elPCgsL09///ncVFhae9RoPP/ywKioq9Oqrr571Ndu3b1d9fb1uv/32xmLhd77zHUnS5s2bT3nt/fffr65du+qRRx65iO+sdbRr104PPPCA5s2bJ7vdrl//+tfasmWL1bEsFR7iaGxx9dFmFgkAgHNbc6BIhRW1ig0P1qVd46yO4xVYjzWPv6/HDMPQdZ72PNyAAQBYJaekWsv35EuSbhzW0eI0LYd1V/P4+7rrbK7z3N9dsJ2T+mh7FMPg1d7b4B6oOK5HgpKiQi1O0zwbNmyQJI0fP/605xISEtSnTx/V1dVp/vz5Z/z6hQsX6s0339RTTz2lrl27nvV9iouLJUnt27dvfKzh10VFRY2Pvfnmm1q+fLleeeUVBQUFNfv7aSvjx49v7OP8yiuvWJzGejM9vcM/2XKcfsoAgHOau/XrFon+ssP4YrEeuzD+vB67ZnCqDENafaBQR4qaPrsEAICW8v7Go3KZ0vDO7dUlPtzqOC2GddeF8ed115kM7hijLvHhqqpzasH20+fBAa2JT8nwWk6Xqfc3uothvrhTpqKiQtKpP5xPFhsbK0ln3PVRWVmp++67T7169TrvEfKGY+N79+5tfGzPnj2SpPT0dElSeXm5fvzjH+v666/XlClTmvmdtL2bb75ZkrR06VKLk1jvsh4Jah8WpILyGq3cRz9lAMCZ1da79Knnw+SMASkWp/EerMcunL+ux9Lah2mMZzZLQ4sqAADaimmamu35+eOL97rOhXXXhfPXddeZGIah6wa7T+p/uOmoxWkQaCiGwWut2Juv3NIaxYQFaVLvRKvjNFtCQoIk6dChQ2d8vuHxrKys05575plnlJWVpT//+c8KDg4+5/sMGjRIKSkp+v3vf6/t27crNzdXjz/+uAzD0JVXXilJ+uUvf6kTJ07o97///UV8R21n0KBBkqQDBw6otrbW2jAWC7LbdNVA9+mwhpOSAAB806p9BSqpqlNCZIhGdKFFYgPWYxfOn9djNw9330R7d/0R1TtdFqcBAASSdVnFyiqsVFiwXdP7+9cGJtZdF86f111nco2nGPbl/kIdO1FlcRoEEoph8FoNO2WuGZSqEIfd4jTNN27cOEnSW2+9ddoPsjVr1igzM1OSVFZWdspzGzdu1B/+8AfdcccdZzxa/k2hoaF64YUXlJWVpf79+ys5OVkLFy7UfffdpwEDBigzM1Mvv/yyfvrTn54yfLSqqkqmeWFt9w4dOiTDMM76z7/+9a8Lum6D+Pj4xl83HH8PZDcOde8WW7gjRyWVdRanAQB4o088LRKn9UuW3WZYnMZ7sB67cP68HpvcJ1Gx4cHKLa1pnNkCAEBbaDiVPGNAisJDHBanaVmsuy6cP6+7zqRjbJhGdImVaUofbWaOK9qOf/2tC79RUF6jz3fmSpJuHJZmcZoLc9ttt+n555/X4cOHNXPmTL344ovq1KmTVq1apXvuuUcOh0P19fWy2b6uSTudTt1zzz2KiYnRiy++2Kz3ysjI0OzZs1VdXa2JEyfq+uuvlyQ98MAD6tSpkx577DFJ0ttvv60nn3xShw4dUnR0tO6//3798pe/PCXH+YSHh+uGG2446/MrV67U/v37m3y9bzp5cdIwDDWQ9UuNUq/kSO3OKdPHW4/p2yPTrY4EAPAi1XVOfb7DvW6a4TlNDDfWY6zHziTEYdd1g1P1t5UH9fa6I5rUO8nqSACAAFBeU6/5245Lkm7ysxaJEusu1l3Nc/2QNK09WKQPNmbr++O6Bsz3DWtRDINXem/DUdU5TQ1Mi1bfDtFWx7kg4eHhmjt3rmbMmKEFCxZowYIFjc916tRJjz76qH7729+e0kv55Zdf1saNG/X3v//9lF0hTTFq1CiNGjXqlMfef/99ff7555o7d65CQkK0YcMG3Xrrrbr88sv1hz/8QcuXL9fzzz+vxMREPfjgg01+r/j4eM2aNeusz995550XtQgoKPh6NtbZek0HEsMwdOOwjnp27k7NXn+EYhgA4BQr9uSrrKZeyVGhGtqJn5snYz3Geuxsbr6ko/628qCW7M5TXmm1EqNCrY4EAPBzn2w5pspapzLiwzU03f9+trLuYt3VHFf2T9Yzc7ZrX165tmWXaEBajNWREAAohsHruFym3lx7WJJ02wjfvunfv39/7d69W7Nnz9b69etVX1+vgQMH6tZbb9Vzzz0nSerbt2/j6z/55JPG49Wvv/76KdfKycmRJF133XUKDg7Wc889pzFjxpz1vauqqvSjH/1IV111laZPny5J+t3vfqeIiAi9++67ioyM1MyZM7Vx40a98MILzVoEtLbNmzdLkrp3766goCBrw3iJawZ10K/n79LWoyXKzClTz+RIqyMBALzE3K3uHcbTB6TIRovE07AeuzD+vh7rlhipYenttf5QsWZvOKofTuhmdSQAgB8zTVOvr3bPzLr5ko5+ewqGddeF8fd115lEhgZpat9kfbLlmD7YmE0xDG2CYhi8zsp9BTpcVKnIUIdmDPT9YaLt2rXT7bffrttvv/2UxxctWiRJp/VDNk1TK1asOOv1Vq9eLenUXSNn8qtf/Uq5ubl6+eWXGx/bvXu3evXqpcjIrwspl1xyiZYvX67S0lJFRUU15VtqdW+//bYkacKECRYn8R5xESGa3DtJC3bkaPb6I3p6Rh+rIwEAvEBVrVOLdnlaJA7w/XVTa2E91nyBsB67+ZJOWn+oWG+uPazvXZYhh52R2gCA1rHhULF2HS9ViMPmly0ST8a6q/kCYd11JtcNSdUnW47p4y3H9NNpvRXsYC2G1sWfMHidhlNh1w9JU1iwf9Zrly9fro0bN6pv37669NJLGx9ftmyZTNM84z/p6e5TcsePH5dpmrrmmmvOev39+/frhRde0OOPP66MjIxTnqusrDzl/1dUVEjynp7Ey5Yt09tvvy3DMPTAAw9YHcerNMzP+3BTtmrrXRanAQB4g6WZeaqsdSqtfTsN6hhjdRyfwnrs7AJlPTZjQIrahwUp+0SVFu/OszoOAMCPNZwKu3pgB8WEBVucpu2x7jq7QFl3ncnYbvGKjwhRUUWtlu/JtzoOAgDFMHiV3NJqfe7Z3XzriE4Wp7l4mzdvVn19/SmPbdy4UbfeeqsMw9Arr7zSKu/70EMPKSUlRU8++eQpj/ft21c7d+7Upk2bJEllZWX65JNP1KlTp1N2yVihurpa//u//6vp06fL6XTqmWeeUb9+/SzN5G3G9UhQclSoCitqtWBHjtVxAABeYO7WY5LcLRK95QO9t2E91nSBth4LDbLr5kvcnzleX51lbRgAgN/KL6vRp9vdba1vH9XZ2jCtjHVX0wXauutMHP/P3n2HR1HubRz/7qb33mgJCYTeexeRYsOCBbGAAvbe9XjsvnrsvSKCBbuAgiii9N4h1BBIIIGEJKT33Z33j0AUAaUkmWRzf66Ta8nO7uy9c8zOs/N7iouVizs3AuCHdakmp5GGwDmH3Ui99fXqfdgdBj1jgomPqP9rIt19991s3bqVzp07ExoaSnJyMitXrsRqtfLBBx/UyPDn2bNnM3v2bKZPn46Xl9dR2x544AGmTZvG4MGDOfvss1m/fj379u3j/fffr/Yc/2TSpEksWLAAqOyhk56eztq1aykuLsbDw4MXX3yR+++/v1Yz1QeuLlZG92zK6/MS+Xx5CiM7NTI7koiImKiozMYfh0ezXNhR54QTUXvs+NQeq3RN72g+WJjE0l3Z7DpYQIvw+v8dRERE6pavVu2lwm7QuWkgHZoEmB2nRqnddXxqd53YpV2bMGnJHn7fdpC84goCvBvGmmliDhXDpM6wOwy+WlU5ReLVvev/qDCAa665hs8//5wNGzaQm5tLWFgYo0eP5oEHHqBz587V/nplZWXcddddDB8+/LjDxzt27MiMGTN47LHHmDVrFpGRkbzwwgvcdNNN1Z7lnyxdupSlS5disVjw9fUlODiYwYMHM2jQIMaOHUt4eHit5qlPrurZjLf+2MWq5ENsT8+ndWTdmN9aRERq3+/bD1Ja4SAmxJt2jXQ+OBG1x45P7bFKjQO9GNo2gl+3ZDB1WQrPXNywemSLiEjNstkdTDt8reu6PtEmp6l5ancdn9pdJ9a2kT+tI/3Ynl7AT5v2c01v5/87EfNYDMMwzA4hAvD7tgzGT11DsI87yx85Gw9XF7MjidRJt36xlp83p3NN72Y8e3EHs+OIiIhJbvpsDb9uyeD2wS24f3grs+OI1FvLdmUxZtJKvN1dWPHoEPw91SNZRESqxy8JB7j583UE+7iz7OGz8XTTtS6Rv/to0W6e+3kbXZsF8sOt/f79CSKnSWuGSZ0xZVkyAJd1a6JCmMg/ONJLZvq6NApKK0xOIyIiZigsszF/R+Ui0+d3jDI5jUj91icuhJbhvhSX2/lhrdarEBGR6vPp8hQAruzRVIUwkRO4qHMjrBZYtzeX3ZmFZscRJ6ZimNQJuw4WsDgxC6sFrtVwWJF/1Cc2hLgwH4rK7cxYn2Z2HBERMcG8rRmU2xzEhvnQOlJrHImcCYvFwnV9Y4DKi5YOhyZPERGRM7c9PZ9lSdlYLXB1L+dYDkSkJoT7ezIwPgyAH9bpOpfUHBXDpE74ZGkyAOe0iaBpsLe5YUTqOIvFUlU0/mxFCprtVkSk4Zm16QAAF3SIwmKxmJxGpP67tEtj/Dxc2Z1VxMLETLPjiIiIE/h48R4Azm0fRZMgXesS+SejujYBYPr6NHVMkhqjYpiYLq+4oqrqf32/5ianEakfLu3WBC83F3ZmFLJqzyGz44iISC3KL61g0c4jUyQ2MjmNiHPw8XDlyh5NAZi0eLfJaUREpL47WFDKzA37ARg/QNe6RP7N0LYR+Hm6kpZbwoo92WbHESelYpiY7qvVeympsNM60o/escFmxxGpF/w93bi4S2Pgz/X2RESkYZi3NYNyu4MW4b7ER/iaHUfEaVzfvzkuVgtLd2WzZX+e2XFERKQe+3x5CuV2B12bBdK1WZDZcUTqPE83Fy44vBby92s1VaLUDBXDxFQ2u6NqMdEb+jXXND8ip+D6fjEA/LolnX2His0NIyIitWb24SkSz9cUiSLVqnGgF+d1qLwIc2RqKxERkVNVWmHnsxWV17omDIg1OY1I/XFkqsQ5CQcoLreZnEackYphYqrftmaQlltCsI87Iztrmh+RUxEf4cfA+DAcBkxeqgs2IiINQV5JBYsOr2d0pOekiFSfiYensvpx434O5JWYnEZEROqjH9alkVNcQZMgL4a1jTA7jki90S06iOgQb4rL7fySkG52HHFCKoaJqT5ZmgzAmJ7N8HRzMTeMSD00oX/lBZtvVu8jr6TC5DQiIlLTftuaQYXdoFWEHy0j/MyOI+J0OjYJpGfzYGwOQ1NRi4jIKXM4DD5eUrn25PX9muPqokuvIifLYrFwaZfK0WHfr0s1OY04I30ii2k27stlVfIhXK0WrukdbXYckXppQMtQ4iN8KSq38/XqvWbHERGRGjZ7U+VC7OdrVJhIjZl4eEqraSv3UlimKXpEROTkLdyZSVJmEX4erlzRvYnZcUTqnUu7NgZgWVI2+3M1Sl+ql4phYpp3F+wCYGTnRkQGeJqcRqR+slgsTOhfecFmytJkKuwOkxOJiEhNyS0uZ3FiFkDVukYiUv2GtA4nNtSHglIb36zeZ3YcERGpRyYdHhU2umdT/DzdTE4jUv80DfamZ/NgDAOmr08zO444GRXDxBS7Dhbw65YMAG4ZFGdyGpH6bWTnRoT6urM/r5SfNx8wO46IiNSQuVsysDkMWkf60SLc1+w4Ik7LarUw/vDaYR8v2aPORiIiclK27s9n6a5sXKwWxvaNMTuOSL11WdfKUZU/rEvFMAyT04gzUTFMTPH+wsqeMsPaRmi9C5Ez5OnmwrW9Y4DKCzZqKIiIOKdZhzs8XKApEkVq3KiuTQj19SAtt4SZG/abHUdEROqBj5fsAeDc9pE0CfI2OY1I/XVuh0g83awkZRaxMTXP7DjiRFQMk1qXllvCjMPDXG8d3MLkNCLO4ZrezXB3tbIpNY/VyTlmxxERkWqWU1TO0l2aIlGktni6uTC+f+XosPcXJuFwqLORiIicWEZ+KT9urLzWNeHw2pMicnr8PN0Y3i4SgO/XppqcRpyJimFS6z5atBubw6BvXAidmwaaHUfEKYT4ejDq8CKjkxbvNjmNiIhUt1+3pGN3GLSN8ic2TFMkitSGa3o3w8/TlV0HC5m7NcPsOCIiUod9ujyZCrtB9+ggXesSqQajDk+V+NOm/ZTZ7CanEWehYpjUqoz8Ur5ctReAW8/SqDCR6nSk9/Jv2zLYdbDQ5DQiIlKdZh+eIvF8TZEoUmv8PN0Y2ycGgPcW7NJU1CIiclzF5Ta+WFl5rWvC4TUnReTM9GsRSoS/B7nFFczfftDsOOIkVAyTWvXO/F2U2Rx0jw6iX4sQs+OIOJUW4X6c0yYCw6iczkdERJxDdmEZy5KyAa0XJlLbru8Xg6eblY2peSzdlW12HBERqYO+X5dGbnEFzYK9Gdo20uw4Ik7BxWrh4i6VMyB9tzbN5DTiLFQMk1qTllvCV6v2AXDvsHgsFovJiUScz62D4wCYsT6N1Jxik9OIiEh1+OXwFIntG/sTHeJjdhyRBiXE14PRPZoB8O6CXSanERGRusbhMJi8ZA8AN/SLwcWqa10i1eXIVIkLdhwku7DM5DTiDFQMk1rz9h+JlNsd9IkNoW9cqNlxRJxS12ZB9I0LweYw+HCR1g4TEXEGMzfsB2Bkp0YmJxFpmCYOjMXVamFZUjbr9+aYHUdEROqQP7YfZE9WEX6erlzevanZcUScSnyEHx0aB2BzGPy4cb/ZccQJqBgmtWJvdjHfrkkF4L5h8SanEXFutw+uXI/vq9X7OFhQanIaERE5E/tzS1i15xAWC1yoYpiIKRoHelVN0/PuAk1FLSIif5q0pLIT6phezfDxcDU5jYjzGdW1sg32/bpUk5OIM1AxTGrFy3N3YHMYDIwPo3tMsNlxRJxan7gQOjcNpNzmYPKSZLPjiIjIGTjSA7JnTDBRAV4mpxFpuG4eFIfFAr9tzWBnRoHZcUREpA5ISMtjxe5DuFotjOsbY3YcEac0snNjXK0WEtLy2ZGuNpicGRXDpMat25vDjxv3Y7HAg8NbmR1HxOlZLJaq0WGfr0ghr7jC5EQiInK6jkyReFHnxiYnEWnYWoT7MqJdJADva3SYiIgAHx9eK+z8jlHqtCRSQ4J93BncOhyA79buMzmN1HcqhkmNMgyDZ2dtBeCyrk1o3zjA5EQiDcPZrcNpHelHYZmNqcuTzY4jIiKnYWdGAdsO5OPmYuHc9pFmxxFp8G49q7Kz0cyN+9mbXWxyGhERMVN6Xik/HR7BP75/c5PTiDi3Kw6vx/fDujTKbQ6T00h9pmKY1KhZmw6wbm8u3u4u3K9RYSK1xmq1cOvh0WGTl+6hqMxmciIRETlVPx4eFTYoPowgH3eT04hIhyYBDIwPw+4weHfBLrPjiIiIiaYuT8bmMOjZPJiOTQLNjiPi1Aa3CiPcz4PsonJ+35Zhdhypx1QMkxpTWmHnhTnbgco59iP8PU1OJNKwnN8hipgQb3KLK/hiZYrZcURE5BQYhsHMjWlA5Tz5IlI33DWksrPRd2tTSc3R6DARkYaoqMzGFysqv2NP0KgwkRrn6mLlsm5NAPhqtaZKlNOnYpjUmHfn7yItt4SoAE8mDog1O45Ig+NitVRN5/PBwt0Ul2t0mIhIfbF+Xy77DpXg7e7COW3CzY4jIod1iw6mX4sQbA6D97R2mIhIg/T9ulTyS23EhHgzpE2E2XFEGoQjUyUuSswkLbfE5DRSX6kYJjVi18FC3ltY+eXwiQvb4uXuYnIikYbpkq6NaRbsTXZROZ8t1+gwEZH6Yub6ylFhw9pG4O3uanIaEfmru4bEA/DNmn3s18UYEZEGxe4wmLxkDwA39G+Oi9ViciKRhiEm1Ic+sSEYBny7RqPD5PSoGCbVzjAM/jsjgQq7wdmtwxneTgu+i5jFzcXKHWcfHh22aLfWDhMRqQcq7A5mbToAwEVdNEWiSF3Ts3kwvWODqbAbfLBQo8NERBqS37dlkJxdTICXW9W0bSJSO0b3rBwd9u2aVOwOw+Q0Uh+pGCbVbuaG/SzfnY2nm5WnRrbDYlEvGREzXdKlMTEh3hwqKudTjQ4TEanzFu7IJLuonBAfd/q3CDU7jogcx51DWgLw5ep9ZOSXmpxGRERqy6TDo8LG9Gqm0fsitWx4u0gCvNxIyy1hya4ss+NIPaRimFSrrMIynpm1FYA7zm5J02BvkxOJiKuLlTvOrrxg8+GiJAo1OkxEpE77fl0qABd3aYybi5rrInVRn9gQesQEUW5z8L5Gh4mINAibUnNZtecQrlYLY/vEmB1HpMHxdHPhksMzZ3y9eq/JaaQ+0rdrqTZHpkfMLiqndaQfEwfEmh1JRA67qHMjmof6kFNcwdRlyWbHERGRE8gpKmfetgwATb0jUodZLJaqtcOmrdzLwQKNDhMRcXYfHx4VdmGnRkQGeJqcRqRhurJH5VSJv23NIKuwzOQ0Ut+oGCbVZtamA8xJSMfVauHlyzvh7qr/vETqClcXK3cOqVw77KPFuykorTA5kYiIHM+PG/dTYTdo18ifNlH+ZscRkX/Qr0UIXZsFUmZz8NGi3WbHERGRGrQ/t4TZh9d0Hd+/uclpRBquNlH+dGoSQIXdYPq6NLPjSD2jaoVUi8yCMh6fmQDAbYNb0L5xgMmJROTvRnZqTFyYD7nFFXy0eI/ZcURE5DiOTJE4qqtGhYnUdRaLpWrtsM9WpKh3soiIE5u6PBmbw6B3bLCueYmY7MoezQD4avVeDMMwOY3UJyqGyRlzOAwe+G4jOcUVtI3y57bBLcyOJCLH4WK1cP+wVgB8vHi3LtiIiNQxO9IL2JSah6vVwkWdG5kdR0ROwqD4MDo1CaC0wsFHizU6TETEGRWV2Zi2snJ9ogn9tSSIiNku7BSFl5sLSZlFrE3JMTuO1CMqhskZ+2DRbhbsyMTD1cqrV2p6RJG6bET7SDo2CaCo3M4783eZHUdERP7iyKiws1uHE+LrYXIaETkZFouFu845PDpseQqHispNTiQiItXty1V7KSi10TzUh7Nbh5sdR6TB8/N044KOUQB8tXqfyWmkPlHVQs7ImuRDvDx3BwBPjWxH60itbSFSl1ksFh4c3hqAL1bsJTWn2OREIiICUGaz893aymLYZd00RaJIfTK4VTjtG/tTXG7n4yUaHSYi4kzKbPaqkb83DozFarWYnEhEAEb3bArArE37ySuuMDmN1Bcqhslpyykq544v12N3GFzUuRFX9mhqdiQROQn9W4bSNy6EcruD1+clmh1HRESAX7dkcKionEh/T/U4FqlnLBYLd55dOTps6rIUcos1OkxExFlMX5dGRn4ZEf4eXNq1sdlxROSwrs2CaB3pR2mFg2/XanSYnBwVw+S0OBwG9327kQN5pcSG+vDcJR2wWNQ7RqS+eGB45dphP6xLJTGjwOQ0IiIybWUKAFf2aIqri5roIvXN0LYRtInyp7DMxoeLNDpMRMQZ2B0GHxz+TJ84IBYPVxeTE4nIERaLhWv7RAPw2YoUHA7D5ERSH+ibtpyWSUt288f2g7i7Wnl7TFd8PVzNjiQip6BLsyCGt4vAYcD/ftlhdhwRkQZt18FCVuw+hNXy53QfIlK/WCwW7h0aD8AnS5PJLCgzOZGIiJypOQkH2JNVRKC3G1f1bGZ2HBH5m4s7N8bPw5WU7GIWJWaaHUfqARXD5JStTcnhxcMXz5+4sC1tG2mdMJH66IHhrXCxWpi3LYNlu7LMjiMi0mB9uWovAGe3DicqwMvkNCJyus5pE06npoGUVNh5d8Eus+OIiMgZMAyDd+cnATC2Tww+6gQuUuf4eLgy6vB6y58tTzE5jdQHKobJKcktLufOL9djcxhc0DGKMeoZI1JvtQj345pelX/DT8/ail1DykVEal1phZ3v16UCMKaX2lUi9ZnFYuH+YZWjw75YsZf9uSUmJxIRkdO1cGcmWw/k4+3uwri+MWbHEZETODJV4h87DrLvULHJaaSuUzFMTpphGNz/7SbSckuICfHm+Uu1TphIfXf3OfH4e7qyPb2Ab9dowVERkdo2a9MBcosraBzoxaD4cLPjiMgZ6t8ilF7Ngym3O3jrD40OExGpj/46Kuyqns0I8nE3OZGInEhcmC/9W4RiGPD5So0Ok3+mYpictI+X7GHetgzcXSrXCfPzdDM7koicoSAfd+46p7IH88tzd1BQWmFyIhGRhsMwDD5esgeAq3s3w8WqTkYi9Z3FYuH+4a0A+HbNPlKyi0xOJCIip2rprmxWJR/C3cXKhAHNzY4jIv/iusOjw75ZvY/SCrvJaaQuUzFMTsr6vTm8MGc7AP+9oA3tGweYnEhEqsu1vaNpHupDVmE57y5IMjuOiEiDsXx3NtsO5OPl5qKpp0WcSI+YYAbFh2FzGLwxL9HsOCIicgoMw+DV33YAlVNYaz1XkbpvSJsIGgd6kVNcwU8b95sdR+owFcPkX+UVV3D7tMp1ws7rEMk1vaPNjiQi1cjd1cqj57UB4OPFe9ibrTmWRURqw+TDo8Iu69aEQG9NvyPiTO4fVjk6bPqGNBIzCkxOIyIiJ2vBzkzW7c3Fw9XKrWfFmR1HRE6Ci9VSdb364yV7MAzD5ERSV6kYJv/IMAwe+r5ynbBmwd68MKqj1gkTcULntAmnf4tQyu0O/jszQQ0HEZEatjuzkHnbDgJwfb8Yc8OISLXr0CSA4e0iMAx4Ze5Os+OIiMhJMAyD136r/My+rk804f6eJicSkZM1pmczvN1d2J5ewKLELLPjSB2lYpj8o2mr9vLLlnTcXCy8PaYL/lonTMQpWSwWnrqoHe4uVhbuzGROQrrZkUREnNonS5MBGNI6nNgwX3PDiEiNuG9YK6wW+GVLOmtTDpkdR0RE/sVvWzPYlJqHt7sLNw3SqDCR+iTA243RPSqnnv9wkZYAkeNTMUxOaEd6AU//tBWAB4e3pmOTQHMDiUiNigvz5ebD00A89dMWCkorTE4kIuKcsgvL+G5tKgDjtSi7iNOKj/Djiu5NAfi/n7dr5L2ISB1WbnPwwpztAIztG0Oor4fJiUTkVN3QPwYXq4Wlu7JJSMszO47UQSqGyXGVVti548t1lNkcDIwPY3x/XagRaQhuPSuOmBBvMvLLNKWPiEgNmbRkDyUVdjo0DqBPbIjZcUSkBt0zNB4vNxfWpuTw6xaNvBcRqas+XZ7M7qwiQn3duUVrhYnUS02CvDm/QxQAHy3ebXIaqYtUDJPjembWVnZmFBLq68Erl3fCatU6YSINgaebC89c3B6o/DKwOVU9aUREqlNucTmfLksG4I6zW2gtVhEnF+HvycTDI0D/98sOKuwOkxOJiMjfZReW8cbviQDcP6yVlggRqcduHBgLwKxNB0jLLTE5jdQ1KobJMX5JOMAXK/cC8OoVnQjz09BwkYZkQMswRnZqhMOAR6Zv0kUbEZFqNHlpMkXldlpH+jG0bYTZcUSkFtw4KI5QX3f2ZBUx7fD3LBERqTte+W0nBaU22jXy5/LD09uKSP3UvnEAfeNCsDsMJi/ZY3YcqWNUDJOjpOWW8OB3mwC4aWAsA+PDTE4kImZ47II2BHi5kZCWz3sLtPCoiEh1yC+t4JOllV/I7ji7pUaFiTQQvh6u3H1OPABv/J6odVlFROqQzal5fLWqsqPCExe2w0UzI4nUe0dGh321ai+5xeUmp5G6RMUwqWJ3GNzz1QbyS210ahLAfcNamR1JREwS7ufJ0xe1A+DN3xPZsl/TJYqInKlPlyVTUGqjZbgv57aPNDuOiNSi0T2aEhvmw6Gict5fqI5GIiJ1QbnNwQPfbcRhwMhOjejZPNjsSCJSDQbFh9Emyp+icjsfa3SY/IWKYVJl0uLdrEo+hI+7C29e1QV3V/3nIdKQjezUiBHtIrE5DO77ZiPlNk2XKCJyunKKyvlgUeUizref3ULrsYo0MK4uVh4e0RqASYv3sF9rWIiImO69BUlsTy8g2MedJy5sa3YcEakmFouFu4a0BOCTpckaHSZVVO0QALYdyOeVuTsBePzCtkSH+JicSETMZrFYePaS9gT7uLM9vYA3Dy8oLCIip+7t+bsoKLXRJsqfCzs2MjuOiJhgaNsIejUPpszm4LnZ28yOIyLSoG1Pz+ft+ZXfcZ8c2Y4QXw+TE4lIdRrWNoI2Uf4Ultk0OkyqqBgmlNns3PP1BsrtDs5pE84VWixURA4L9fXg2YvbA/DewiQ27Ms1N5CISD2071Axny5PBuCRc1trVJhIA2WxWHhyZOV6NLM3H2BJYpbZkUREGqQym537v91Ihd1gaNsILuwYZXYkEalmVqtGh8mxVAwTXp+XWDUs/PlLO2oxdxE5ynkdoriwUyPsDoO7v1pPYZnN7EgiIvXKy3N3UGE36N8ilIHxYWbHERETtYny59re0QA8/mOCpqEWETHBs7O2kZCWT6C3G89e3F7XwUSc1F9Hh01arNFhomJYg7cm+RAfHF7A+f8uaU+Yn4aFi8ixnr2oPY0CPEnOLubJH7eYHUdEpN7YnJrHzA37AXj43NYmpxGRuuCeofGE+rqzO7OIyUt1YUZEpDbNWJ/GZytSAHjtys5E+HuanEhEaspfR4dNXrqHgwWlJicSs6kY1oAVldm479uNOAy4tGtjRrTXsHAROb4AbzdeH90FqwW+W5vKjxv3mx1JRKTOczgM/jszAYBLujSmfeMAkxOJSF0Q4OXGw+e2AeDN3xM5kFdiciIRkYZh3d4cHvx+EwC3D27B4FbhJicSkZo2vF0EnZoGUlxu583fE82OIyZTMawBe+7nbaRkF9MowJMnR7YzO46I1HE9mwdz2+AWAPxn+mb2HSo2OZGISN329Zp9bNiXi6+Hq0aFichRLu3SmG7RQRSX23lu9jaz44iIOL19h4q58dO1lNscnNMmnHuGxpsdSURqgcVi4ZHD38W+XLWP3ZmFJicSM6kY1kDN33GQaSv3AvDy5Z3w93QzOZGI1Ad3DmlJl2aBFJTauPvrDVTYtc6FiMjxZBeW8cKc7QDcOzReU/CIyFGsVgtPX9QOqwVmbTrAsqQssyOJiDit9LxSrvl4JVmFZbSJ8ueN0V1wsWqdMJGGondsCINbhWF3GLw8d4fZccREKoY1QDlF5Tz4XeWw8Ov7xdC3RajJiUSkvnBzsfLGlV3w83BlbUoOL/2qRoSIyPH875ft5JVU0CbKn+v6RJsdR0TqoHaNArimd+Xnw2MzEiitsJucSETE+WQWlHH1pBWkZBfTNNiLyeO64+PhanYsEallD53bGosFft6czrq9OWbHEZOoGNbAGIbBYzMTyCwoIy7Mh4dGaMoeETk1zUK8eenyjgB8uGg3vySkm5xIRKRuWbori2/WpALw7MXtcXVRk1tEju++Ya0I8/Ngd2YRb/+xy+w4IiJOJbOgjGs/XklSZhGNAjyZNqE3UQFeZscSERO0jvRnVNcmADz101YcDsPkRGIGfTNvYGZsSGP2pgO4WC28dmVnPN1czI4kIvXQiPZRTOjfHIAHvt3InqwikxOJiNQN+aUVVSPwr+0dTbfoIJMTiUhdFuDlxjMXVa7f/P7CJLYdyDc5kYiIc9ibXcxl7y9je3oB4X4eTJvYm6bB3mbHEhETPTi8FT7uLmzcl8t361LNjiMmUDGsAUnLLeHxGVsAuGtISzo2CTQ3kIjUaw+d25ru0UEUlNm45fO1mtpHRAR4dtZW0nJLiA7x5uFzNQJfRP7diPZRDG8Xgc1h8PD3m7Crp7KIyBnZdiCfUe8vq5oa8Zub+hAT6mN2LBExWbi/J3ed0xKAF3/ZTn5phcmJpLapGNZAOBwG932zgYIyG12aBXLrWXFmRxKRes7NxcrbY7oS6uvO9vQC/jsjwexIIiKm+n1bBt+sScVigZcv76T1KETkpD19UXv8PF3ZmJrHJ0v3mB1HRKTeWrgzk8vfX05mQRmtI/34/ua+KoSJSJVxfZsTG+ZDVmE5r/+WaHYcqWUqhjUQk5bsZsXuQ3i7u/D6lZ21doWIVIvIAE/eHN0FqwW+XZvKl6v2mh1JRMQU6XmlPHB4esSJA2LpERNsciIRqU8i/D159Lw2ALw8dwcp2ZqCWkTkVH22IoUbpqymsMxGz+bBfH1jH8L9Pc2OJSJ1iLurlScvrJyieuryZLbszzM5kdQmVUQagG0H8nn5150APH5BW6JD1CNGRKpP3xah3DesFQBPzNzC2pQckxOJiNSuCruDO75cx6GictpG+XPv0HizI4lIPXRl96b0jg2mtMLBvd9s1HSJIiInye4weOqnLfx3RgJ2h8Gork34fHwvArzdzI4mInXQwPgwzusQid1h8ND3m7DZHWZHklqiYpiTK62wc/dXGyi3OzinTQRX9mhqdiQRcUK3nhXHiHaRlNsd3PL5WjLyS82OJCJSa17+dQerk3Pw83DlvWu64unmYnYkEamHrFYLL13WCV8PV9am5PD+wiSzI4mI1HlFZTZu/HQNnyxNBuCB4a14+fKOuLvqkqeInNiTI9vh7+lKQlo+Hy/RFNUNhc4Mx1FaWsoTTzxBfHw8np6eNGrUiBtuuIHU1NTT2l9ubi5333030dHReHh4EB0dzV133UVubu4Jn7Nt2zauvvpqoqKi8PDwICYmhjvuuIOsrKzjPn7RokVMnDiRrl27EhERgbu7O8HBwbTp2oe1f/xIqK87L4zqgMViOa33ICINU0pKCm+99RbnnXcesbGxeHh4EBoayogRI/jxxx+rHmexWHj5ik7ER/hysKCMmz9fS5nNfsz+zjrrLCwWyz/+WK06NYlI9arOtl1MTMwxn1uPnt+WlP9dQMLTIyjJ3Pev+ygvL6dt27ZYLBY8PTV1j4j8yVGQSfOk70n/4iHuuqg3Hp6e+Pr60rVrV5577jmKi4tPaX/bt2/nf//7H0OGDKFZs2Z4eHgQGRnJpZdeyuLFi2voXYiInLri4mJmzJjB+PHj6dixI/7+/vj4+NCpUyeefvppCgsLj3lOTlE5V09aye/bD+LhauXdq7ty2+AWR137mjNnDkOHDiUwMBBvb286dOjASy+9hM1mq823JyJ1SHJyMhH+Xmx+agQp/7uAm89qcdT3u8jIyFPa34IFC/7xOlfv3r1r6J3IqbIYhqG5F/6itLSUIUOGsGzZMqKiohgwYADJycmsWrWKsLAwli9fTlxc3EnvLzs7mz59+pCYmEhsbCzdu3dny5YtbNmyhRYtWrBixQpCQkKOes4ff/zBhRdeSHFxMW3atKFNmzZs3ryZxMREmjZtyvLly2ncuPFRz7n//vt55ZVXiI+Pp3nz5gQFBZGQuIeEdavBcDB05GXMnflttRwjEWk4+vfvz9KlS/Hy8qJXr15ERkaSlJTE6tWrAbjnnnt49dVXqx6fnFXEyLeXkF9qY3SPpjx/6dFF+BdeeIHt27cf97XWrl1LQkICAwcOZOHChTX7xkSkwajutl1MTAwpKSmMHTuWvJIK5m8/iM1h0DLcl05NA3n++eeJior6x308+eSTPP300xiGgYeHB6WlGk0rIpVmzZrFhRdeiHdACPaARgQGh9Ex3JVVK1eSl5dHhw4dWLRoEYGBgSe1vyZNmpCWloa/vz+9evUiKCiIrVu3kpCQgMVi4dVXX+Xuu++u0fckInIyJk2axMSJEwFo164dbdu2JT8/n2XLllFQUEDr1q1ZuHAh4eHhAOzPLeG6yavYdbCQQG83Jo/rQddmQUft83//+x8PP/wwVquVXr16ERYWxooVKzh48CDDhg1j9uzZuLq61vp7FRFzJScn07x5cyIiIvCJ7UZGQRmhvh4Mig/DYoGAgADeeOONk97fggULGDx4MHFxcfTv3/+Y7XFxcfz3v/+tzrcgp8uQo/z3v/81AKNPnz5GQUFB1f2vvPKKARgDBw48pf1de+21BmBceumlRkVFRdX9d9xxhwEY11133VGPLyoqMiIiIgzAeOKJJ6rut9vtxt13320AxogRI455nS1bthhpaWlVv6fmFBsdn/zVaHTjh4ZfcLgBGHPmzDml7CIiV111lfH+++8bhYWFR90/a9Ysw9XV1QCMX3/99aht87dnGDEPzzKiH5plfLY8+aRfq2fPngZgfPTRR9WSXUTEMKq/bRcdHW0ARlZBqdH3+d+N6IdmGWM+Wm5U2Own9fytW7ca7u7uxo033mgAhoeHxym9vog4t/379xsJCQlGdmGZ0e2Z34zoh2YZT/6YYOTl5RlDhgwxAOOhhx466f0NHTrUmDZtmlFWVnbU/e+//74BGC4uLsaWLVuq+22IiJyyqVOnGrfccouxc+fOo+7fv3+/0aVLFwMwrrrqKsMwDCMxo8Do83/zjOiHZhm9/2+ekZiRf8z+Vq1aZVgsFsPNze2o76y5ubnGwIEDDcB44YUXavZNiUidtGfPHgMwBg0aZOzNLjLa/neOEf3QLOOd+Ymntb/58+cbgDF27NjqDSrVTiPD/qKiooLw8HByc3NZt24dXbp0OWp7p06d2LRpE2vWrKFbt27/ur/09HQaN26Mi4sL+/btIyIiompbWVkZTZs25dChQ6SlpVVt+/zzz7n22mtp1aoVW7duPWq6sLKyMuLi4khLS2Pjxo107Njx+O/D7mD0hytYm5JDp6aBdDs0nyce/y8PPPAAL7744ukcGhGRY9x00018+OGHjBs3jk8++eSobe8u2MWLv+zA1Wrh0xt60rdF6D/uKzExkfj4eDw8PMjIyCAgIKAmo4tIA1HdbTv4c2TY5e8tY1XyIWJCvJlxWz8Cvd3/9bmGYTBw4EB27tzJ9u3bCQ4O1sgwETmh+dsPcv2UytH4k8d1xyN7F/3796dHjx6sWrXqjPc/fPhw5s6dy5NPPskTTzxxxvsTEakpy5cvp2/fvnh4eLB0614mfrGRQ0XlxIb58Nn4XjQO9DrmORMmTODjjz9m4sSJfPjhh0dt27JlC+3btycsLIwDBw7g4qL1XkUakiMjwwYNGsSCBQv4Zs0+HvxuE65WCz/c2peOTQJPaX9HRoaNHTuWKVOm1EhmqR5amOUvlixZQm5uLnFxccdcLAG47LLLAPjpp59Oan9z5szB4XAwcODAowphAB4eHlx44YXY7XbmzJlTdf/atWsBGDhw4DHr5nh4eNCnTx8AZs6cecLXfW72Ntam5ODn6crbV3XB3a1yyLe7+79fpBEROVmdOnUCYP/+/cdsu2VQHCM7NcLmMLj587XsOnjs/O5/9fnnnwMwcuRIFcJEpNpUd9vur1YlH8LPw5VJY7ufVCEM4IMPPmDJkiW88sorBAUF/fsTRKRBG9w6nHF9YwC475uN5JRUrm9TXd/r/qktJyJSlxz5vCorK+Oqt+ZxqKicjk0C+PamPscthMGf19fOOuusY7a1a9eO0NBQMjMzWbZsWY3lFpH64fJuTTivQyQ2h8HdX22guFxrCjorFcP+YuPGjQB07dr1uNuP3H/kcTWxv6KiIoATXiAJDg7+xwzT16cyZVkyAK9c3gmKsvnggw8AGDFixEnlFhE5Gbt37wY47sKiFouFFy/rSNdmgeSX2hg/dTWHispPuK8vvvgCgGuuuaZmwopIg1TdbTuAvJIKAApX/0Dczi9567nH+PDDD8nMzPzH5x04cICHH36Ys88+W591InLSHjmvNe0b+5OdV8CN9/4HgHPPPbda9v1PbTkRkbrkyOcVVlfKXLzp1yKEaRN7E+LrccLnnOn1NRFxfhkZGTzxxBPcdNNNuKz+Are9q0jKyOWZWdtOa3+JiYk88sgj3HjjjTz66KP8/PPPOByOak4tZ0KrRP7F3r17gcpFho/nyP1HHlcT+wsLCwMgJSXluM85cn9ycvIx27bsz+PuN78he83PtI7w4X+rC1myZAk2m41nn332uAv4iYicjtzcXD799FMALrroouM+xtPNhQ+v687F7ywlJbuYmz5bw+cTeuHhevQUFMuXLycpKYmQkJBqu7gjIgLV37abtHg3BaWVvQSz/5jMX8fp33PPPbz55puMHz/+uM+9/fbbKS0t5b333jvJ9CLSkOXk5HDPPfcAUJSWzv6ly7GX5NOuzxDuvffeM95/UlISs2bNAipH5ouI1GV3/Oc5ALxiu3J+l6a8dmXnY75X/l1YWBiJiYnHvb7mcDjYt28fcPzrayLSMGzfvp2nn376qPtc/MOYkvEwA1uGcm6HqFPa37Jly44ZbdqhQwe+//57WrZsecZ55cxpZNhfFBZWTuPl7e193O0+Pj5HPa4m9jdo0CAAZs+eTVZW1lGP37t3L/PnzwegoKDgqG0HC0q58dO1FGXtpyjhd9b+/iN//PEHNpuNp556ivvvv/+kMouInIxbbrmFzMxMevfuzSWXXHLCx4X6evDJuB74ebiyOjmHR77fzN+Xqvzss88AGD16NG5ubjWaW0Qalups2/24cT/Pzt6Gd8te3PTMu6SkpFBcXExCQgL33nsvZWVlTJgwgRkzZhzz3JkzZ/LDDz/w8MMPEx8ff/pvSEQajKKiIqZOncrUqVNZMO9X7CX5eLfqR37361mXVnRG+7bZbIwbN46ysjKuvPLKk14zUUSkthmGwS3Pf8SCH78GqytX3fIAb13V9V8LYfDn9bWpU6ces+3rr7+mpKQEOPb6mog4Pw8PD2655RYWLFhARkYGeXl5LF++nPPOOw97fiYHv3mcuybNJSnz5GoAAQEBPPDAA6xYsYLs7Gyys7P5/fff6d27N5s3b2bo0KHk5eXV8LuSk6Fi2F8cuUBrsVj+cXtN7m/o0KF0796dwsJCzj33XFavXk1hYSFLly7lvPPOqxpa+df1xIrLbUyYuoa03BI6DLqA3KJyysrK2LFjB4888gjPPPMMgwYNIicn55Tyi4gczwsvvMBXX31FcHAwX3zxxQk/445oGeHHu9d0xcVq4Yf1abw2L7FqW0VFBd988w0A1157bY3mFpGGp7radst2ZXH/N5VT6Nz7+PO895+badasGV5eXrRr145XXnmFd999F4CHHnroqOcWFBRw++2307JlSx555JHTfSsi0sA0adIEwzBwOBzs3buXjz/+GEvGDtIm384NL39Nak7xae/7jjvuYMmSJcTGxlZ9domI1DUOh8Ed7/3Eh0/fCxhcdOODTLpnFC7Wf/7+ecRtt91GQEAAK1asYNy4cezatYvc3Fy+/vprbrvtNlxdKyfL+uv1NRFpGKKionj33XcZNGgQ4eHh+Pv707t3b2bPns3oq67CUVbEgYVfcsvna09q/bAuXbrw4osv0qtXL4KDgwkODubss89myZIlDBgwgJSUFN55551aeGfyb/SJ/xd+fn7An/MK/11xceUXDl9f3xrbn8Vi4YcffqBDhw6sWbOGnj174ufnR//+/UlPT+fxxx8H/pzz2O4wuPPLDWxKzSPI241PxvUgwNsNd3d34uPjefbZZ3nhhRdYuXJl1XNFRE7X1KlTefTRR/Hx8WH27NnExsae1PMGtAzjmYvaA/Dm74l8tqJyqoo5c+aQnZ1Ny5Yt6dWrV43lFpGGqTraduv25jDh0zWU2x2c3yGKxy9oe9zi2oQJEwgPD2fnzp3s2bOn6v5HH32U1NRU3nvvPTw8TryuhYjI8VgsFpo2bcoNN9zAr3NmYZQUsOeHl7nx0zWUlNtPeX9PP/0077//PhEREfz6669Va+aIiNQlFXYHN74/l/cfmYCjtJBhV45nxnvP/WtHzL9q3Lgx06dPJzg4mKlTp9KyZUuCgoIYPXp01ecqnHhNMRFpmB77T+UareXJ69mZUchDx5nh6GS5uLhUdZb89ddfqy2jnD4Vw/6iWbNmAKSmph53+5H7jzyupvbXtGlT1q1bx3fffcc999zDTTfdxGuvvca2bdsIDQ0FoF27dgA8O3sr87Zl4O5qZdLY7sSE+hzzOkcWaZ85c+Yx20RETtbMmTMZP348bm5u/PDDD/Tu3fuUnj+mVzPuGlI5R/LjMxP4efMBPv/8c+DPzykRkep0pm27rfvzGTd5FcXldvq3COWVKzphPUFvZKvVSlxcHAAHDhyouv+nn37C09OTZ555hrPOOuuoH4Dy8vKq33ft2nVa71NEGoZ+vXvRMj6eisxkNm5L5JEfNp3SxZl33nmHJ554goCAAH755RdatGhRg2lFRE5PSbmd696Zx9T/TsCen8nZI6/gly8/Oq19DR48mKSkJN5//31uvfVWbr/9dj777DNWrVpFbm4u8Of1NRERoGptL0dxDq5WCz9t3M+7C5LOeH9//Y4o5nE1O0Bd0qlTJwDWrVt33O1H7u/YsWON78/V1ZVRo0YxatSoo+6fN28eAGeddRYfLEzik6XJALx6RSe6RR+/V19wcDBWq5XMzMyTyi0i8ncLFizgyiuvBOCLL75g2LBhp7Wfu89pSWZhGdNW7uWOqctI/fEnQMUwEakZZ9IWS8os5LrJK8kvtdEtOogPr+uGp9s/r09xZErqv480Ky0tZeHChcd9jmEYVdtOdl1aEWm4IsPD2Ll9G5TkMWPDfjo0CWR8/+b/+rwvvviCO+64A29vb2bPnk3nzp1rPqyIyCnKK67g2g8W8OuLt2M7lMqAoecz94dppzQi7O8CAwO56aabjrrPZrOxcOFCrFYrAwcOPNPYIuJEjnyn8/P15cmR7XhsRgIv/bqD5qE+nNch6rT3d7IzzUnN0siwv+jXrx8BAQEkJSWxfv36Y7Z/9913AFxwwQUntb8RI0ZgtVpZvHgxBw8ePGpbWVkZP/30E1arlXPPPfek9peYmMisWbMICQmhKKorz8/ZDsAj57bmgo6NTvi8xYsX43A4qnori4icirVr1zJy5EjKy8uZNGkSl1122Wnvy2Kx8MxF7RnRLpK8rYsoLyulc/deJz3doojIqTjdtt2+Q8VcM2klWYXltGvkz+RxPfB2/+c+ZFu2bGHHjh14e3vTunXrqvuTk5MxDOO4P1C5ePOR33VxWkT+SX5+PuvXr8disfDAZQMAeG72VhbsOPiPz/v5558ZN24cbm5uTJ8+nX79+tVGXBGRU5KRX8pl7yxk7uv3U56eSO+BZzNv1g+4uPxzZ6TT8cUXX5CRkcGIESNo2rRpte9fROqv77//HoBu3bpxTe9oru8XA8C932xg477cM9qfmE/FsL9wd3fn9ttvB+D2228/an2JV199lU2bNtG/f3969Ohx1PPefvttWrdufcyi6FFRUVx11VWUl5dz6623YrP9ueDegw8+SGZmJmPGjCEyMvKo523ZsoXS0tKj7ktKSuKSSy6hvLycy297lP+buxuAO85uwU2D4njyySdJT08/5j2tWbOGiRMnAnD99def6iERkQZux44dnHvuuRQUFPDGG28wbty4k3rekCFDaN26NatWrTpmm4vVwuujO+OyeykAByN6nlaDQkTk35xO2+5gfimDb3iYNS+Pg9XT+PSGngR4uQGV87yvXbv2mNfZtGkTl19+OYZhMGHCBNzd3Wv2jYmI03r33XfZtGnTMfenpaUxZswYCgoKOP/887nrgu5c3q0JDgNun7aePgMGHbfttXTp0qqOTF9//fVpj+4XEalJiRkFXPL2YpZOepyyvZvo1qsvv8/56aTaVCe6JgeVHTv/Pp3sb7/9xh133IGnpyevvvpqtb0HEak/Pv300+NOpf/DDz/w8MMPA3DrrbcC8Nj5bRncKozSCgcDzhpMi/hWx7S3PvjgA7Kzs4+6zzAMPvjgA1577TUsFgs333xzDb0bORWaJvFvHnvsMebNm8eyZcto2bIlAwYMICUlhZUrVxISEsInn3xyzHOysrLYsWPHcef+fP3111mxYgXff/89rVu3pnv37mzZsoWEhATi4uJ47bXXjnnOSy+9xIwZM+jatSuRkZEcOHCApUuXUlFRwUXX38mcslYATBzQnHuHxgPw1FNP8X//93907dqVmJgYysvL2bNnDxs2bADgiiuu4K677qrGIyUiDcHo0aPJzMwkLCyMtWvXHrcY1rp166rGwhFJSUmkpKRQXFx83P1mH0wnK3E9Vlc3rC36ce3HK5k2sTftGwfUxNsQkQbsVNp2h4rKuebjlWRlZWE7lEqvCCshvh5V25cvX85TTz1FdHQ0cXFxhIWFsWfPHtatW4fNZmPQoEE8//zzZrxNEXES33zzDbfddhtt27aldevWuLm5sW/fPtauXUtZWRnt2rXjww8/xGKx8NwlHdiXU8yK3YfYlbCDstyMY9peF1xwASUlJTRv3pwZM2YwY8aMY16zf//+TJgwoZbeoYjI0VbtOcSEqatJXfI9JTuXA9CsUUTVhei/e/nllwkNDa36/Z+uyY0aNQq73U6HDh0ICAhgx44drF+/Hi8vL7777jtatWpVM29KROq0yZMnc/3119O6dWtiYmLw9PRk69atbN9eOQvbAw88wCWXXAJUduh+86ouXPbecn7P2k9S/kEOZOcetb/nn3+eO+64g7Zt2xIdHQ3A5s2b2bNnD1arlTfeeEMjw+oIFcP+xtPTk/nz5/P8888zbdo0ZsyYQVBQEGPHjuWZZ5455eHToaGhrF69mieeeIIZM2Ywffp0IiIiuP3223nqqacIDj52na+LL76Y9PR0Nm7cyJIlSwgKCuK8884j9qzL+SE9EIBxfWN49Lw2VfMmv/XWW8yfP58NGzaQkJBARUUFYWFhXHTRRYwbN46LL774TA+NiDRAR+Y2zszMZOrUqcd9zKBBg44phv2bL774AofDwYUXjsS9VVPWpORw9aSVfDGhlwpiIlKtTrZtl1NUznWTV7IzoxAfD1fyAC/3o6flGT58OPv27WP16tVs3LiRvLw8/P396d+/P1dffTXXX399jUzlIyINxwMPPEBcXBwrVqxg/vz5FBQUEBAQQO/evRk1ahQTJ07E09MTAHdXK+9f041L311GqqNy5ENhme2o/eXm5gKwZ88e9uzZc8LXVTFMRMzw8+YD3P31BsptDiI8bOQcvn/69OknfM6TTz55VDHsn9x8883MmDGDlStXUlhYSFRUFDfeeCMPPfSQpuoXacAmTpxIWFgYGzZsYMmSJZSUlBAWFsall17KLbfcwjnnnHPU4/083fh4XHfinrZgB56bvY1Bg84i0Lty9Op9993H3Llz2bJlC7///jsVFRVERUVxzTXXcOeddx4zy5yYx2L8fbyw1DkOh8Erv+3gnflJANx6VhwPDG91RguIiojUFQWlFVw3eRXr9+bi5+HKh9d1p09ciNmxRKQBySos45pJK9meXkCIjztf39SbFuF+ZscSETkpKdlFjHpvOVmFZXRtFshn43vh46F+ryJSdxmGweSlyTw7eyuGAcPaRvDG6C7HdEQSEalLdmcWcuWHK8gsKKND4wC+mNgLf083s2PJKVAxrI4rrbBz37cbmb2pcrj3A8NbcdvgFianEhGpXvmlFUycuoaVew7h7mrlzdFdGNE+8t+fKCJyhg7mlzJm0kp2HSwkzM+DaRN60TJChTARqV+2Hchn9IcryCupoF+LED4e2wNPN11UFpG6p7TCzuMzE/hmTeV6Pdf2jubJke1wsarDt4jUfYkZBVz54QoOFZXTtVkgU27oqYJYPaJiWB2WWVDGxE/XsGFfLq5WC89d0p4rezQzO5aISI0orbBz55frmbs1A6sFnrukA1f11GeeiNScA3kljPloJXuyiogK8GTaxN40D/UxO5aIyGlZvzeHayatpKjczjltInjvmq64uVjNjiUiUuVAXgk3f76OjftysVrgoRGtuXFgrGY+EpF6Zev+fK76qLITUvvG/ky9vudRa01L3aViWB2VkJbHTZ+tJS23hAAvN96/ppumDRMRp2ezO/jP9AS+XrMPgBsHxvLQiNbqJSgi1W5vdjHXfLySvYeKaRzoxVc39qZpsLfZsUREzsjypGzGfbKKMpuDc9qE8/aYrhohJiJ1word2dw+bR1ZheUEeLnx1lVdGBgfZnYsEZHTkpCWx9jJq8guKic2zIfPxveicaCX2bHkX6gYVscYhsEXK/fy9E9bKbc7aB7qw8djuxMb5mt2NBGRWmEYBq/+tpO3/tgFwICWobx9VVcCvDXsXESqx/q9OUyYuobsonKiQ7yZNrG3vriIiNNYuDOTGz9dQ5nNQf8WoXx4XTe83bWGmIiYw2Z38Obvibw9fxcOA1pH+vHhtd1pFqJOSCJSv+3OLOSaSSvZn1dKowBPPpvQizhdw6/TVAyrQ3KLy3lsRgKzDq8Pdk6bcF6+vBOB3u4mJxMRqX2zNu3ngW83UVJhp0mQF2+M7kK36CCzY4lIPffrlnTu+mo9pRUO2jf2Z/LYHoT7e5odS0SkWi1Pymb81NUUl9vpFh3ER9d1J9hH3ytFpHal5hRz11cbWJuSA8Cork145uJ2KtCLiNPYn1vCtR+vJCmziAAvN94Z05X+LUPNjiUnoGJYHfHrlnT+Mz2BrMIyXKwWHhrRiokDNG+yiDRsW/ZXThmbmlOCi9XCXUNactvgFpo2UUROmWEYTF6azLOzt2IYMLhVGG+P6YqPhy7GiIhzWrc3h3GTV5FfaiM6xJtPxvXQjCMiUisMw+DbNak8M3srBaU2/DxcefaS9lzUubHZ0UREql12YRkTPl3D+r2V6yH+5/y23NAvRtf16yAVw0yWXVjGkz9t5aeN+wGIC/Ph5cs70aWZRj+IiADkl1bw+IwEZmyo/Jzs2CSA5y/tQLtGASYnE5H6orjcxiM/bGbm4c+RMb2a8fTIdri6WE1OJiJSsxIzCrh+ympScyrXon736q70a6HeyiJSc/ZmF/Po9M0s2ZUFQOemgbw5uoumRRQRp1ZaYeexGQl8tzYVgPM7RvF/F3fQkh91jIphJqmwO/h8RQqv/baT/FIbVgvcNCiOu4a01ALHIiLHMX19Ko/P3EJBqQ0Xq4Xx/Ztz+9kt8PdUw0JETiwxo4Dbpq1jZ0YhLlYLj5zbmvH9m6uXnog0GJkFZUz8dA0b9uViscCdZ7fkziEtNdJeRKqV3WHwydI9vDJ3JyUVdjxcrdw7NJ7x/ZurA5KINAiGYfDxkj28MGc7NodBVIAnr17RmT5xIWZHk8NUDKtlDofB3K3pvDJ3J4kHCwFoG+XP85d2oFPTQHPDiYjUcQfzS3lq1lZmH15bMdDbjVsGxTG2b4w6EojIUWx2Bx8s2s0b8xIptzsI9/Pgnau70iMm2OxoIiK1rrTCzhMzt/D1mn0A9I4N5pUrOtM40MvkZCLiDFYnH+Kpn7aQkJYPVH7GvHBpR2JCfUxOJiJS+zbuy+XurzewJ6sIiwVuHBjLPefE67pVHaBiWC1xOAx+3ZLOG78nsj29AIBgH3fuH9aKK3s0Va88EZFT8Mf2DP7v5+3sOtypINTXnat7RXN172aE+3manE5EzLY25RBP/riVzWl5QOX6YP+7rKM+H0SkwZuxPo1Hp2+muNyOj7sLD5/bmqt7RWPV91EROQ37c0t4fs72qqU//DxdefS8Nozu0VSj8EWkQSsqs/HMrK18tbqyI1KzYG+eubg9g+LDTE7WsKkYVsOKy21MX5/GlKXJVSPB/Dxcub5fDOMHxBLgpem9REROh91h8MO6VF6fl0habgkA7i5WhrQJ56LOjRncOgwPV/W6EWlIdh0s4KVfd/DrlgwA/D1deeLCdlzatbEuyIiIHLYnq4gHvt3ImpQcALpHB/HYBW3prJlKROQkFZbZmLR4N+8vTKK0woHFAqN7NOW+Ya0I9fUwO56ISJ0xd0s6j8/cQnp+KQDD20XwwPDWtAj3NTlZw6RiWA1Jyizk69X7+GrVXvJLbcDhIlj/5ozv11yL54mIVBOb3cGvWzKYvHQPaw9f1IHKz9y+LUIY0DKM3rEhxIb6qNeziBMyDINFiVl8snQPC3ZkAmC1wJU9mnLP0HiNBhMROQ6Hw+DT5cm8+OsOisvtAFzQMYp7h8YTG6aLMyJyfIVlNqYuS+ajxbvJLa4AoEdMEE9c2I72jQNMTiciUjcVltl4de5Opizbg8Oo/L56Rfem3H52C5oEeZsdr0FRMawa5RaX89PG/Xy/Lo0N+3Kr7o8O8WZsnxgu794EP08VwUREasqW/XnM3LCfHzfsr+p1c4SPuwvtGgXQvnEAceE+xIT4EB3iTVSAl6aqFamH9h0qZvbmA3y3NrVqylSLBYa2ieCB4a1oGeFnckIRkbpvf24Jr/62k+/XpWIYlZ+j57aP5JZBLejQRBe2RaRSYZmNT5cn89Gi3eQcLoI1D/Xh3qHxXNAxSiPwRUROws6MAl78ZQfztlXOZOJqtXBxl8bcclYcceqMVCtUDDtDecUV/L49gzkJ6SzYcZAKe+XhdLFaGNgylKt7RTO4dXi9utCamZlpdgQRqSVhYc45V7HdYZCQlsfixEwWJWaxKTWX0grHcR/r7mKlSZAXjYO8aBLkTZMgr8M/3jQN8iLU10MjykTqAMMw2HaggEWJmczZfICNqXlV23w9XLmsWxPG9Y1x6oXa1UYTqf/qattr24F8Xpm7g3nbDlbd16lJAJd3b8qFnRppen+RBiojv5QvVu7ls+XJRxXB7hzSggs7NsLVxWpywpqn9pdI/VNX21tHrEk+xGvzdrJ0V3bVfX3jQhjTqxnD2kbi7ur8n61mUTHsNBwsKOW3rRn8kpDO8qRsbI4/D2HbKH8u7dqYkZ0b1dtpedSjR6ThaCinAJvdQVJmEZvT8ti6P5+U7CKSs4vYd6iEcvvxi2RHuLtaaRJ4pFjmRfNQH1pG+BEf4UejAE99ZorUEMMwSM0pYdWeQyxOzGTJrmyyCsuqtlst0Ds2hPM7RjGyU6MGMfpenzci9V9db3vtSC/g/YVJ/LRxf9X3XA9XK0PbRnBu+yjOahWGj4erySlFpCYZhsGalBymLkvml4T0qs+ChlYEO0LtL5H6p663t45YvzeHdxckMW9bBkcih/i4c2GnRlzQMYquzYLUObuaqRh2Emx2Bxv25bJwZyYLdmSyOS3vqO2tIvwY3j6S8zpE0jrS36SU1UcnepGGo6GfAuwOg/25JaTmlJCaU3z49s9/H8grwfEPh8jXw5UW4b60ivAjPtKP+IjKf4f5eeizVOQUldscbNmfx9qUHNbtzWFtSg4Z+WVHPcbb3YXesSEMbhXGiPZRhPk1rAXa9bkiUv/Vl7ZXVmEZM9an8c2afezMKKy6393VysCWYQxqFUa/uBCah/ros0nESezOLGTGhv3MWJ/G3kPFVff3iAlibN8YRrSLbFBFsCP0GSdS/9SX9tYRqTnFfLN6H1+v2XfUd+BIf09GtI9kUKswejUPxttdHZLOlIphx2EYBrsOFrIq+RDLkrJZvDOT/FLbUY/p1DSQEe0iGd4uwukWGNaJXqTh0Cngn1XYHaTnlVYVyPbllJB0sJCdGQXsySo6amTwXwV6uxEf4fdnkSzcl1aRfgR6u9fyOxCpm46M+kpIy2Njah7rUnLYmJpLme3okZquVgvtGgfQv0UIA1qG0bVZUIOeMkJtNJH6r761vQzDYFNqHj8nHOCXhHRSsouP2h4V4EmfuBB6x4bQpWkgcWG+6sEsUk/YHQYb9uXyx/YM/tieybYD+VXbvN1duKBjFNf1iaF944a9fqDaXyL1T31rbx1hsztYuDOT2ZsO8NvWDArK/qxHuLtY6RYdRJ+4ELpHB9GpaaBG658GFcOonPZw+4ECth7IZ01yDmtTDlXNhXxEgJcbA1qGclarcAa2DCXcv35OgXgydKIXaTh0Cjh95TYHydlF7MwoYGdGITvTC9iZUUBydtEJR5OF+3nQPNSHxoFeNDr80zjIi0h/TwK83AjwcsPTzarPYXEqDodBcnYRCfvz2ZKWR8L+PBLS8skrqTjmsUHebnSLDqJrdBDdo4Pp2CQATzcXE1LXTfpsEKn/6nPbyzAMdmQU8NuWDJYmZbEuJfeY6ab9PFzp2DSAzk0D6dQkkNaR/jQJ8lKBTKQOODIKf01yDquTD7E6+ehrXy5WCwNbhnJxl8YMbRuhEQiHqf0lUv/U5/bWEWU2O4t2ZvH7tgwWJ2aRllty1HarBdpE+dOlWWV7q1WkH/HhfgR4O//yAWeiQRTDHA6DQ8XlHMgt5UBeCQfyStl3qJjt6QVsT88nq7D8mOd4ulnp0jSIns2DGRgfRuemgbg0kAa8FgcVaTjq+qKi9VFphZ2kzMrRYzvSj9wWHNNwORE3Fwv+nm74e7nh4WrFzcXKuL4xjOrWpIaTi5wZwzA4VFROUmZR1d/AlrR8tuzPo6jcfszj3VwstIr0o32jALpGB9EtOohYTbf1j9RGE6n/nKntVVJuZ03KIZbuymZdSg6b0/IoqTj2897TzUqLcF9ahvvRItyXmBAfmgZ70STImyBvN33ui9SAwjIbO9Lz2XaggG0H8tmeXsCW/XmUVvytgO3pyqD4MIa0CWdQfDjBPprJ4u/U/hKpf5ypvQWV37X3ZBWxZFcWq5NzWJeSc8JrTBH+HsRH+BEd4k3jQG+aBFV2wm4S6EWor0eD76BkajEsr6SCP7ZXLhDnMMBhGHD41mGAQeWt3e7A5jAotzuw2Q0q7A4q7AY2u6Py3w6DClvlvwvL7OSXVlBQaqOgtIL8kgoKy2z/uOaLxQLNQ3xoE+VPxyYB9GgeTPtGAQ16Gh4REalehWU2EjMK2HuomP25paTlHr7NKSGjoJSCUhv2E5ys/nNeGyYOjK3lxCLHcjgMMgvLjlpjb292MUmZhezKLCS3+NjRXgAerlbaNvKnfaMA2jf2p12jAOIj/NTWEhFxIja7gx0ZBWzYl8uGvblsTstjd1YR5X+bAvevfNxdaBToRbCPO8E+7gT5uBPs7U6gtxve7q54ulnxdHOpvHV1wcPNBTeXyos4Fg7f/u2ajmGA3TCwO/78cRgGNoeB4/DvtsP3/fUxnZtVTvMoUl8cWf94T1ZR1c/urCJ2ZxaSmnP8i6SB3m50jw6mR0wQ3WOC6NgkELcGuA6YiEh9dyCvhHUpuWxKza2asejfOmG7WC0EebsT7ON2+Lay7RXo5VbV3vJwdcHDtbL95e5qxQIYVLavDIzDt3+OvqtsT1VeK3AYBnbjz/bWkXqP3fHn/UPbRtIq0q/Gj8+JmFoM25lRwLDXFtXKa1ksEObrQVSAJ1EBXkQFetIqwo82Uf7ER/jh5a4peERExDyGYVBUbie/pIL80gryS2yUH+7oERvmQ3SIj9kRpZ5yOAxKKuzYqi4AOipv7ZW/l9rsFJXZKCi1UVhmo/DwbX5JBZmF5WQVllX9ZOSVHTMl1t81CfIiLsyXFuG+tI3yp33jAOLCfBrkgusiIg2d3WGw91AxiRkFJB4sZNfBQvYeKmbfoWIOFpT9+w5q0TMXt+fa3tFmxxABKqfHyi2u4FBROZkFZRzIKyEtt5T9uSV/+Sn9x3ZZpL8nraMqr3u1jvSjXSN/YkO1rp+IiLMqKK0g8WAhiRkF7DtUQlpuCak5xaTllJCeX/qPg4Vqy6tXdOLSrubNfGTqBMDe7i4MaBkKgNViwWqpvLVYKufktVoqe3u5uFhwd7HiarXg6mLF3aXy1rXqfiturhbcrFZ8PFzx93LFz9MNf8/Dt16uBHq5q/exiIjUWRaLBV8PV3w9XGmEl9lxxIms35fLqPeWVdv+XKwWIv09q6ZaaBLsTVyYDy3CfYkN9VUHIxERqeJitdA81IfmoT4Ma3f0ttIKO2m5JRzILSWnuJyc4nIOFZWTU1ROTnEFxeV2ymx2SivslFY4Km9tdhyOP3sjH+mpXPnvyt7KVosFF+ufP1YLuFqtWK0WXKzgYrXiYuHwNguuLpW3UU68LrjUvD1ZRXy5ai/GkZmOjsx+ROWt8ZfZjwyjsrNSqc1OSbmdkorK/85LKuzklVSQU1Q5w9HJcHe1EhPiffjvzJfmod7EhPgQH+FHkKY8FBFpUPw83ejaLIiuzYKO2VZhd5BdeLitVXz0bW5xBWU2O2UVDspsjsp/2xyUVTgwMCpH41f+r7Juw5H6zZGajqWqXWU90sayWnA5Uu85/G8Xq8X0jt4NYs0wERERkYZq475cLnpn6VH3ublUNkTdrFbcXa34elYWYn08XPE7cuvpSqivB6F+HoT5uhPq60FkgCeR/p4a5SUiIiLyF0t3ZXH1pJXVuk+rhaopRBsFetE40Ouo20aBlTMfNZT17UVERM6UimEiIiIiTszuMCiz2XG1Vo6y19Q4IiIiItUrOauIL1amYK3sMl/VO95C5S1/+91qteDhasXL3QUvt8ofTzcX/L1cCfJ2J8THAz9PV7XbREREqpGKYSIiIiIiIiIiIiIiIuK0NMeNiIiIiIiIiIiIiIiIOC0Vw0RERERERERERERERMRpqRgmIiIiIiIiIiIiIiIiTkvFMBEREREREREREREREXFaKoaJiIiIiIiIiIiIiIiI01IxTERERERERERERERERJyWimEiIiIiIiIiIiIiIiLitFQMExEREREREREREREREaelYpiIiIiIiIiIiIiIiIg4LRXDRERERERERERERERExGmpGCYiIiIiIiIiIiIiIiJOS8UwERERERERERERERERcVoqhomIiIiIiIiIiIiIiIjTUjFMREREREREREREREREnJaKYSIiIiIiIiIiIiIiIuK0XE/mQYZhUF5eXtNZREREpJa5u7tjsVjMjiGovSUiIuKs1N6qO9TeEhERcU4n0946qWJYeXk5L7zwQrWEEhERkbrj4YcfxsPDw+wYgtpbIiIizkrtrbpD7S0RERHndDLtLYthGMa/7ai6es6kp6czZcoUxo0bR2Rk5BnvT06Njr95dOzNpeNvLh1/85zMsVdP5bpDPZVrhj6DapeOd+3Rsa49Ota1yxmPt9pbdUdDam85499SXabjXbt0vGuXjnft0vE+PdU2MsxisVRLLyZ3d/eqW/WKqn06/ubRsTeXjr+5dPzNo2Nfv1RXe0uOpr+D2qXjXXt0rGuPjnXt0vGWmtSQ2lv6W6pdOt61S8e7dul41y4d75pjNTuAiIiIiIiIiIiIiIiISE2p1WKYr68vgwYNwtfXtzZfVg7T8TePjr25dPzNpeNvHh17Ef0d1DYd79qjY117dKxrl463SPXQ31Lt0vGuXTretUvHu3bpeNeck1ozTERERERERERERERERKQ+0jSJIiIiIiIiIiIiIiIi4rRUDBMRERERERERERERERGnpWKYiIiIiIiIiIiIiIiIOC0Vw0RERERERERERERERMRpqRgmIiIiIiIiIiIiIiIiTsvUYtiiRYu4//77GTx4MAEBAVgsFsaNG2dmJKe0evVqzjvvPIKCgvDx8aFnz55MmzbN7FhO7/PPP+emm26ie/fueHh4YLFYmDJlitmxGoS0tDRef/11hg0bRrNmzXB3dycyMpJRo0axcuVKs+M5vdzcXO6880769OlDZGQkHh4eNG7cmLPPPpvvv/8ewzDMjtigvPjii1gsFiwWCytWrDA7jkitUfun9qjNUzvUvqldas+YS+0XkVOn80Tt0nnCfDpX1KyYmJiq4/v3n5tvvtnseE5r+vTpDB06lJCQELy8vGjevDlXXXUV+/btMzuaU3A188UnT57M1KlT8fb2plmzZuTn55sZxyktWLCA4cOH4+7uzujRowkICOCHH37g6quvJjk5mUcffdTsiE7rscceIyUlhdDQUKKiokhJSTE7UoPx1ltv8b///Y+4uDiGDh1KeHg4iYmJzJgxgxkzZvDll19yxRVXmB3TaWVlZTF58mR69+7NxRdfTHBwMAcPHuSnn37isssuY+LEiXz44Ydmx2wQtm3bxuOPP46Pjw9FRUVmxxGpNWr/1C61eWqH2je1S+0Z86j9InJ6dJ6oXTpPmEvnitoREBDA3Xfffcz93bt3r/0wTs4wDG6++WY+/PBD4uLiGD16NH5+fuzfv5+FCxeSkpJC06ZNzY5Z71kME7sqrFmzBi8vL1q3bs3q1avp06cPY8eOVU/SamKz2WjdujWpqaksX76cLl26AFBQUECfPn3YsWMHW7dupWXLliYndU7z5s2jZcuWREdH88ILL/DII4/wySefaPRjLfjhhx8ICwtjwIABR92/ePFihgwZUnUy8fDwMCmhc7Pb7RiGgavr0f0tCgoK6N27N1u3biUhIYF27dqZlLBhsNvt9OnTB4vFQnx8PJ9//jnLly+nd+/eZkcTqVFq/9Q+tXlqh9o3tUvtGXOo/SJy+nSeqF06T5hH54raERMTA0BycrKpORqKN998k7vuuovbbruNN954AxcXl6O222y2Yz5v5NSZOk1i9+7dadeu3TH/50r1+OOPP0hKSmLMmDFVF4IA/Pz8+O9//4vNZuOTTz4xMaFzO+ecc4iOjjY7RoN06aWXHvMFAGDAgAEMHjyYQ4cOsXnzZhOSNQwuLi7HPUH7+fkxfPhwAHbt2lXbsRqc//3vf2zcuJHJkyfrPCsNito/tU9tntqh9k3tUnvGHGq/iJw+nSdql84T5tG5QpxNSUkJTz31FLGxsbz++uvH/e9ahbDqoaPoxBYsWADAsGHDjtl25L6FCxfWZiQR07m5uQE6iZihtLSUP/74A4vFQtu2bc2O49QSEhJ46qmneOyxx9QTURoctX+kIVL7pvaoPVNz1H4RqTk6T9QenSdqls4VtausrIypU6eSlpZGUFAQffv2pVOnTmbHcjq//fYbhw4dYty4cdjtdn788Ud27txJYGAg55xzDi1atDA7otPQWdCJJSYmAhx3GqCgoCBCQ0OrHiPSEOzdu5d58+YRGRlJhw4dzI7j9HJzc3n99ddxOBwcPHiQn3/+mX379vHEE09oerIaZLPZGDduHG3atOHhhx82O45IrVP7RxoatW9qltoztUPtF5Gao/NEzdJ5ovboXFH70tPTj5n6fMSIEXz22WeEhoaaE8oJrVmzBqjssNCpUyd27NhRtc1qtXLPPffw8ssvmxXPqagY5sTy8vKAysUOj8ff35/U1NTajCRimoqKCq699lrKysp48cUXNZS+FuTm5vLUU09V/e7m5sZLL73EfffdZ2Iq5/d///d/bNy4kZUrV1b1ABVpSNT+kYZE7Zuap/ZM7VD7RaRm6DxR83SeqD06V9SuG264gUGDBtGuXTs8PDzYunUrTz31FHPmzGHkyJEsXboUi8VidkyncPDgQQBeeeUVunbtyqpVq2jTpg3r16/nxhtv5JVXXiEuLo5bbrnF5KT13xmvGRYaGorFYjnpnyNT14iI1BaHw8ENN9zAokWLmDhxItdee63ZkRqEmJgYDMPAZrOxZ88enn76af7zn/8watQobDab2fGc0saNG3n22We5//776dq1q9lxRESkBql9UzvUnql5ar+I1AydJ2qHzhO1Q+eK2vf4448zaNAgQkND8fPzo1evXsyaNYv+/fuzfPlyfv75Z7MjOg2HwwGAu7s7M2bMoEePHvj6+jJgwAC+++47rFYrr7zyiskpncMZjwy76qqrKCgoOOnHR0ZGnulLykk60iP6SA/pv8vPzz9hr2kRZ2EYBhMnTuTzzz/nmmuu4f333zc7UoPj4uJCTEwMDz/8MC4uLjz44IN89NFH6tFSA8aOHUtcXBxPPvmk2VFETKP2jzQEat/UPrVnao7aLyLVT+eJ2qfzRM3SuaJusFqtXH/99SxZsoSlS5dy/vnnmx3JKRz5ftq9e3caNWp01LZ27doRGxvLrl27yM3NJTAw0ISEzuOMi2FvvfVWdeSQGnBkbuLExES6det21LacnByysrLo27evGdFEaoXD4WDChAl88sknXHXVVUyZMgWr9YwHxMoZGDZsGA8++CALFizQl4IasHHjRgA8PT2Pu71Pnz4ATJ8+nYsvvri2YonUKrV/xNmpfWM+tWeql9ovItVL5wnz6TxR/XSuqDuOrBVWXFxschLn0apVK4ATFrqO3F9SUqJi2BnSmmFObNCgQTz//PPMnTuX0aNHH7Vt7ty5VY8RcUZ//QJw5ZVX8tlnn2l+9Dpg//79QOWioFL9xo8ff9z7Fy1aRGJiIiNHjiQsLIyYmJjaDSZSi9T+EWem9k3doPZM9VL7RaT66DxRN+g8Uf10rqg7Vq5cCaBjXY0GDx4MwLZt247ZVlFRwa5du/Dx8SEsLKy2ozkdfSo7sSFDhhAbG8u0adO488476dy5MwAFBQU888wzuLq6Mm7cOFMzitQEh8PB+PHjmTJlCpdffjmff/65vgDUog0bNtC8efNjpiE7dOgQjz76KADnnnuuGdGc3qRJk457/7hx40hMTOSRRx6hd+/etZxKpHap/SPOSu2b2qX2TO1R+0Wkeug8Ubt0nqhdOlfUrq1bt9KoUaNjRiEtWbKEV199FQ8PDy699FJzwjmhuLg4hg0bxty5c5k0aRITJkyo2vbCCy+Qm5vLNddcowJ7NTD1CC5ZsqTqwywzM7PqviMXKFq3bs3DDz9sVrx6z9XVlUmTJjF8+HAGDBjAVVddhb+/Pz/88AN79uzh2WefJT4+3uyYTmvSpEksWbIEgM2bN1fdt2DBAgAuvvhiDd2uIU8//TRTpkzB19eX+Ph4nn322WMec/HFF1ddIJXqNWXKFCZNmsTgwYOJjo7Gx8eHlJQUZs+eTWFhIaNGjWLMmDFmxxQRJ6X2T+1Tm6d2qH1Tu9SeEZH6RueJ2qXzhDizb775hhdffJEhQ4YQExODh4cHCQkJzJ07F6vVyvvvv0+zZs3MjulU3n33Xfr27cvEiROZMWMGrVu3Zv369fzxxx9ER0fz0ksvmR3RKZhaDNu1axdTp0496r6kpCSSkpKAyilsVAw7M4MHD2bJkiU88cQTfPPNN5SXl9OuXTueeeYZrr76arPjObUlS5Yc89/30qVLWbp0KVA5nFgXhmpGcnIyAIWFhTz33HPHfUxMTIy+BNSQyy67jLy8PFasWMGiRYsoLi4mODiY/v37c9111zF69GgsFovZMUXEian9U7vU5qkdat/ULrVnRKS+0Xmiduk8Ic5s8ODBbNu2jXXr1rFw4UJKS0uJiIjgyiuv5J577qFnz55mR3Q6cXFxrFmzhscff5xffvmFuXPnEhkZyW233cbjjz9OeHi42RGdgsUwDMPsECIiIiIiIiIiIiIiIiI1wWp2ABEREREREREREREREZGaomKYiIiIiIiIiIiIiIiIOC0Vw0RERERERERERERERMRpqRgmIiIiIiIiIiIiIiIiTkvFMBEREREREREREREREXFaKoaJiIiIiIiIiIiIiIiI01IxTERERERERERERERERJyWimEiIiIiIiIiIiIiIiLitFQME2ngJkyYgMViYejQoRiGccz2xx9/HIvFQocOHSgrKzMhoYiIiEj9pvaWiIiISM1Se0tE/o3FON6ng4g0GIWFhXTq1Indu3fz2muvcffdd1dtW7lyJf369cPFxYVVq1bRqVMn84KKiIiI1FNqb4mIiIjULLW3ROTfaGSYSAPn6+vLZ599houLC4888ghbtmwBoLi4mGuvvRa73c4zzzyjhoKIiIjIaVJ7S0RERKRmqb0lIv9GxTARoW/fvjz44IOUlpZyzTXXUF5ezr333ktiYiIDBw7k/vvvNzuiiIiISL2m9paIiIhIzVJ7S0T+iaZJFBEAKioq6NWrF+vXr2fo0KH89ttv+Pv7s2nTJqKjo82OJyIiIlLvqb0lIiIiUrPU3hKRE1ExTESqbN26lW7dulFaWgrAlClTGDt2rMmpRERERJyH2lsiIiIiNUvtLRE5HhXDRKRKeXk5HTp0YOfOnQQEBJCamoqvr6/ZsURERESchtpbIiIiIjVL7S0ROR6tGSYiVf7zn/+wc+dOrFYreXl53HPPPWZHEhEREXEqam+JiIiI1Cy1t0TkeFQMExEAFi1axKuvvoq3tze//fYbgYGBTJo0iZ9++snsaCIiIiJOQe0tERERkZql9paInIiKYSJCfn4+Y8eOxeFw8NJLL3H22WfzzjvvADBhwgQyMzNNTigiIiJSv6m9JSIiIlKz1N4SkX+iYpiIcOedd5KcnMywYcO49dZbARgzZgxXXnklBw8e5MYbbzQ5oYiIiEj9pvaWiIiISM1Se0tE/onFMAzD7BAiYp7p06dz6aWXEhQUREJCAo0aNaralpOTQ/v27dm/fz+TJ0/m+uuvNzGpiIiISP2k9paIiIhIzVJ7S0T+jYphIg1YRkYG7du3Jysriy+//JLRo0cf85i5c+cyYsQIfH192bRpEzExMbUfVERERKSeUntLREREpGapvSUiJ0PFMBEREREREREREREREXFaWjNMREREREREREREREREnJaKYSIiIiIiIiIiIiIiIuK0VAwTERERERERERERERERp6VimIiIiIiIiIiIiIiIiDgtFcNERERERERERERERETEaakYJiIiIiIiIiIiIiIiIk5LxTARERERERERERERERFxWiqGiYiIiIiIiIiIiIiIiNNSMUxEAPj5558555xzCA4OxsfHh65du/LWW2/hcDjMjiYiIiJSr+3Zs4ePPvqIiRMn0qlTJ1xdXbFYLDz77LNmRxMRERGp9wzDYMmSJTzwwAP07t2bwMBA3N3dadSoEaNGjWL+/PlmRxSROsBiGIZhdggRMdcLL7zAI488AkBsbCy+vr4kJCTgcDgYOXIk06dPx2pV7VxERETkdNx999288cYbx9z/zDPP8Nhjj5mQSERERMR5/P7775xzzjkAWK1WWrRogY+PD4mJiRQWFgLw2GOP8cwzz5gZU0RMpqvbIg3c8uXLefTRR7FarUybNo2kpCQ2btzIunXriIiI4Mcff+TVV181O6aIiIhIvRUaGsoFF1zA008/zZw5cxg1apTZkURERESchmEYtGjRgnfffZesrCx27NjBunXryM7Orur8/eyzzzJr1iyTk4qImTQyTKSBO//88/n555+58cYb+eCDD47aNm3aNK6++mpCQkI4cOAAbm5uJqUUERERcR7jxo1j6tSpGhkmIiIiUg3y8/Px9vbG1dX1uNvPO+885syZw8iRI5k5c2YtpxORukIjw0QasPz8fObNmwfA+PHjj9l++eWX4+/vT3Z2tuZXFhERERERERGROsff3/+EhTCAoUOHArBz587aiiQidZCKYSIN2Pr16ykvL8fT05OuXbses93NzY0ePXoAsHLlytqOJyIiIiIiIiIickZKS0sB8PLyMjmJiJhJxTCRBiwxMRGAZs2anbAHTWxs7FGPFRERERERERERqQ8Mw+Dbb78FoF+/fianEREzqRgm0oDl5OQAEBQUdMLHHNl25LEiIiIiIiIiIiL1wUcffcT69etxd3fn7rvvNjuOiJhIxTCRBuzIMHF3d/cTPsbDwwOAkpKSWskkIiIiIiIiIiJyptatW8ddd90FwLPPPktcXJzJiUTETCqGiTRgnp6eAJSXl5/wMWVlZYDmVRYRERERERERkfphz549XHDBBZSWljJmzBjuv/9+syOJiMlUDBNpwE5mCsSTmUpRRERERERERESkLkhPT2fo0KEcOHCA888/nylTpmCxWMyOJSImUzFMpAFr2bIlAHv37sVmsx33Mbt37z7qsSIiIiIiIiIiInXRoUOHGDp0KElJSQwaNIhvv/0WNzc3s2OJSB2gYphIA9alSxfc3NwoLS1l3bp1x2yvqKhg9erVAPTq1au244mIiIiIiIiIiJyUwsJCzjvvPBISEujRowc//fSTlv0QkSoqhok0YP7+/pxzzjkAfPzxx8ds//bbb8nPzyckJISzzjqrltOJiIiIiIiIiIj8u7KyMi666CJWrlxJu3bt+OWXX/Dz8zM7lojUISqGiTRw//nPf7BYLEyaNIkvv/yy6v6NGzdy7733AvDggw/i7u5uVkQREREREREREZHjstvtjB49mj/++IO4uDh+++03goODzY4lInWMxTAMw+wQImKu5557jsceewyA2NhYfH19SUhIwOFwcP755zNz5kxcXFxMTikiIiJSPy1dupSLLrqo6vfCwkLKysrw9vY+auqe9evX07RpUzMiioiIiNRbX375JWPGjAEq17wPDw8/7uOioqL49ttvazOaiNQhrmYHEBHz/ec//6FTp0689tprrF27lvT0dDp06MD111/P7bffrkKYiIiIyBmoqKggOzv7mPuLi4spLi6u+t1ut9dmLBERERGnUFZWVvXvxMREEhMTj/u46Ojo2ookInWQRoaJiIiIiIiIiIiIiIiI09KaYSIiIiIiIiIiIiIiIuK0VAwTERERERERERERERERp6VimIiIiIiIiIiIiIiIiDgtFcNERERERERERERERETEaakYJiIiIiIiIiIiIiIiIk5LxTARERERERERERERERFxWiqGiYiIiIiIiIiIiIiIiNNSMUxERERERERERERERESclophIiIiIiIiIiIiIiIi4rRUDBMRERERERERERERERGnpWKYiIiIiIiIiIiIiIiIOC0Vw0RERERERERERERERMRpqRgmIiIiIiIiIiIiIiIiTkvFMBEREREREREREREREXFaKoaJiIiIiIiIiIiIiIiI01IxTERERERERERERERERJyWimEiIiIiIiIiIiIiIiLitFQMExEREREREREREREREaelYpiIiIiIiIiIiIiIiIg4LRXDRERERERERERERERExGm5mh1AROo2wzBYm5LD7M0H2JSaR3ZhGYVldkJ83GnfOIABLUMZ0T4STzcXs6OKiIiI1Dib3cGPG/czfX0auzOLAOjQOIArezblrPgwLBaLyQlFREREnN/e7GJ+3JjGptQ89mQV4TAM3Fys+Hq40qVZIANahtG/RShWq9pmIlLJYhiGYXYIEal7HA6DHzfu580/Eqsu9JxI40AvHj2vDed1iNQFIBEREXFauw4Wcvu0dWxPLzju9mFtI3jlik74ebrVcjIRERER51dYZuPnTQf4bl0qq/Yc+tfHNwv2ZuLAWMb0bIaLimIiDZ6KYSJyjM2peTz0/Sa2HsgHwNvdhXPbRzEwPpSoAC98PFw4kFvKur05TF+fxoG8UgAu6BjFS5d1wstdo8RERETEufySkM5932ygqNxOoLcb4/s1p1/LUGx2g1+3pPPp8mQq7Abdo4OYekNPfDw0CYeIiIhIdThYUMq785P4evU+SirsAFgs0L9FKINbhdMi3Bd3Vys2u0FmYSkrdx/i580HyC+1AdCukT8vXNqRDk0CzHwbImIyFcNEpIrdYfDm74m8PX8XdoeBn6crNw+KY2zfGHxPcEGnpNzOewuTeHf+LmwOg3aN/JlyfU/C/DxqOb2IiIhIzfh1Szq3frEOu8Ogd2wwb17VhXA/z6Mes3FfLtd+vJL8Uht9YkOYekNP3F21RLOIiIjI6cotLueDRbuZsjS5qggWG+bDZd2acEmXxkQFeJ3wucXlNr5evY/XfttJfqkNV6uF+4e34sYBsZo6UaSBUjFMRADIK6ngrq/Ws2BHJlA5yuupke0I8T25otbK3dnc+sU6sovKad/Yn69u7HPCApqIiIhIfbEkMYsbpqym3O7g0i6NefGyjri6HL/ItWFfLtdMWklhmY2JA5rzn/Pb1nJaERERkfrPZnfwxcq9vDx3BwWHR3d1bhrI/cNa0a9FyCkt0ZFVWMbjMxP4eXM6AMPbRfD6lV00q5FIA6RimIiQmlPMuE9Ws+tgIZ5uVp6/tAOXdGlyyvvZk1XEZe8tI7uonP4tQpk8rod6RIuIiEi9tSeriIveXkJ+qY3zOkTy5uguJyyEHfHrlnRu+mwtFgtMv7UfnZsG1k5YERERESewNiWH/85IqFq6o3WkH/cPa8WQNuGnvU69YRh8vXofj8/cQrndQacmAXxyfU+CfdyrM7qI1HEqhok0cNsO5DN28ioOFpQRFeDJR9d1p33j059DeVNqLqM/XEFxuZ2LOjfi9Ss7n3ZjRURERMQsBaUVXPzOUpIyi+jaLJAvb+yNh+vJ9SC+9+sN/LA+jU5NAph+az9NxSMiIiLyLw4VlfPCnG18syYVgAAvNx4Y3oqrejbDpZraUquTD3Hjp2vIKa6gdaQfX0zoddIzIolI/achGyINWEJaHld9tIKDBWW0ivDjh1v7nlEhDKBjk0Dev6YbrlYLMzfs54uVe6sprYiIiEjt+e+MBJIyi4gK8OT9a7uddCEM4OFzW+Pr4crG1Dy+XbuvBlOKiIiI1H/ztmYw7LWFVYWwK7o34Y/7BnFN7+hqK4QB9IgJ5rtb+hLu58H29ALGfLSSnKLyatu/iNRtKoaJNFCbU/O4etJKcosr6NQ0kG9u7vOPC4+eioHxYTx8bmsAnpm1lcSMgmrZr4iIiEhtmLkhjRkb9uNitfD2mK6E+3me0vPD/T25+5yWALwydydlNntNxBQRERGp1wpKK3jou01M+HQNWYXlxEf48v0tfXjxsk41NmIrLsyXr27sTbifBzsyCrh+ymqKymw18loiUreoGCbSAG3dn8/Vk1aQV1JBl2aBfDa+JwFebtX6Gjf0a87A+DDKbA7u+moDFXZHte5fREREpCak55Xy2IwEAG4f3IJu0UGntZ/r+sQQ6e/JwYIyvl+bVp0RRUREROq9hLQ8zn1jMV+v2YfFAjcOjOXH2/vTLTq4xl87NsyXLyb0ItDbjQ37crn587XqvCTSAKgYJtLA7M0uZuwnq8gvtdG1WSCf3tATf8/qLYQBWK0WXr68I4Hebmw9kM+kxXuq/TVEREREqtvjMxMoKLXRqWkgd5zd4rT34+5qZeLAWAA+WJSETR2DRERERACYtWk/l72/jNScEpoEefHVxN48el4bPN1OflrqM9Uywo9PxvXA292FxYlZ3Pv1RuwOo9ZeX0Rqn4phIg3IwYJSrp28ksyCMlpH+vHJ9T3xq4FC2BHhfp48dn5bAF6ft5M9WUU19loiIiIiZ+qXhHTmbs3A1WrhxVEdcXU5s69LV/VsSpC3GynZxfyckF5NKUVERETqJ4fD4NW5O7h92npKKxwMig9j9p0D6BUbYkqeLs2C+ODabri5WJi9+QCPzUjAMFQQE3FWKoaJNBAl5XZumLKalOximgV78+kN1T814vGM6tqYAS1DKbM5ePLHLTX+eiIiIiKnI7+0gid+rJwe8eZBcbSK9DvjfXq7uzKub3MApi5LPuP9iYiIiNRXZTY7t3+5jjf/2AVUTos4eVyPWrk29U8GtAzj9Su7YLHAl6v28vLcHabmEZGao2KYSANgGAYP/7CJhLR8Qnzc+Wx8T8L9T20h+NNlsVh45qL2uLlYWLgzk4U7M2vldUVEREROxUu/7CAjv4zmoT7cfgbTI/7dVb2a4mq1sDYlhx3pBdW2XxEREZH6orjcxoSpa/h5czruLlZevrwTj57XBherxexoAJzfMYrnLu4AwDvzk5i0eLfJiUSkJqgYJtIATFq8h5kb9uNqtfDu1V2JDvGp1dePCfXhuj4xAPzf7G2ag1lERETqlG0H8vliZQoAz13cvlrXqwj38+ScNhFAZW9jERERkYaktMLOhKlrWJyYhbe7C59c34PLujUxO9YxxvRqxgPDWwHw7OxtfLc21eREIlLdVAwTcXJLd2Xx/JxtADx+YVvT5mG+4+wWBHi5sSOjgG/W7DMlg4iIiMjfGYbBs7O34jDg/A5R9G0RWu2vcVWvZgD8sC6V0gp7te9fREREpC6yOwzu/moDy5Ky8XF34bPxvehXA22t6nLrWXFM6F85xfVD329i7hat+SriTFQME3Fi2YVl3P31BhwGXNG9Cdf2jjYtS6C3O3cOaQnAK3N3UlhmMy2LiIiIyBHzth1k6a5s3F2tPHxu6xp5jQEtQmkS5EV+qY05CQdq5DVERERE6hLDMHhsRgK/bKmcGvGj67rTLTrI7Fj/yGKx8J/z23BZtybYHQa3f7me5UnZZscSkWqiYpiIkzIMg4e+30xmQRktw315+qL2WCzmzsV8be9oYkK8ySos0yLyIiIiYrpym4P/+7lyBP2E/s1pGuxdI69jtVqqpgOauWF/jbyGiIiISF3y/sLdfLlqL1YLvDG6c42Mvq8JFouFFy7twNC2EZTbHEz8dA0JaXlmxxKRaqBimIiT+mLlXuZty8Ddxcobo7tU69oXp8vd1crd58QD8NHi3RSUVpicSERERBqyT5cnsyeriFBfD24d3KJGX2tkp0YALE7MIruwrEZfS0RERMRMC3dm8uKv2wF4amQ7zu0QZXKiU+PqYuWtq7rQq3kwhWU2xk5exe7MQrNjicgZUjFMxAntzizk2dlbAXhwRCvaNvI3OdGfLuzUiNhQH3KLK/h0eYrZcURERKSBOlRUzhu/JwLwwPB4fD1ca/T1YsN86dA4ALvD4OcErT8hIiIiziklu4g7pq3DMGB0j6ZcY+KSHWfC082FSWO7076xP9lF5Vz78SoO5JWYHUtEzoCKYSJOxjAMHp2+mdIKB/1ahHBDv+ZmRzqKi9VStXbYR4t3a+0wERERMcU783dRUGqjbZQ/l3VrWiuveWR02E+aKlFEREScUGmFnZs+W0t+qY3OTQN56qJ2pi/ZcSb8PN2Ycn1PYkN9SMst4dqPV3GoqNzsWCJymlQME3Ey365NZcXuQ3i6WXnh0o5YrXWv0fHX0WFaO0xERERqW0Z+KZ+vqByh/tC5rXGppfbSBZ2isFhgVfIh9ueqZ7GIiIg4lxfmbGd7egGhvu68f003PFzNX7LjTIX6evDp+J5E+nuy62Ah13+ySh27ReopFcNEnEhWYVnVIvD3nBNfY4vAn6m/jw4rLlcjQkRERGrPO/N3UWZz0CMmiIEta28x96gAL3pEBwPw6xZNlSgiIiLOY/72g0w53OH55cs7ERngaW6gatQkyJvPxvck0NuNjal53PzZWspsdrNjicgpUjFMxIk8O2srucUVtI3yZ3z/ujU94t9d2KkR0SHe5BZX8P3aVLPjiIiISAORmlPMl6v2AnDv0Fa1PnXP8PaRAPyidcNERETESWQVlvHAdxsBGNc3hrNahZucqPq1jPBjyvU98XZ3YcmuLO75egN2h2F2LBE5BSqGiTiJ1cmHmLFhPxYLPH9pB1xd6vaft4vVUrWe2cdL9uBQA0JERERqwdt/7KLCbtA3LoQ+cSG1/vrD20UAlW23rMKyWn99ERERkepkGAaP/rCZrMJyWkX48fC5rc2OVGM6Nw3kw2u74+5i5efN6Tw2YzOGoetZIvVF3b5aLiInxeEweOqnLQCM7tGMTk0DzQ10ki7r1gR/T1eSs4uZty3D7DgiIiLi5FKyi/j28Ij0+4bFm5KhSZA3HRoH4DBg3la1f0RERKR++yUhnblbM3C1Wnh9dGc83er/OmH/pH/LUN4Y3RmrBb5ctY8Xf91hdiQROUkqhok4ge/WppKQlo+fh6tpF3ZOh4+HK1f3jgZg0uI9JqcRERERZ/fG74nYHQZntQqj2+G1u8ww4shUiVo3TEREROqxvJIKHv+xsnP2LWfF0SbK3+REtePcDlE8d0kHAN5bkMSHi5JMTiQiJ0PFMJF6rqC0oqoXyp1DWhLq62FyolMzrm8Mbi4WViUfYuO+XLPjiIiIiJPadbCQGevTALh3qLmdh4a3qyyGLd2VRUFphalZRERERE7X/37ZTmZBGbGhPtw2uIXZcWrVVT2b8dCIyikh/+/n7XyzZp/JiUTk36gYJlLPvbcgiazCMpqH+jC2b4zZcU5ZhL8nF3ZqBFSuHSYiIiJSE16ftxOHAcPaRtCxSaCpWVqE+xIT4k2F3WDprixTs4iIiIicjlV7DjFt5V4A/u/SDk4/PeLx3DwolhsHxgLw8Peb+FWj/kXqNBXDROqxzIIyPlmaDMAj57bG3bV+/knf0K85AHMSDpBZoIXkRUREpHrtSC9g9uYDANxj8qiwIwa3Dgfgj+0HTU4iIiIicmrKbHYe+WETAKN7NKV3bIjJicxhsVh45NzWXN6tCQ4D7vl6A4kZBWbHEpETqJ9XzkUEgPcXJlFSYadT00CGto0wO85pa984gC7NAqmwGxpWLiIiItXuzd8TMQw4r0NknVnL4uzDxbD5OzJxOAyT04iIiIicvMlLkknKLCLU14NHzm1jdhxTWSwWnr+0A33jQigut3Pz52spLLOZHUtEjkPFMJF6KiO/lM9XpACV615YLBaTE52Za3tHAzBt5V7suiAkIiIi1WR7ej6zNx/AYoG7htSNUWEAPZsH4+3uQmZBGVv255sdR0REROSkHCwo5Z35u4DKWYoCvN1MTmQ+Vxcrb17VhUh/T5Iyi3jou00Yhq5tidQ1KoaJ1FPvzN9Fmc1B9+ggBrYMNTvOGTuvQxRB3m6k5ZYwX9MFiYiISDV5Y14iUNnWaBXpZ3KaP3m4utC/RWUbTlMlioiISH3x6tydFJbZ6NQkgEu6NDY7Tp0R6uvBO1d3xdVqYfbmA3y8ZI/ZkUTkb1QME6mHUnOK+XJV5SKl9w6r/6PCADzdXLiie1MAPjs84k1ERETkTGzdn8+chPTDo8Jamh3nGEemSvxjh4phIiIiUvdt2Z/H14eXt3j8wrZYrfX/elR16hYdxGPnV04b+fyc7axNyTE5kYj8lYphIvXQ23/sosJu0Cc2hL5x9X9U2BFjejXDYoGFOzNJyS4yO46IiIjUc2/+Xjkq7PwOUcRH1J1RYUcMPlwM25SaS1ZhmclpRERERE7MMAye/mkrhgEXdmpEt+hgsyPVSWP7xnBhp0bYHQb3fbOB4nKtHyZSV6gYJlLP7M0u5tu1qQDcN6zurHtRHaJDfBjYMgyAL1buNTmNiIiI1Gdb9ufxy5a6OyoMIMLfk3aN/DEMWLAj0+w4IiIiIif065YMVu45hIerlYdGtDI7Tp1lsVh49uL2RPp7kpxdzIu/7DA7kogcpmKYSD3z4eIk7A6DAS1D6R7jfL1wru0dDcA3a/ZRWmE3OY2IiIjUV0fWCruwYyNa1sFRYUcMblU5Omy+pkoUERGROqrMZuf/ft4GwI0DY2kS5G1yorotwMuNFy/rCMCUZcks25VlciIRARXDROqVzIIyvllTOSrs1rNamJymZgxuHU7jQC9yiyuYk3DA7DgiIiJSDyWk5TF3awYWC9w5pG63mc5qVTkqfumuLOwOw+Q0IiIiIseasjSZvYeKCffz4OZBcWbHqRcGxodxda9mADzw3SZNlyhSB6gYJlKPTFm2h3Kbg85NA+kd63yjwgBcrBYu794EgG8PF/5ERERETsVLv1ZORzOyUyNahNfdUWEAnZoG4ufhSm5xBQlpeWbHERERETlKXkkF78zfBcD9w1vh4+FqcqL649Hz2tAkyIu03BLe/mOX2XFEGjwVw0TqiYLSCj5dngLArWfFYbFYTE5Ucy7r1gSLBZYlZbPvULHZcURERKQeWZaUxcKdmbhaLdw7tO6vr+rmYqVPXAgAixO1bpiIiIjULR8t2k1+qY34CF9GdW1idpx6xcfDlScubAfAR4t3szuz0OREIg2bimEi9cS0lXspKLXRItyXc9pEmB2nRjUJ8qbv4YtC363V6DARERE5OYZh8L/Di5SP6dWM6BAfkxOdnIHxlVMlLkrUehIiIiJSd2QVljF56R4A7h3aCher83bMrinntAlncKswKuwGT/y4BcPQtNgiZlExTKQeKLc5+HhJZePj5kFxWBtA4+OK7k2BymKYQ+tniIiIyEn4JSGdjfty8XZ34Y6zW5od56QNbFlZDFuXkkNBaYXJaUREREQqvbcgieJyOx2bBDC8nXN3zK4pFouFJy5sh7uLlcWJWfy6Jd3sSCINlophIvXAz5sPcLCgjHA/D0Z2amR2nNM2a9YsBg0aREBAAP7+/gwaNIhZs2b9P3v3HVd3efYP/PM9g733hkAgJEASsvfeMSbOOmO12vqr21q1j9pha22Ns65arXVvTcwwe+8FScgijDDD3nA4nPX9/XGGxpAECHCf8Xm/Xr4eHzjAh5gmN9/rvq6r09fOTYuAr4cK5Y3t2FtY1+lrOjo68OKLL2LUqFHw8/ODj48PBg0ahF/96lcoLy8/77XTpk2DJEmX/Eeh4B+JREREjkpvNGHZBnNX2N2TExHq6y44kVlXzj9xwV6ID/aCwSRjX2F9lz/3rFmzbOeYysoLH6y0tbXh448/xgMPPIAxY8bA3d0dkiThH//4xxV/X0REROTcKpra8fE+87qO380Z5NTrOn6uO8+vLmXlypW44447sGj6OJS/cQuKly3G1eOGYN78+VizZk2nH3Ps2DHcf//9GDduHKKiouDu7g5/f3+MHz8eb7zxBgwGw5V+e0QuixsPieycLMv4n6Ul/fZx8XBTOWbB5l//+hceeughqFQqzJo1C+7u7tiwYQMWLVqE1157DQ8++OB5r/dQK3H1sCh8ur8EXx8qxcSBIee9v7q6GrNmzUJOTg4iIiIwa9YsAEB+fj7ef/993HnnnYiOjra9ft68eUhISOg02+HDh3H8+HFMnjy5d79pIiIi6jcf7y1GYU0bgr3dcM/kAaLjAOje+WdycgiK60qwM68Gs4dc/ub1Bx98gM2bN0OSpIuO28nLy8PSpUt77fshIiIi1/H6lnzoDCaMGRCEKckhl/8AJ9Hd51eX8tFHH+G7775DWloaJk8YjwPl7WirrcD6deuwft06PPPMM3j22WfP+5gdO3bgzTffRHx8PIYMGYLQ0FDU1NRg9+7d2LdvH5YvX45169ZBrVb39rdO5PQkmYNKieza4eIGXPf2HripFNj75AwE+9jHLefuOHPmDNLS0qBUKrF161aMHz/e9vYJEyagqakJJ0+eRHLy+eOMjpY2YvGbu+GuUuDQ0wgp6LYAAMe9SURBVLPg62H+i95kMmHixInYt28fnnrqKfz5z3+GSvVjbb+wsBB+fn4ICenaYW3s2LE4cOAA3n33Xdx999299F0TERFRf6lr7cC0F7ehRWvA89dm4OYxcaIjdfv8s/5EJX7z8WEMCPHG1semXfJz19TUYPDgwRg5ciRyc3NRXFyMiooKREREnPe6goICPP/88xgzZgxGjx6Nb7/9Fs899xyef/55PPnkk33yfRMREZHjK6nTYMZL22Awyfj63vEYnRAkOlK/6Onzq4vJzs5GXFwcgoODAQCf7CvG0yuOw6O+AOWfP4W2tjYcP34cQ4YMsX1MYWEhACAxMfG8z1VVVYVZs2bh+PHjePvtt3Hvvff2xrdM5FIcs8WEyIVYu8KWDI9yyEIYALz22mswGAy49957bQcJAEhJScFTTz0Fg8GAf/3rXxd83NAYfySFeqPDYML6E1W2t3/wwQfYt28frrvuOvztb387rxAGmA8MXS2E5eXl4cCBA3B3d8cNN9zQw++QiIiIRHpxwxm0aA0YEuln2zsqWnfPP+OTgqFUSDhb24bSes0lP/fDDz+MtrY2vPXWW5d8XVJSEt577z38+te/RmZm5gVnJiIiIqLOvLUtHwaTjCkpoS5TCAN6/vzqYjIzM22FMAD4xehYDAjxhjYoCemT50OWZWzbtu28j0lMTLygEAYA4eHhtstMW7Zs6eZ3RkQAi2FEPVJUVARJkjBt2jS0tbXh0UcfRWxsLDw9PTFixAisWrXK9tqvv/4aY8aMgbe3N8LDw/Hggw+ivb39gs/Z2tqKZ599FhkZGfDy8oKfnx/GT5yMb75bDgC4c+L5437WrFmDu+66C4MHD4afnx+8vb0xbNgw/P3vf0dHR8cFn/+DDz6AJEn485//jJKSEtxyyy0IDQ2Fp6cnRo0adV7m3madq3z99ddf8D5rAaqzry9JEpYMN486XJH94w6wd955BwDwu9/97oqzffLJJwCAq6++Gv7+/lf8+YiIiJxVf51/pk6dihUrVnSaobPzT/LgdPz7tRchG/T406IhUCp+3GfhSOcfPw81MmMDAAA782ov+nnXr1+Pzz77DE899RSSkpJ6MTERERE5m56c37y8vfHi0qmo3/QOfjMx+oLP2RvnN2d7ftVVaqUCv5uTAgDIrWoDALi5uXX545VKZbc/hoh+xKuBRFdAp9Nh5syZKCgowLhx49Da2oodO3bgmmuuwbp165CTk4PHH38co0ePxpw5c7Bz5068/vrrqKurw6effmr7PFVVVZgxYwZOnjyJ6OhozJ49GxqNBjt27YFOuwtDr7kXgyMXnve1f/WrX6GtrQ1paWnIyMhAc3MzDhw4gKeeegqbN2/Ghg0bbH9J/lRRURFGjx4NDw8PTJo0CVVVVdi7dy+WLFmCtWvXYs6cOb36a9TY2IiSkhIA5hsxPxcTE4OQkBAUFxejqanpgoLU4uHReGnjGewpqEVVsxZekh6HDh2Cr68vxo4di71792LlypWor69HXFwcFi9ejPT09C7ns/53uO22267guyQiInIdfX3+2bt3L6655ppOR/n9/PzT2NSErTv3wnD6BPzqT2PUPxd1mtlRzj+Tk0NxqLgBO/NqcMvYC0c9ajQa3HvvvUhNTcXjjz/eq5mJiIjIeXXn/BY/dBzOHD2ElsOr8NazvpjYy+c3Z31+1VUL0iORIG3AzhPboVSpMHPmzC59XENDA1566SUAwPz583v0tYlcnkxE3Xb27FkZgAxAnjZtmlxfX2973//+9z8ZgDxw4EA5KChI3rFjh+195eXlclhYmAxALigosL19/vz5MgD58ccfl3U6nSzLsqzpMMipD30gqwIiZYVSKR89evS8DMuXL5dbW1vPe1tzc7N81VVXyQDkDz/88Lz3WXMBkB944AFZr9fb3vfqq6/KAOTJkydf8L3Gx8fbPq6r/5w9e9b28UePHpUByIGBgRf99Rw+fLgMQD527Fin77/2rd1y/BOr5Xd3FMj79u2TAciZmZnyfffdd8HXliRJ/v3vf3/Rr/VTe/bskQHIwcHBtl93IiIi6lx/nH9kWZYLCgrkpKQkWdmF88/f15yUYx/+Sg4YNM4pzj+Hi+vl+CdWyxl/WifrDcYLPubRRx+VAchbt269IGtFRcVFv5bVn/70JxmA/Pzzz1/2tUREROT4unt+q23RyoOe/kGO/u2HcmBwSJ+c32TZeZ9fXczKlSvlO+64Q77lllvkSZMmyQqFQoZSLUde/ajc0NbR6cecOXNGvuOOO+Tbb79dnjNnjuzj4yMDkH/zm9/IJpOpW1+fiMzYGUZ0BZRKJd59910EBgba3rZ06VI8/vjjyM/Pxx//+EdMnjzZ9r6oqCjceuuteOWVV7Bjxw4kJibiyJEjWLt2LSZMmIB//OMfkCTzaJ8VR8rR7hGC5Kv/H0599Ee89957580lXrJkyQV5fH198corr2D16tX4/vvvsXTp0gtek5iYiJdeeum8nRH33Xcf/vKXv2Dfvn3Q6XTntVtff/31qK29+Kiezvj4+Nj+vbW1FQDg5eV10dd7e3uf99qfW5IZjcPFDVieXY6YFHMbeU5ODrKzs/HYY4/hvvvug4+PD1asWIGHHnoIy5YtQ2Ji4mWXiX788ccAgJtuuglqtbrr3yAREZEL68vzD/DjWWXJkiWXPP8cKW3EuzsLoXD3wquvvIJfLhjv8OefodH+8PNQoVlrwLHyJoyI+/HXOCsrC6+99hruuOMOTJs2rVvZiIiIyLV19fy2bP1paPUmjBiciKTbb8Orr77aq+c3K2d9fnUxR48exYcffmj7/z08PJC46D60DpiK/+0uwiOzUy74mKqqqvM+BgDuv/9+PPfcc+f92hNR17EYRnQFEhISMHDgwPPeplAoEB8fj5qaGsyePfuCj7HudqioqAAAbNy4EQCwePFi219msizjf7vPAgB+fcMCPPLRH3Hw4MELPldeXh5++OEH5Ofno62tDSaTCbIs297XmWnTpl1Q+FGpVEhMTMThw4dRV1eHyMhI2/tefPHFy/9CXII1z6X+ora+5mIWZkTiLytP4MS5ZpQEmRfKGwwG3HzzzVi2bJntdXfffTc6Ojpsh4NLFcP0ej2++uorAMDtt9/e5e+HiIjI1fXV+eenJk2aBAAXPf98u2Il/rV8F5pbWxEb6IktFYG293XGUc4/KqUCk5JD8ENOJXaeqbUVw4xGI+655x4EBARccTYiIiJyPV05vzVr9fhoTzEA4L7pA5EvmV/fW+c3V3h+dTFPP/00nn76aWi1WuTn5+Ptt9/G22+/DI/EHXjf7U+4Z0oifNzPf0w/adIkyLIMo9GIkpISLF++HH/5y1+wfv16bNiwAQkJCT3KQuTKWAwjugLR0RcuEgV+vCnS2fut77MuCS0qKgIAPPHEE3jiiScueP0j/zT/35/ebpFlGY899hheeeWVi/5F3NLS0unbY2JiOn279TZMZ8tLr4Svry8AoK2t7aKv0Wg052X4uSBvN0wbFIpNp6qRXam1vf2uu+664LV33nknHnjgAZSVlSE/P/+Cw57V2rVrUVdXh+TkZIwdO7bL3w8REZGr64/zj1VXzj+nAZzeYf53Zzj/TE4ONRfD8mrw0KxkAMCrr76KrKws/Pe//0VISEivZiUiIiLn15Xz28d7i9HSYUBKuA9mDw5HxcG+O7/9lDOc37rKw8MD6enpePPNN6FUKvH666+jfPd3+Gx/Kn49JanTj1EqlRgwYAAeffRRDBgwANdeey0eeOABrFq1qkcZiFwZi2FEV+BybcldaVs2Go0AgMmTJyMxMREAsK+wDmUN7UgK9Uam5UbwTx98fPnll3j55ZcRExODV199FePHj0doaCjUajV0Oh3c3d0vesjobiv1Y4891u028xdffNGWNy7OvPy9oaEBbW1ttoPWT5WVlZ332s4sHh6NTaeqcbD2xz+24uPjL3idl5cXQkNDUV1djerq6osWwz755BMAwG233dbF74qIiIiAvjv/dKaz809ASARUk+6EX9wQfPfofAyLD3aq88+kgebPkV3aiGatHn4eaqxatQqSJOHDDz/ERx99dN7rKysrAQDXXnst3Nzc8Le//c12M5uIiIgIuPxZSGcw4f1d5glFv502EArFha+/kvObKz2/6qrbb78dr7/+OjR5+/HuzrNYOj4BHmrlJT9myZIl8PHxwdq1ay8YE0lEl8diGJFg1psu119/PR588EHUtHRg/PObEWKS8eXDk5Ea4XfBxyxfvhwA8Pbbb+Oqq646732FhYW9mu+bb75BcXFxtz7mz3/+s+0wERAQgLi4OJSUlCA7O/uChzNlZWWora1FXFwc/P39L/o5Zw0Oh4+7CrUdfvAPDEJTQz3q6+sveJ3JZEJjYyOAi9/UaW5utt2gYTGMiIio//38/NMV1vOPeuqv4TVwDJbdOAzD4oMBONf5JzbICwNCvHG2tg17C+owNy0CgPlm9Y4dOy769ffu3QsA3X4IRERERLTxZBXq2nSIDvDEVUMjO33NlZzfXOn5VVdZv66iowU1LR1YeeQcbhwde8mPkSQJQUFBKCkpQUNDA8LDw684B5ErUYgOQOTqZs2aBQBYsWIFAOCbw2UwmGRkxgV0WggDzLdUACA29sK/JK17sHpLUVERZFnu1j8/n1u8cOFC8/f2zTcXfP6vv/4aAC44FP2cp5vS9jAofvhkAMDWrVsveN2ePXug0+ng6emJ1NTUTj/XN998A61Wi4kTJ17yNhMRERH1jZ+ff7oit9i8r0LlF4JfTRqAa0f8ODrH2c4/1u6wXXnmwta2bdsu+nWtnfIVFRWQZbnTJfVEREREl/L14VIAwNLx8VApO39c3JPzmys+v+qq7du3AwAGWnbrvr/77GV3khUWFqK0tBR+fn4cnU3UAyyGEQk2btw4zJw5E1u3bsXDDz+MT3flAgBuHmNuuTaZTNiwYQN27dpl+5iUlBQAwH/+85/z/qLcuXMnli1b1o/pu+ahhx6CUqnEv//9b+zbt8/29ry8PDz33HNQKpUX3CoqLy9HamrqeQWtq4dHAQD0aVdBqVRi2bJlyM7Otr2/uroaDz30EADzPrGLtYtbRyTefvvtvfMNEhERUbf89PzzyCOPoLW19bz3//z8syK7HIV68yWhyIrdeGrBj+cDZzz/fPDoEgDArnx2eREREVHfK6hpg6daiZtGX3z8X3fPb4DrPr8CzM+oXnrpJdv0op/auHEjHn/8cQDAYw/+Bl5uSpyubMHu/Dq88MILnXbN5ebm4pZbboEsy1i6dCmUykuPVCSiC7EYRmQHPv30UwwdOhSvvfYa9j53E2q/fBpfv/AYJk+ejIiICMydOxeHDh2yvf7BBx+Et7c33nrrLaSnp+Pmm2/GlClTMHXqVNx7770Cv5PODRo0CMuWLUNHRwcmT56MBQsWYMmSJRg2bBjq6uqwbNkyDBo06LyP0ev1yM3NRW5uru1tE5KCEeilhsY7Evf/4a+or6/H+PHjMX36dCxatAipqanIysrCiBEj8Pzzz3eapby8HNu3b4ebmxtuvPHGPv2+iYiI6OKs559XX30V8fHxmDlzJm666aYLzj/fHynHo18dge/Iq6H28ETWui+RkZHh1OefsrMFUCoknK1tQ1mD5opyXHPNNRg3bhzGjRuH9957DwDw1ltv2d52zTXXXNHnJyIiIudw7Yho+HupL/marp7frFz1+RUAaDQaPPbYY4iKisKUKVNwyy23YPHixRg8eDDmzJmDmpoaPPLII1h68y9ww0jzxIP3dhXirbfeQnJyMkaMGIEbb7wRN9xwA8aMGYMhQ4Zg//79mDJlykWfeRHRpbEYRmQHwsPDsW/fPky89VGoAqOgr8rDqpXfo6ysDJmZmXjzzTfP222VkpKCgwcPYtGiRaitrcXKlSvR2tqKd955xy5v1gDAI488gpUrV2L8+PHYuXMnNm/ejJEjR+L777/HI4880qXPoVYqMC/dPLvaY/hCrF+/HlOmTEF2djY2btyIyMhI/OUvf8HOnTvh6+vb6ef49NNPYTKZsHDhQgQGBvba90dERETdYz3/vPzyy0hOTsbBgwexYsWK884/ocNn4ZEvj8AkA7fPHYfsQ4dc5vwzLMa8i8I6KrGnsrOzsX//fuzfvx/l5eUAgNLSUtvbftplT0RERK6lw2Cy/fudExMu+/qunN/4/MosLCwML7zwAqZPn46SkhKsWLEC69evh1arxU033YStW7fi5ZdfBgDcOXEAJAnYlluDBx5/GjfddBPa2tqwfv16fP/99ygpKcHs2bPxwQcfYOvWrfDx8emrb5/IqUny5YaRElG/qGvtwLjnN0NvlPHDg5MxJKrzfWGubnd+LW59bz8CvNQ4+NQsqC8yy5qIiIgc25pjFXjwi2wYTTJuGBmDf143FAqFJDpWv3ll4xm8tjkPC4dG4s1bRoiOQ0RERE7ob6tP4r1dZzE5OQQf/2qs6Dgu7Z6PDmHjySrcMjYOf78mQ3QcIqfEp8hEdmLFkXPQG2UMjfFnIewSxg4IQoiPGxo1euzmHg0iIiKntO74j4Wwa0dE4x8uVggDgMnJ5qXoe/JrYTLx/iIRERH1rrYOA748VAoAuGviAMFpyPrfYEV2OZq1esFpiJwTi2FEdkCWZXxtOYBY5wRT51RKBeZbRiWuPlYhOA0RERH1tk0nq3D/Z+ZC2DWZ0Vh2/TAoXawQBgDDYgPg465Cg0aPE+eaRcchIiIiJ/NdVhlatAYkhnhjakqo6Dgub1xiEAaG+UCjM+L77HLRcYicEothRHbgxLlmnK5sgZtKgauHRYuOY/euGmouhq0/UYkOg1FwGiIiIuotewvq8NvPsmAwybh6WBRevME1C2GAeVfquMRgAMDO/BrBaYiIiMiZyLKMT/eXAABuHx/vch349kiSJNwyJg4A8On+EnCzEVHvYzGMyA5Yu8LmDAmHv5dacBr7NzohCOF+7mjRGrDzDEclEhEROYOT55px94cHoTOYMHtIOF6+0XULYVbWUYm78njeISIiot6TU95ku5R9TSYvZduL60bEwF2lwOnKFmSXNoqOQ+R0WAwjEqzDYMT3R88BAG4YFSs4jWNQKCQsyLCOSjwnOA0RERFdqepmLX714UG06YwYlxiE12/OhErJH1UmWYphh4oa0K5jNzwRERH1ji8Omi9lz0+PQICXm+A0ZOXvpcZCyzSkT/eVCE5D5Hz4EyaRYJtPVaNRo0eEnwcmDQwRHcdhXDU0CgCw8WQVtHo+HCIiInJUOoMJ93x8GBVNWiSGeuOd20bBQ60UHcsuJIZ4I8rfAzqjCQeK6kXHISIiIieg0Rmw6oj5YvEvRvNStr25dWw8APPl7yaNXnAaIufCYhiRYNYRideOiHb5UUDdMSIuANEBnmjTGbH9DPdoEBEROaqXNubiaGkjArzU+N8vR3Nk9E9IkmTrDtuVx/MOERERXbkfcirR0mFAfLAXxg0IFh2HfmZEXABSI3zRYTDh26wy0XGInAqLYUQCVTVrbYWc60fGCE7jWCRJwoKMCADAmmMVgtMQERFRT+zKq8U72wsBAP+8bijig70FJ7I/k5JDAQA7uTeMiIiIesGXB83j924cFQsFL2XbHUmScOvYOADAZwdKIMuy4EREzoPFMCKBvssqh0kGRsUHIjHUR3Qch7PQMipx0ymOSiQiInI0bR0GPP7NUQDALWPjMDctQnAi+zQxyXxj+3RlC2paOgSnISIiIkdWUNOKg0UNUEi8lG3PFmdGw1OtRH61+b8XEfUOFsOIBJFlGcuzze3O1/EA0iPDYvwRHeAJjc6IbbnVouMQERFRN7y66QzONWkRE+iJpxcOFh3HbgX7uCMtyg8AsDuf3WFERETUc8uzygEAU1NCEe7nITgNXYyfhxqLhkUC+HG9ChFdORbDiAQ5VdGCM1WtcFMqsCAjUnQchyRJEhYONf/arcmpFJyGiIiIuurkuWa8v7sIAPDXxenwclOJDWTnrHvDdnBvGBEREfWQLMtYccRcDLtmBC9l27vrR8YCAH7IqYBGZxCchsg5sBhGJMj3lgPI9NRQ+HtyUXxPLbQUEjefqkK7jqMSiYiI7J0sy/jr6pMwmmQsyIjA9NQw0ZHs3uSB5r1hu/JquTeCiIiIeuRwcQPKGtrh7abE7MHhouPQZYxOCERckBfadEasP8EL4ES9gcUwIgFMJhkrj54DACwZHi04jWMbGuOPmECOSiQiInIUO/JqsbewDm5KBf5vAccjdsWohEC4qxSobulAXnWr6DhERETkgKxdYXPTI+DpphSchi5HkiRcO8L8zPDbw+WC0xA5BxbDiATYf7YeFU1a+HqoeBv6CkmSZOsOW51TITgNERERXYrJJOMfa08DAO6YEI+YQC/BiRyDh1qJMQOCAAA787g3jIiIiLpHZzBh9THzM5NrMnkp21FcZxlnubugFuca2wWnIXJ8LIYRCWAdkTg/PQIeat7GuVLWvWFbTlVzVCIREZEdW51TgVMVzfD1UOG30waKjuNQJg007w3bxb1hRERE1E07ztSgUaNHqK87JiSFiI5DXRQb5IUxA4Igy8DybHaHEV0pFsOI+lmHwYgfLB1MHJHYOzKi/REb5Il2vRFbOSqRiIjILsmyjLe25gMA7p6UiEBvN8GJHMukZPODq/1n66EzmASnISIiIkey3HIp++phUVAqJMFpqDuut3SHfZtVxt2xRFeIxTCifrb1dA2atQaE+7ljbGKw6DhOwTwqMQoAsOYYRyUSERHZo6251Thd2QJvNyV+OSFBdByHMzjCD8HebtDojMgqaRAdh4iIiByERmfA5lNVAHgp2xHNz4iAh1qBwpo2HCltFB2HyKGxGEbUz1Ye5W2cvmDdG7b5dBU0OoPgNERERPRzb20tAADcOi4e/l5qwWkcj0IhYaJtVCL3hhEREVHXbM+tgVZvQmyQJ9Kj/UTHoW7y9VBjfrr5mde3WWWC0xA5NhbDiPpRs1aPTafMY/wW8zZOr0qP9kNckBe0ehO2nuYuDSIiInuSVdKAQ8UNcFMq8KtJA0THcVjWUYk781kMIyIioq5Zd6ISADA/PRKSxEvZjug6y6jEVUcr0GEwCk5D5LhYDCPqRxtPVEFnMCEp1BtpUbyN05skScLCoeabMmtyzglOQ0RERD/10Z4iAMDVw6MQ7uchNowDm2wphuWUNaJJoxechoiIiOxdh8GILZZL2XPTIgSnoZ4anxSMcD93NLXrseMML0UR9RSLYUT9aE2OeZ/VomFRvI3TB6yjErecrkZbB0clEhER2YOalg7bGeiO8Qliwzi4SH9PDAzzgUkG9hTwQQgRERFd2p78OrR0mPfWZ8YGiI5DPaRUSFiYEQUAWHmUF8CJeorFMKJ+0qTRY2eeeXyftWhDvSstyg/xweZRiVtOV4uOQ0RERAC+OFACvVFGZlwAMmL8RcdxeJMGclQiERERdc264+YRiXPTIqDg3nqHdvVwczFs08kqaHS8AE7UEyyGEfWTDScroTfKGBTui+RwX9FxnJIkSbZC4w+WG+hEREQkjsFowqf7SwCwK6y3WEcl7spjMYyIiIguzmA0YcNJczFsHkckOrxhMf6ID/ZCu96ITad4AZyoJ1gMI+on1vFA1r1W1Desv74clUhERCTezrxaVDZrEeilxvwMPoTpDWMTg6FSSCip16CkTiM6DhEREdmpA0X1aNDoEeilxpgBQaLj0BWSJAmLhlpGJR7hqESinmAxjKgfNGp0ttu7CzgisU8NifTDgBBvdBhM2MxRiUREREJ9dagUAHBNZgzcVUrBaZyDj7sKI+ICAQA782sEpyEiIiJ7td4yInH2kHColHwE7AysoxK3n6lGk0YvOA2R4+GfhET9YMOJKhhMMlIjfDEwzEd0HKcmSRIWWG6erznGmzJERESi1LV2YNOpKgDAjaNjBKdxLpM4KpGIiIguQZZl2wXh2UPYne8sUsJ9kRrhC71RxroTXA9C1F0shhH1g9XWEYnsCusXCzPMN2W25daglaMSiYiIhFieXQ69UcawGH+kRviJjuNUrMWwPQV1MJpkwWmIiIjI3uRXt6KsoR1uKgUmDgwWHYd60aJhllGJR3kBnKi7WAwj6mMNbTrszreMSOS+sH4xONIXidZRiZYb6URERNS/vs0qBwBcPypWcBLnMzTaH74eKjS165FT3iQ6DhEREdkZa1fY+MRgeLmpBKeh3nS1pRi2t6AO1S1awWmIHAuLYUR9bP2JShhNMgZH+iEplCMS+4MkSVhoKTyuOca2cSIiov52pqoFpyqaoVZKWMTLQL1OpVRgQpL5lveuPO4NIyIiovNtsRTDZqSGCU5CvS02yAuZcQEwyXzmRdRdLIYR9bE1lhGJV/FBUL9aYBlJue1MDVq0XCpKRETUn74/Yu4KmzYoDAFeboLTOKdJyaEAgJ3cG0ZEREQ/0aTR43BxAwAWw5zVoqHm7rC1OZWCkxA5FhbDiPpQfZsOewrqAPxYnKH+kRrhi8RQb+gMJtuNKCIiIup7sizj+yPmHQaLh0cJTuO8Jg807w3LKmlAG3ekEhERkcX2vBoYTTKSw3wQG+QlOg71gXnpEQCAg8X1HJVI1A0shhH1IeuIxLQoPwwI8RYdx6VIkoSrLAXI1WwbJyIi6jeHixtQ1tAObzclZg0OFx3HacUHeyEm0BN6o4wDZ+tFxyEiIiI7scWyO33GYHaFOauoAE8Mjw2ALAPrT1SJjkPkMFgMI+pD1tm9CzkiUYgFll/37bkclUhERNRfrF1hc9Mj4KFWCk7jvCRJwuRkc3cYRyUSERERABhNMradMe8TnTGIxTBnNt/SHbY2hxfAibqKxTCiPlLX2oE9BeYHEws5IlGIQeG+SAr1hs5owqZTvClDRETU1/RGk21f6pLh0YLTOL9JA617w2oEJyEiIiJ7cKS0AY0aPfw8VBgZHyg6DvWh+enmZ437z9ajvk0nOA2RY2AxjKiPrDtRCZMMZET7Iz6YIxJFkCQJCy1LRdcc41JRIiKivrYrrxb1bTqE+LhhQlKw6DhOb9LAECgVEvKqW1FarxEdh4iIiATbfsZ8KXtycihUSj72dWZxwV5Ii/KD0SRj40k+8yLqCv6pSNRHOCLRPlxl+fXfcaYGzRyVSERE1KesXWELMyL5AKYf+Hupbbe+t+ZWC05DREREou2ydItbRymTc7OOSvwhh8Uwoq7gT6hEfaCmpQP7CusAcESiaCnhvhgY5mMelXiSoxKJiIj6is5gwoYT5h/EF/D8029mppr3gWw+xWIYERGRK2vW6nG0rAkAMInFMJcw33Lm3lNQiyYNL4ATXQ6LYUR9wDoicViMP2KDvETHcXnWgqS1W4+IiIh6397COjRrDQjxcceohCDRcVzGDEsxbG9hHTQ6g+A0REREJMq+gjoYTTISgr0QE8hnUa4gKdQHKeE+0BtlbDrFC+BEl8NiGFEfWHPsHACOSLQX1v8OO/Nq0dTOmzJERER9Ya1lROK89HAoFZLgNK5jYJgPYoM8oTOYsDu/TnQcIiIiEmRXvnlfGLvCXMu8dPMzr7XHOSqR6HJYDCPqZdUtWuw/Ww+AI4LsRUq4L1LCOSqRiIiorxiMJqy3jEicn87zT3+SJAkzU8MBAFtO85xDRETkqnblWYphA0MFJ6H+tCDDvDdsR14NWjs4JYDoUlgMI+pl645XQpaB4bEBbEu3I9bC5JocjkokIiLqbfvP1qNBo0eglxpjB3BEYn+b8ZO9YbIsC05DRERE/a28sR2FtW1QSMD4pGDRcagfDQr3RUKwF3QGE7bn1oiOQ2TXWAwj6mWrLXupruKIRLti3Ru2M6+GoxKJiIh62Q+WyyZz0yKgUvJHjP42NjEIXm5KVLd04MS5ZtFxiIiIqJ/tyjMXQYbFBsDfUy04DfUnSZIwe4h5SsDGkxyVSHQp/EmVqBdVN2txsMg8InE+RyTaleRwXwwK94XeKGMjRyUSERH1GqNJ/nFEIs8/QrirlJg00LwfZMvpasFpiIiIqL/ttIxInDyQ+8Jc0ewh5lGJW05XQ280CU5DZL9YDCPqRWtyKiDLQGZcAKIDPEXHoZ9ZaOnWW3PsnOAkREREzuNgUT1qW3Xw91RjAsfyCDNzsGVUIothRERELsVkkrGnoA4AMCmZ+8Jc0cj4QAR5u6FZa8DBs/Wi4xDZLRbDiHrRyqPmIsvVw6IEJ6HOLLCNSqxFk4ajEomIiHrDWsuIxNlDwqHmiERhpg8yF8OOljaipqVDcBoiIiLqL3nVrahv08FTrcTw2ADRcUgApUKy7ZDdwGlIRBfFn1aJeklpvQbZJY1QSD92IJF9GRjmg9QIXxhMMtZzjjIREdEVM5lkrLOMSFyQESE4jWsL8/PA0Bh/AMBWdocRERG5jP1nzV1hI+MD4abio15X9ePesCrIsiw4DZF94p+QRL3E2hU2LjEYYb4egtPQxSy0dIf9YLnFTkRERD13rLwJVc0d8HZTYiJ3VAg3M9X8EMS6w42IiIic3/5C81i8MQOCBCchkSYnh8BdpUB5YztOVbSIjkNkl1gMI+olqzgi0SEssHTt7cqrRaNGJzgNERGRY9to6bSeNigM7iql4DQ039KdtzOvFq0dBsFpiIiIqK/Jsoz9lh1RY1kMc2lebipMTjZfTtvIUYlEnWIxjKgXnKlqwenKFqiVEuanc0SiPUsK/XFU4oYTPBwQERFdCesP2taxLCRWcpgPEkO8oTOasIWjEomIiJxeYW0bals74KZSYBj3hbk865l80yk+7yLqDIthRL3A2hU2NSUU/l5qwWnocq6ydIet5qhEIiKiHiuua8OZqlYoFRKmDwoTHYcASJKEeenm7rB1x3nOISIicnYHLF1hw2MD4KFml76rm2EZmZ1T3oTqZq3gNET2h8Uwoisky7JtX9gijkh0CAsse8P25NeioY2jEomIiHrC2hU2JiGIl4HsiHVKwdbTNWjXGQWnISIior60v7AOADCOIxIJQKivO4bG+AMAtp2pEZyGyP6wGEZ0hY6VNaG4TgMPtQKzBnNEkCNIDPXBkEg/86jEk1wwT0RE1BMckWif0qP9EB3giXa9Edv5EISIiMhpnbcvLDFYcBqyF9aJDVs5MpvoAiyGEV0ha1fYrMHh8HZXCU5DXbXQOirxGEcIERERdVdDmw4Hi8wPX1gMsy8/HZW4/gQv/RARETmrsoZ2VDRpoVJIyIwLEB2H7MT0VHMxbGdeLfRGk+A0RPaFxTCiK2A0yVh9zFwMu5ojEh2KbVRiQR3qOSqRiIioW7acroZJBlIjfBEb5CU6Dv3MfEsxbNOpKugMfAhCRETkjPZZRiQOjfGHlxsvZ5PZ0Gh/BHu7obXDYLu8RkRmLIYRXYHd+bWoau5AgJcaUweFio5D3TAgxBtpUX4wmmRs4K1pIiKibrGOSJzDrjC7NCIuEGG+7mjRGrCDoxKJiIicEkckUmcUCsn2jHJbLs+BRD/FYhjRFfg2qwyAuSvMXaUUnIa6yzoqcU0ORyUSERF1lVZvxI488w/Ws1gMs0sKhYSrhpqnFnxvGelNREREzuWApRg2ZkCQ4CRkb6x7w7ZwbxjReVgMI+qhFq3etofh2hExgtNQTyz8yajEutYOwWmIiIgcw96COmh0RkT4eSAj2l90HLqIJZnmYtjGk5Vo7TAITkNERES9qaKpHSX1GigkYFR8oOg4ZGemJIdCqZCQX92K0nqN6DhEdoPFMKIeWptTCa3ehKRQbwyL4YMgRxQf7I2MaH8YTTJ+OM5RiURERF2xwTIicdaQMEiSJDgNXUxGtD8GhHhDqzdh40mec4iIiJyJtSssPdofvh5qwWnI3vh7qTEyzlwk3ZrL7jAiKxbDiHrIOiLx2hExfBDkwBYNM3eHreIIISIiossymWRsOmUuhs0eEiE4DV2KJElYPNzcHbYim+ccIiIiZ2LdFzYmgSMSqXPWvWE7ztQKTkJkP1gMI+qB0noN9p+thyQB146IFh2HroB1n8bBonpUNLULTkNERGTfjpY1oqalAz7uKoxL5MMXe3f1MPM5Z1d+LWo5EpqIiMhpZBU3AABGsRhGFzE5OQQAsK+wDnqjSXAaIvvAYhhRD3yXVQ4AmJgUgkh/T8Fp6EpEBXhidEIgZBlYc6xCdBwiIiK7ttEyInHqoFC4q5SC09DlJIb6YGiMeSQ0zzlERETOoVmrR25VCwBgRHyA2DBkt9Ki/BHgpUZrhwHHyhpFxyGyCyyGEXWTLMv4Lts6IpFdYc7Aemt6JUclEhERXZJtROLgcMFJqKsWDzefV5dnlwtOQkRERL3hSEkjZBmIC/JCmK+H6Dhkp5QKCROTzN1hO/M4KpEIYDGMqNsOFzeguE4DLzcl5qVzV4YzmJ8RCaVCwrGyJhTVtomOQ0REZJeK69pwpqoVSoWE6YPCRMehLlo0LBIqhYQjpY3IrWwRHYeIiIiu0GHLiMSR8YGCk5C9m2QZlbiLxTAiACyGEXXbV4dKAQDz0yPh5aYSnIZ6Q4iPOyYkBQMAVrE7jIiIqFPWEYljBwTB30stOA11VZivB2YONhcvPz9QIjgNERERXamsEnMxbASLYXQZkwaai2HZpY1o0eoFpyESj8Uwom5o0eqx6qh538JNY2IFp6HetMgyKnHVMRbDiIiIOrPBUgybPYQjEh3NzWPiAJhHJWr1RsFpiIiIqKeMJhnZJY0AgJFxLIbRpcUGeSE+2AtGk4z9hfWi4xAJx2IYUTesPHoO7XojBob5YBRv4DiVuWkRcFMqcKaqFacrm0XHISIisiv1bTocKjL/AM1imOOZnByK6ABPNLXrsfZ4heg4RERE1EO5lS1o7TDAx12FQRG+ouOQA7B2h+3K56hEIhbDiLrhiwPmEYk3jY6FJEmC01Bv8vdUY+qgUAAclUhERPRzW09XwyQDgyP9EBPoJToOdZNSIeEXo81TDT63nGeJiIjI8Ry2jEjMjAuAUsHnUnR5ky17w3bm1QhOQiQei2FEXXS8vAk55U1wUypw7YgY0XGoD1xtHZV4tAKyLAtOQ0REZD+s+8JmW3ZPkeO5YVQMFBJw4Gw9CmpaRcchIiKiHsgqtuwL44hE6qLxSSFQSEBBTRsqmtpFxyESisUwoi764qB54fictHAEebsJTkN9YebgMHiqlSip1+BoWZPoOERERHZBqzdih+Um6ewhEYLTUE9F+ntiRqq5mPnJvmLBaYiIiKgnDluKYSO5uoO6yN9TjaExAQCAnXkclUiujcUwoi7Q6Az4Pts8Os+6gJycj5ebyrYHZeURjkokIiICgD0FtdDojIj090B6tJ/oOHQFbhsXDwD4+lAZWrR6wWmIiIioO6pbtCip10CSgOFxAaLjkAOx7g3bzb1h5OJYDCPqgjXHKtDSYUBckBfGJwaLjkN9yDoqcfWxczCaOCqRiIjIOiJx1uBw7kx1cFNTQjEwzAetHQZ8dahMdBwiIiLqhuySRgBASpgv/DzUYsOQQ5mU/GMxzMRnXeTCWAwj6oIvDpoXjf9idCwUXFDq1CanhMDPQ4Xqlg4cOFsvOg4REZFQJpOMTaeqAcDWPU2OS5Ik3DkxAQDwwZ6zvPhDRETkQI6UNgIAMtkVRt00Ii4Qnmolalt1OFPdIjoOkTAshhFdxpmqFhwuboBSIeGGkTGi41Afc1cpMT89EgCw8ihHJRIRkWs7WtaImpYO+LirMI7d8U7h2swYBHipUVrfbuv6IyIiIvt3xNIZNjw2QGgOcjxuKgVGJZj3zO0rqBOchkgcFsOILuOLA+ausJmpYQjz8xCchvrDIsuoxLXHK6A3mgSnISIiEsdaLJk6KBRuKv7o4Aw83ZS4dax5B+77u84KTkNERERdYTTJOFbWCID7wqhnrBfb9hVyChK5Lv5ES3QJWr0R32Wb9yncPCZOcBrqL+OTghHi445GjR678rhclIiIXJe1GDaHIxKdyu3jEqBSSDhQVG8buURERET2K7+6FW06I7zclEgO8xUdhxyQrRh2to57w8hlsRhGdAnrT1SiUaNHlL8HpqSEio5D/USpkLAwIwIAsIqjEomIyEUV1bYhr7oVKoWEaYPCRMehXhTh74HFw6MBAG9syRechoiIiC7nSGkDACAj2h9K7rKnHhga4w8vNyUaNXrkVnFvGLkmFsOILsE6IvGGUbE8bLiYq4ebRyWuP1EJrd4oOA0REVH/23TK3BU2NjEI/p5qwWmot/12ehIkyfzf+eS5ZtFxiIiI6BKsndwckUg9pVYqMCohCACwr5B7w8g1sRhGdBFFtW3YW1gHSQJuHB0rOg71s8zYQEQHeKJNZ8TW09Wi4xAREfW7DZYRibMHc0SiM0oK9cHCjEgAwJtb2R1GRERkz46UNgEAMmMDxAYhhzYu0VwM21vAYhi5JhbDiC7ii4PmrrCpKaGIDvAUnIb6m0Ih4aph5gdEKzkqkYiIXEx9mw6HiszLtWdxX5jTun/GQADAD8crkF/NcTlERET2SKMzILfS3MU9PDZQcBpyZNa9YfvP1nNvGLkkFsOIOqE3mvDN4TIAwE2j4wSnIVEWDTWPStx8uhotWr3gNERERP1ny+lqmGRgcKQfYgK9RMehPpIa4Yc5Q8Ihy8BbWwtExyEiIqJO5JQ1wSQDEX4eiPD3EB2HHFhGtD+83ZRoatfjdCUvQpHrYTGMqBObT1WhtrUDIT7umDmYC+NdVVqUHxJDvaEzmLD5FEclEhGR69hkHZHIrjCnZ+0O+/7oORTXtQlOQ0RERD9n2xfGEYl0hX66N2wv94aRC2IxjKgTnx8wj0i8YVQM1Er+z8RVSZKEqyy7NFYfqxCchoiIqH9o9UbsyKsBwH1hrmBoTACmpoTCaJLZHUZERGSHbMWwuAChOcg5WEclcm8YuSI+5Sf6mbIGje0B0E2jYwWnIdEWWkYl7jhTg2aOSiQiIhewr7AOGp0R4X7uSI/2Ex2H+sGDM83dYd9mlaG0XiM4DREREf2UtRg2LCZAaA5yDmMTzZ1hh4u5N4xcD4thRD/z9aEyyDIwISkY8cHeouOQYCnhPhgY5gOd0YSNJ6pExyEiIupzW06bRwPPSA2HJEmC01B/GBkfhIkDg2EwyXhrG7vDiIiI7EVVsxYVTVooJGBojL/oOOQE0qP84a5SoEGjR2Ftq+g4RP2KxTCinzCaZHx9yDwi8RfsCiNYRiUONY9KXJPDUYlEROTcZFm27cmcxb2pLuWhmSkAgG8Ol6K8sV1wGiIiIgJ+7ApLCfeFt7tKbBhyCm4qhW3/3MGiBrFhiPoZi2FEP7E7vxbnmrTw81BhblqE6DhkJxZa9obtzKtBk4ajEomIyHmdrmxBeWM73FUKTEgKER2H+tGYAUGYkBQMvVHGW1vzRcchIiIi/GRfmKV4QdQbxgwwj0o8WFQvOAlR/2IxjOgnvrR0hS3JjIaHWik4DdmL5HBfDAr3hd4oY8PJStFxiIiI+szmU+aRwJMGhsDTjWchV/PQzGQAwFeHSnGO3WFERETCHSlpBMBiGPWuUQnmYtghdoaRi2ExjMiioU1n2wl14yiOSKTzLeSoRCIicgGbLCMSZw4OF5yERBibGIxxiUHm7rBt7A4jIiISyWiScaysEQAwPC5AaBZyLiPiAqCQgJJ6DaqataLjEPUbFsOILJZnl0NnNCEtyg/p0VxKSuezFsN25dWiUaMTnIaIiKj31bR04KjlgctM7gtzWdbdYV8dLENFE7vDiIiIRMmvbkWbzggvNyWSw3xFxyEn4uuhRmqEHwB2h5FrYTGMCOZl8V9ZRiT+YjS7wuhCSaE+GBzpB4NJxgZLByEREZEz2ZpbDVkGMqL9Ee7nIToOCTI+KRhjBwRBZzTh7W0FouMQERG5rKOWfWEZ0f5QKiSxYcjpjE4IBMC9YeRaWAwjApBT3oTTlS1wUymweFi06Dhkp66ydIet5qhEIiJyQtZ9YTNS2RXm6h6aZd4d9sWBUlQ2cXQOERGRCNmWYhhHJFJfsO0NK2YxjFwHi2FEAL48aO4Km5cWAX8vteA0ZK8WZJiLYbvza1HfxlGJRETkPLR6I3bm1QIAZnFfmMsbnxiMMQnm7rB/b2d3GBERkQhHLMWwzNgAoTnIOY2ydIadPNeM1g6D4DRE/YPFMHJ5Wr0RK4+cA8ARiXRpA0K8kRblB6NJxvoTlaLjEBER9Zp9hXXQ6IwI93NHerSf6DgkmCRJtu6wzw6UcLE6ERFRP9PoDMitbAYADI8NFJyGnFGkvydiAj1hkoHsEu4NI9fAYhi5vE2nqtDSYUB0gCfGJwaLjkN2bqFlVOIPHJVIREROZPOpagDAjNRwSBJ3UhAwISkYo+IDoTNwdxgREVF/yylrgkkGIvw8EOHPXa7UN0ZbRiUeLGIxjFwDi2Hk8lZklwMAlmRGQcGFpHQZC9LNxbC9BXVo1HBUIhEROT5Zlm37wmYN5r4wMpMkCQ/PSgEAfH6gBNXsDiMiIuo31hGJwzkikfqQdVTioSLuDSPXwGIYubT6Nh225dYAAJYMjxachhxBQog3UiN8YTDJ2GS5RU9EROTITlW04FyTFu4qBSYkhYiOQ3Zk4sBgjIwPRIfBhH9vLxQdh4iIyGUcLWsEAAyPCxCag5ybtTMsu6QReqNJcBqivsdiGLm0NTkVMJhkpEX5ITncV3QcchDz0iMAAOuOc1QiERE5vi2nzV1hkwaGwNNNKTgN2RNJkvDQTOvusGI0tLErnoiIqD8cKWkEwM4w6lsDQ33g76lGu96Ik+eaRcch6nMshpFLs45IvCaTXWHUdfMtoxJ35NWitcMgOA0REdGVsXY6zxwcLjgJ2aPJySFIi/KDVm/CZwdKRMchIiJyetXNWpxr0kIhARnR/qLjkBNTKCSMjLeMSizm3jByfiyGkcsqqdPgcHEDFBKwaFiU6DjkQFLCfZAY4g2dwYStpzkqkYiIHFdta4dtDM9M7gujTkiShF9NGgAA+GhvEXQGjtAhIiLqS9mWfWEp4b7wdleJDUNOz1oMyyphMYycH4th5LK+P2LuCpuQFIJwPw/BaciRSJKEubZRiZWC0xAREfXczrwayDIwJNKP5yG6qKuGRiHU1x1VzR1YyzHRREREfeqIpRjGEYnUHzIte+my2RlGLoDFMHJJsixjuaUYtoQjEqkH5luKYVtzq6HVGwWnISIi6pntuTUAgKmDQgUnIXvmplJg6bh4AMB/d52FLMuCExERETkv7guj/jQsJgAKCTjXpEVFU7voOER9isUwcknHy5tRWNMGD7UCc9O4H4O6LyPaH9EBntDojNh+pkZ0HCIiom4zmWTsyKsFAExNYTGMLu3WcfFwVylwrKwJh3lzmIiIqE8YTTKOWUZYD7d07BD1JW93FQZH+gEAsoobxYYh6mMshpFLWp5t7gqbNTgcvh5qwWnIEUmShLlp5u6w9RyVSEREDujEuWbUt+ng467CiLhA0XHIzgV5u+HaEeaJCv/bUyQ2DBERkZPKr25Fm84IbzclksN8RcchF2H9WYB7w8jZsRhGLsdkkrEm5xwAYPFwjkiknpufYS6GbTxVxWXyRETkcLafqQYAjE8KhpuKPxbQ5S0dnwAA2HCiErWtHWLDEBEROaEjpeZiREaMP5QKSXAachUj4gMAsBhGzo8/9ZLLySppQFVzB3zdVZiSEiI6DjmwEXGBCPFxR4vWgD0FtaLjEBERdYt1zC9HJFJXDY70w/DYAOiNMr45XCY6DhERkdM5UtoEABgey6596j8j44IAAMfLm6DVGwWnIeo7LIaRy1mTUwEAmD0kHO4qpeA05MiUCsm2c279CY5KJCIix9Gs1SPLspydxTDqjlvGxgEAPj9QApNJFpyGiIjIuRwpbQQADI8NEJqDXEtskCdCfNygN8o4ca5JdByiPsNiGLkUk0nG2hxz0WJBRqTgNOQM5qebfx9tOFEFIx8IERGRg9iTXwujSUZiiDdig7xExyEHctXQSPi6q1Bcp8HewjrRcYiIiJyGRmdAbmUzACAzLkBsGHIpkiQh07o3rLhRbBiiPsRiGLmU7NIGVDZr4euuwmSOSKReMDYxCP6eatS16XDgbL3oOERERF2y/Yx5vO8UdoVRN3m5qbAk07x397MDJYLTEBEROY+csiaYZCDS3wPhfh6i45CLGWEthnFvGDkxFsPIpaw5Zu4Km8URidRL1EoFZg8xj0pcd7xCcBoiIqLLk2UZO7gvjK7AzWPMoxI3nKhEbWuH4DRERETOgSMSSaSR8eZi2OHiBsgyJx+Rc2IxjFyGySTjB8u+MI5IpN40Pz0CALDuRCV3ZxARkd0rqGlFeWM73FQKjE0MEh2HHNCQKD8Mjw2A3ihjRXa56DhEREROwVoMG8ZiGAkwNMYfKoWE6pYOlDe2i45D1CdYDCOXcd6IxGSOSKTeM3FgCHzcVahq7sDRskbRcYiIiC7JOiJx7IAgeLmpBKchR3XdyBgAwHdZLIYRERH1BnaGkUgeaiWGRPkBALJKGsWGIeojLIaRy1h/ogoAMHNwGDzUHJFIvcdDrcT01DAAwLrjlYLTEBERXdp2y4jEKckckUg9d1VGJNRKCScrmpFb2SI6DhERkUOrataiokkLhQRkRPuLjkMuyrY3rJh7w8g5sRhGLkGWZaw/YS5SzE2LEJyGnNG8tB9HJXK2MhER2Sut3oj9hXUAgKmDWAyjngv0dsP0QebLQN9llwlOQ0RE5NiyLZ04KeG+8HZn5z6JMcKyNyyrhMUwck4shpFLyKtuRXGdBm4qBaZwUTz1gWmDQuGuUqC4ToPTvB1NRER2av/ZenQYTIj090BymI/oOOTgrh0RDQD4PvscjNybSkRE1GPWEYmZcQFCc5BrG2H5/XfyXDPadUaxYYj6AIth5BI2WLrCJg8M4Q0b6hPe7ipboXUtRyUSEZGd2p7744hESZIEpyFHNz01DP6ealQ2a7G3oE50HCIiIod1pNTcicN9YSRSdIAnwnzdYTDJyClvEh2HqNexGEYuYcNJ876w2UPCBSchZ2YdlbiexTAiIrJT289UA+CIROod7iolrhoaCYCjEomIiHrKaJKRU2YuPAyPDRSchlyZJEm2vWHZHJVITojFMHJ6FU3tOFbWBEkCZg5mMYz6zqzB4VApJORWtaCwplV0HCIiovOUNWhQUNMGpULCxIEhouOQk7COSlx3vJLjdIiIiHogr7oFbTojvN2UGMgx1iTYiPgAANwbRs6JxTByepssXWEj4wIR6usuOA05M38vNcYnBQMA1p1gdxgREdmXHWdqAZjH7/h7qgWnIWcxIi4QMYGe0OiM2JpbLToOERGRwzlS0ggAGBoTAKWCY6xJrExLZ1hWSSNkmTthybmwGEZOzzoicU4au8Ko781L56hEIiKyTzvOmPeFTU3hiETqPZIkYaFlVOLqY+cEpyEiInI8R0obAQDD4wKE5iACgIxof6gUEmpaOlDW0C46DlGvYjGMnFpTu962zHv2kAjBacgVzB4SDkkCjpY1obyRhwYiIrIPeqMJu/PNnWEshlFvWzQ0CgCw5XQ12joMgtMQERE5FlsxLDZAaA4iAPBQK5EW5QeAoxLJ+bAYRk5tW241DCYZKeE+GBDiLToOuYAwXw+Mjg8CwO4wIiKyH9kljWjpMCDQS430aH/RccjJpEX5ISHYC1q9CZtPc1QiERFRV7V1GHCmqgUAkMliGNkJ66jEbMsITyJnwWIYObUNJywjEtkVRv1ormVUIveGERGRvbCOSJycHMpdFNTrzhuVeJSjEomIiLoqp7wJJhmI8vdAmJ+H6DhEAIAR8dZiGDvDyLmwGEZOS6s3YptliTf3hVF/mmv5/XawqB41LR2C0xAREQHbuS+M+thVllGJ287UoEWrF5yGiIjIMXBfGNkja5fiiXPN0OqNYsMQ9SIWw8hp7S2oQ5vOiAg/D2RwHBD1o5hALwyN8YcsA5tOVYmOQ0RELq62tQM55U0AgMkpIYLTkLNKjfBFUqg3dAYTNp7k+YeIiKgrjljG0HFfGNmTmEBPhPq6w2CSbT9HEDkDFsPIaW04aR5RNyctHJLEcUDUv+ammUclruXeMCIiEmxXXi0AYEikH8J8OX6H+oYkSbbusDXHKgSnISIisn+yLNs6w4bFBAjNQvRTkiRhhKVbMauYoxLJebAYRk7JaJJtN1K5L4xEmGfZG7YnvxZN7RwVRERE4lhHJE7hiETqY1dZ9obtyKtBk4bnHyIiokspb2xHZbMWKoWEoSyGkZ0ZEWfeG5bFvWHkRFgMI6d0pLQBta06+HqoMDYxSHQcckFJoT5ICfeBwSRjy2mOCiIiIjFMJhk787gvjPpHcrgvBoX7Qm+Usf4ku+OJiIgu5bCl4yYt2h+ebkrBaYjONyLeWgxrhCzLgtMQ9Q4Ww8gpbThhLj7MTA2DWsnf5iTGPOuoxBw+DCIiIjFOVjSjtlUHbzclRlp+oCXqS9busB9yOCqRiIjoUqzFsJFxPKOR/cmI9odKIaGmpQNlDe2i4xD1ClYJyOnIsoz1J6z7wjgikcSZaxmVuP1MDTQ6g+A0RETkiqwjEscnhcBNxaM/9b35GeZi2G6OiiYiIrqkQ0XmYtioBBbDyP54qJUYEuUHAMi27LYjcnT8iZicTn51K4rqNHBTKrgbg4QaEumHuCAvdBhM2J5bIzoOERG5IGsxbOognomofwwMM4+K1htlbD7FUdFERESdae0w4HRlMwCwe5/slm1vWDH3hpFzYDGMnM6Gk+YfuicODIaPu0pwGnJlkiRhnqU7bO1xjkokIqL+1azV235wnZrMYhj1n3np1lGJPP8QERF1JrukASYZiAn0RLifh+g4RJ3KjAsAYP79SuQMWAwjp7OBIxLJjsy1/D7ccroaHQaj4DRERORK9uTXwWCSMSDEG3HBXqLjkAtZkGE+/+zIq0FrB0dFExER/Zx1X9godoWRHbN2hp041wytns+0yPGxGEZOpaKpHUfLmiBJwMzBYaLjECEzNgDhfu5o7TBgT36d6DhERORCduRZRiRybDT1s0HhvkgM8YbOYMKW09Wi4xAREdkdazGMIxLJnsUEeiLU1x0Gk4yc8ibRcYiuGIth5FQ2WUYkjogLRJgv28xJPIVCsnWHrT1eITgNERG5ClmWbfsqWQyj/nbeqOgcnn+IiIh+ymiSkV3SCAAYGR8kNgzRJUiShMzYAADcG0bOgcUwcirWfWFzhoQLTkL0o3mWYtjGk1UwGE2C0xARkSsoqGlDeWM73JQKjE3kQxbqfwsyzHvDtuXWQKPjqEQiIiKr3MoWtHYY4OOuwqAIX9FxiC5phKV70VrAJXJkLIaR02hq12NvgXkMHfeFkT0ZMyAIgV5qNGj0OFBULzoOERG5gB1nzF1hYwYEwctNJTgNuaK0KD/EBHqiXW+0dSkSERERcLjY/FwgMy4ASoUkOA3RpVn3hmWVNECWZcFpiK4Mi2HkNLblVsNgkpEc5oMBId6i4xDZqJQKzLZ0K647Xik4DRERuYLtZzgikcSSJMnWHbaW5x8iIiKbQ9wXRg5kaIw/VAoJ1S0dKG9sFx2H6IqwGEZOwzoicTZHJJIdsu7NWH+iEiYTb9IQEVHf0eqN2H/W3C0/hcUwEsh6/tl8qgpavVFwGiIiIvtw2FIMG8V9YeQAPNRKDInyA/Dj710iR8ViGDmFDoMR205XA+CIRLJPEweGwMddharmDhwpaxQdh4iInNiBs/XQ6k2I8PNASriP6DjkwobHBCDS3wNtOiN25tWKjkNERCRcVbMWZQ3tUEjA8LgA0XGIusRauD1UxGIYOTYWw8gp7C2oQ5vOiHA/dwyN9hcdh+gC7iolZqSGAQDWc1QQERH1IeuIxCkpIZAk7qEgcRQKydYdtvZ4heA0RERE4lmLCakRfvBx515XcgyjE8wjPQ8W1QtOQnRlWAwjp2AdkThrcDgUXD5KdurHh0GVXDpKRER95sd9YWGCkxAB89PNe8M2nqyCzmASnIaIiEgsazFhVAL3hZHjGGn5/Zpb1YKmdr3gNEQ9x2IYOTyTScYm7gsjBzBtUCjcVQqU1GtwqqJFdBwiInJCpfUa5Fe3QqmQMCk5RHQcIoyMD0SorztatAbsKeCoRCIicm37Cs17XccOCBachKjrwnw9kBDsBVkGsko4KpEcF4th5PCOljWiuqUDPu4qjE/iYYLsl5ebClNTQgEA605wVCIREfW+bbnmHaoj4wPh76kWnIYIUCokzE0zX1hbm8PzDxERua5GjQ65VeaLsWMGBAlOQ9Q9oxLMv2cPnuWoRHJcLIaRw9to6QqbOigU7iql4DREl2YdlfhDTgVHJRIRUa/bmmsekTh9EEckkv1YYBmVuOFkJQxGjkokIiLXdOBsPWQZSAr1Rqivu+g4RN0yxlIMs+69I3JELIaRw7PuC5vDEYnkAGYNCYebUoH86lbbjTAiIqLeoNUbbWPopqeGCk5D9KMxA4IQ5O2GBo0e+3mbmIiIXNS+QvPfgWMTOdWIHI91z92RskZ0GIyC0xD1DIth5NAKa1qRX90KlULCNN6AJgfg56HGtEHmB5Srjp4TnIaIiJzJvsI6aPUmRPp7YFC4r+g4RDYqpcJ2ce2HnArBaYiIiMTYf9a8L2wci2HkgAaEeCPY2w06gwnHy5tExyHqERbDyKFZRySOTwrmXgxyGFcNiwIArD7GUYlERNR7tllGJE4bFAZJkgSnITrf/AzzqMT1J6pgNPH8Q0RErqWpXY+TFc0AgHHcF0YOSJIkW3fYQY5KJAfFYhg5NGsxbDZHJJIDmTU4DJ5qJYrrNMjhbRoiIuoFsixjy+lqAMD0QRyRSPZnfGIw/DxUqG3twKEijkokIiLXcqjIvC9sQIg3wvw8RMch6pHRtr1hPMuRY2IxjBxWTUsHDpeYbyLMGsxiGDkOLzcVZg42j/XkqEQiIuoNZ2vbUFKvgVopYeLAENFxiC7gplJg9pAIAMDa45WC0xAREfWvfYXmEYlj2RVGDsxaDDtY1AATO/3JAbEYRg5ry+kqyDKQEe2PqABP0XGIuuWqoeZRiWuOVfAAQUREV2yrZUTi2AHB8HZXCU5D1LkFGeZi2LrjlTz/EBGRS9l/1txJMzaRxTByXEOi/OCpVqKpXY/8mlbRcYi6jcUwcljWEYlzOCKRHNC0QaHwcVfhXJMWWSWctUxERFdmW655ROI0jkgkOzYpOQQ+7ipUNmuRXdooOg4REVG/aNHqcdyyImHsgGDBaYh6Tq1UIDMuAABwkKMSyQGxGEYOSaMzYGdeLQBgdhqLYeR4PNRKWyF39bEKwWmIiMiRtXUYsL/Q/MPo9NQwwWmILs5dpbSNil53nOcfIiJyDQfO1sMkA3FBXpxsRA5vlG1vGC92k+NhMYwc0o4ztegwmBAX5IVB4b6i4xD1yKJh5lGJq49VwMhRQURE1EO782uhM5rPRYkh3qLjEF3S/HTzqMQfciohyzz/EBGR87Ne5p6UzL2u5PhGJwQCMBd5iRwNi2HkkDacNC/dnj0kHJIkCU5D1DMTB4YgwEuN2tYO7Lcs0yUiIuou6+joGalhPBeR3ZuaEgZPtRLlje3IsYyMIiIicma78y3FsIEshpHjGxEXCJVCQnljO0rrNaLjEHULi2HkcPRGEzafMu/FmM19YeTA3FQKzEsz345exVGJRETUAwajCZtOWfaocnQ0OQBPNyVmWMZ5rj1eKTgNERFR36ps0iKvuhWSBExI4r4wcnze7ioMiw0AAOwt4MVuciwshpHD2VtQh6Z2PUJ83DDaMqeWyFFZRyWuPV4BvdEkOA0RETmaw8UNaNDo4e+pxhiei8hBzLOMSlybU8FRiURE5NSsXWEZ0f4I8HITnIaod4xPNBd29xTUCk5C1D0shpHDsd4gnZMWAaWCo4DIsY0dEIQQHzc0avTYlc9DBBERdY91ROLMwWFQKXm0J8cwPTUM7ioFiuo0OFXRIjoOERFRn9nFEYnkhMZbuhz3FtbxYhM5FP7ETA7FaJKx4YS5GGZdvk3kyFRKBRZkRAIAVh/lqEQiIuo6WZaxwVIMm8PR0eRAfNxVmJISCgBYd5znHyIick6yLLMYRk5pZHwg3JQKVDV34Gxtm+g4RF3GYhg5lANn61HXpkOAlxrjEjlrmZyDdVTihhOV0OqNgtMQEZGjyK1qQUm9Bu4qha2wQOQoFmSYL7b9wL1hRETkpM5UtaKmpQMeagVGxAeKjkPUazzUSmTGBQAwd4cROQoWw8ihWG+Ozh4cDjVHAZGTGBkXiEh/D7R0GLD1dLXoOERE5CA2njB3hU1ODoGXm0pwGqLumTk4HGqlhPzqVuRVcVQiERE5H2tX2OiEIHiolYLTEPUu26jEAhbDyHGwmkAOw2SSbfvC5mdwRCI5D4VCwtXDzd1h32WXC05DRESO4scRiTwXkePx81BjcrK5o3HV0XOC0xAREfW+XXk1AMwXl4iczXjLxK593BtGDoTFMHIY2aUNqG7pgK+7ChM5a5mczLWZMQCAbbnVaGjTCU5DRET2rrReg5zyJigkYMbgMNFxiHpkseUy0Ioj5/gQhYiInIpWb8S+wnoAwKSBHGdNzmd4XADcVQrUtuqQV90qOg5Rl7AYRg5jbY65K2zm4DC4q9heTs5lUIQvhkT6QW+UsTqHi+SJiOjSVlo6acYnBSPEx11wGqKemT0kHF5uSpTUa5BV0ig6DhERUa/Zf7Ye7Xojwv3cMTjSV3Qcol7nrlJiVIJ5Fx5HJZKjYDGMHIIs/zgicV56pOA0RH3j2hHRAIDlWWWCkxARkb1becRcDLt6WJTgJEQ95+Wmwrw085jPFRwVTURETsS6D3z6oDBIkiQ4DVHfmJBkntxl3Y9HZO9YDCOHkFPehPLGdniqlZiawvZyck5XD4uCQgKyShpRVNsmOg4REdmp3MoW5Fa1QK2UMC+Nl4TIsS3JNF8GWn3sHPRGk+A0REREvWNbrrkYNm0Qx1mT85pi2f+6J78WOgPPcWT/WAwjh2DtCpuRGgZPN45IJOcU5udh24e3nLejiYjoIlYeNf8dMTUlDP5easFpiK7MBMuozwaNHjvO1IiOQ0REdMXO1rahqE4DtVLCpGTuvCfnlRblh2BvN7TpjMgqaRAdh+iyWAwjuyfLMtZadijNS48QnIaob1lHJa44Us5F8kREdAFZlrHqqPlcdPVwjkgkx6dSKmzjPnkZiIiInMEWy4jEMQOC4OOuEpyGqO8oFBKmWCZ4beelJnIALIaR3Ttd2YKiOg3cVApMT3Xe9vJ9+/Zh8eLFCAkJgYeHB1JSUvD0009Do9F0+XPMmjULkiRBkiRUVlZe8H6tVov77rsPISEh8Pb2xtVXX43i4uJOP1dTUxMiIiJw8803d/t7KSoqgiRJSEhIuOTrfvnLX0KSJHzwwQedvt36j0KhgL+/PxISErBo0SK88MILqKqq6vbndQRz0yLg5aZEcR0XyRMR0YWOlDaipF4DT7USswbb97mIZ5sL3+6KZ5uuuMYyKnHjySo0a/WC0xAREV0Z64jE6U4yIpFnugvfzjPdj6akmLsft+eyGEb2j8Uwsnurj5kXxE9NCXXaGzWffvopJk2ahJUrVyIhIQELFiyAVqvFc889hwkTJqClpeWyn+ODDz7A5s2bL7mY9aGHHsJbb72F+Ph4TJ48GatXr8aCBQtgNBoveO0f//hHtLW14cUXX7yi7+1KTJw4EXfccQeWLl2KOXPmICYmBps3b8YTTzyBuLg4/POf/3S67ikvNxXmWhbJL88uE5yGiIjszcqj5nPR7CHh8HKz33MRzzadc8WzTVekR/shJdwHHQYTVll+jxMRETmitg4D9hfWA4BTXOjmma5zPNP9aLJlb9jJimZUt2gFpyG6NBbDyK6dNwpomHOOAiorK8Pdd98No9GI999/H4cOHcJ3332HvLw83HDDDTh69Cgef/zxS36OmpoaPPbYY5gzZw7i4uI6fU1FRQXef/99zJ8/H4cOHcK6devw17/+FSdPnsTy5cvPe+3x48fx1ltv4ZlnnkF0dHSvfa/ddffdd+ODDz7ABx98gK+//hq7du1CXV0d/vWvf0GlUuHJJ5/EU089JSxfX7nGtki+ggtIiYjIpsNgxArLGLklmfZ7LuLZ5uJc9WxzOZIk4cZRsQCArw6WCk5DRETUc7vza6EzmhAX5IXEEG/Rca4Iz3QXxzPdj0J83JER7Q8A2HmmVnAaoktjMYzs2rGyJtsooJl2Pgqopz744ANotVrMnj0bd955p+3t7u7uePPNN+Hl5YX//ve/qKuru+jnePjhh9HW1oa33nrroq85fvw4DAYDli5daruNc9dddwEAjhw5ct5r77//fiQlJeGRRx65gu+sb3h6euKBBx7AmjVroFQq8fzzz+Po0aOiY/WqiQNDEObrjkaN3jZegYiIaP2JKjRo9Ijw88AUyw1Me8SzTfe4wtmmK67JjIZKIeFoWRNOVzaLjkNERNQjm09ZRySGXrITyhHwTNc9rnyms45K3JHHUYlk31gMI7tmHZMyy85HAV2Jw4cPAwCmTZt2wftCQ0MxZMgQ6PV6/PDDD51+/Pr16/HZZ5/hqaeeQlJS0kW/TkNDAwAgMDDQ9jbrv9fX19ve9tlnn2H79u14/fXXoVaru/399Jdp06bZ5kO//vrrgtP0LqVCwuLh5hv/32ZxVCIREZl9caAEAHDj6FiolPZ7jOfZpmec+WzTFcE+7pg1OBwA8NVBnn+IiMjxGIwmbDxl3hdlXX/gyHim6xlXPNNNTTE3MOw4UwOjyTXGQ5Jjst+fosnlmUwyVh8zj0hcNDRScJq+09bWBuD8v/R/KigoCAA6vU2i0Whw7733IjU19bKt6dZ29Ly8PNvbzpw5AwCIj48HALS2tuL3v/89rrvuOsyePbub30n/u+mmmwAAW7duFZyk910/0jwqaPOpatS0dAhOQ0REohXVtmFPQR0kCbhxVIzoOJfEs03POfPZpit+Mdp8/lmeXYYOw4U7QoiIiOzZoeIG1LfpEOClxpgBQaLjXDGe6XrO1c50mXEB8HVXoUGjR055k+g4RBfFYhjZrUPFDahs1sLXQ4Wpg+x3FNCVCg01f2/FxcWdvt/69qKiogve98wzz6CoqAhvv/023NzcLvl1hg8fjsjISLz88ss4fvw4qqqq8Pjjj0OSJMyfPx8A8Oyzz6KxsREvv/zyFXxH/Wf48OEAgMLCQuh0OrFhetmgCF8Miw2AwSTb9sMQEZHr+sKyR2lKcihiAr0Ep7k0nm16zpnPNl0xOTkE4X7uaNDobWOmiIiIHMW645UAgFmDw+26i7+reKbrOVc706mVCky2jErcbOmOJLJHjv8nMzkt64jEuWkRcFcpBafpO1OnTgUAfP755xf8Bblv3z7k5uYCAFpaWs57X1ZWFl577TXccccdnbas/5yHhweWLVuGoqIiZGRkICIiAuvXr8e9996LoUOHIjc3F6+++ir+7//+77ylpu3t7ZDlnrU4FxcXQ5Kki/7z4Ycf9ujzWoWEhNj+3dpW70ysN/+/PFTa4/8GRETk+PRGE745bB4bd/OYWMFpLo9nm55z9rPN5aiUClw/0nz++dwyFpSIiMgRyLKM9SfMxbB5TjAiEeCZ7kq44plu9hDzuOsNJ1gMI/vlnEuYyOEZjCb8kGMZkTgsSnCavnXrrbfiueeeQ0lJCRYvXowXX3wRcXFx2L17N+655x6oVCoYDAYoFD/Wro1GI+655x4EBATgxRdf7NbXSkxMxNdffw2tVosZM2bguuuuAwA88MADiIuLw2OPPQYA+OKLL/Dkk0+iuLgY/v7+uP/++/Hss8+el+NyvL29cf3111/0/bt27UJBQUGXP9/P/fTQ4+iLaTuzaFgU/rr6JPKrW5FV0oiR8Z2PJiAiIue28WQVals7EOLjjpmWnUr2jGcbnm2uxE2j4/DWtgLszKtFUW0bEkK8RUciIiK6rGNlTaho0sLLTYlJySGX/wAHwDMdz3TdMX1QGJQKCblVLSip0yAu2L6nWZBrYjGM7NLewjrUtekQ5O2GCUnBouP0KW9vb6xevRpXXXUV1q1bh3Xr1tneFxcXh0cffRQvvPDCeTOaX331VWRlZeG///3vebdNumL8+PEYP378eW/79ttvsXHjRqxevRru7u44fPgwbrnlFsydOxevvfYatm/fjueeew5hYWF48MEHu/y1QkJC8MEHH1z0/b/85S+v6HBRW1tr+/eLzbB2ZH4eaizIiMR3WeX4+lApi2FERC7qvZ2FAICbRsdC7QAjd3i24dnmSsQGeWFaSii25tbg0/3FeGrhENGRiIiILmudpStsemoYPNTOMd2IZzqe6bojwMsNYxKCsLewDhtOVuLuyYmiIxFdgMUwskvWEYnz0yMc4qHPlcrIyMDp06fx9ddf49ChQzAYDBg2bBhuueUW/O1vfwMApKWl2V6/atUqW9v2Rx99dN7nqqw0H8CuvfZauLm54W9/+xsmTZp00a/d3t6O3/3ud1i0aBEWLlwIAHjppZfg4+ODr776Cr6+vli8eDGysrKwbNmybh0u+tqRI0cAAMnJyVCr1WLD9JEbR8Xiu6xyrDp6Ds9cNQTe7vxjm4jIlRwubkBWSSPclAosnRAvOk6X8WzTM65wtumK28fHY2tuDb46VIbfzRnkNA8ViYjIOcmybNsX5iwjEq14pusZVz3TzR4Sjr2Fddh4sorFMLJLfKpKdkerN2Kt5RBx1VDnHpH4U56enli6dCmWLl163ts3bdoEABfMWZZlGTt27Ljo59u7dy+A82+jdObvf/87qqqq8Oqrr9redvr0aaSmpsLX19f2tjFjxmD79u1obm6Gn59fV76lPvfFF18AAKZPny44Sd8ZOyAICcFeKKrTYE1OBW4cZf+7YoiIqPdYu8IWD49CmK+H4DTdw7NN97nC2aYrpqaEISbQE2UN7Vh19Bxu4PmHiIjsWF51K87WtsFNqcD01DDRcXodz3Td56pnutlDwvHs6pM4WFSPhjYdAr3dREciOo/zt9yQw9l6uhotWgMi/T0wdkCQ6DhCbd++HVlZWUhLS8PEiRNtb9+2bRtkWe70n/h4863xiooKyLKMJUuWXPTzFxQUYNmyZXj88ceRmHj+jQ2NRnPe/9/W1gbAfmYdb9u2DV988QUkScIDDzwgOk6fkSTJ9gDo60OlgtMQEVF/OlvbZlvEfs8U57hZybPNxbnK2aYrlAoJt441/3f/ZF+x4DRERESXZu0Km5wcAh8XmebCM93FufKZLjbIC6kRvjDJwJbT1aLjEF2AxTCyO8uzywEAi4dHQ6Gwj7/I+tqRI0dgMBjOe1tWVhZuueUWSJKE119/vU++7kMPPYTIyEg8+eST5709LS0NJ0+eRHZ2NgCgpaUFq1atQlxc3Hm3b0TQarV44403sHDhQhiNRjzzzDNIT08XmqmvXT8yBgoJOFjUgIKaVtFxiIion/xrcx5MMjAjNQwp4WL//u0unm26zhXPNl1x46gYuCkVOFrWhKOljaLjEBERXZS1GDY33blGJAI803UHz3Rmc4aEAwA2nqwSnIToQq5xXYEcRkObDltzzTcHrsmMFpym/zz88MM4efIkhg8fjpCQEBQVFWH//v1QKBR45513+qStes2aNVizZg2WL18OT0/P8973+9//Hp999hmmT5+OGTNmIDs7G6Wlpfj3v//d6zku5b333sO2bdsAmG/+VFZW4vDhw9BoNHB3d8cLL7yAxx57rF8ziRDu54Fpg8Kw5XQ1vjpUij/MHyw6EhER9bH86hZ8f8R8QeiRWSmC03Qfzzad49mm64J93LFwaCSWZ5fj/d1n8dpNmaIjERERXaCotg0nK5qhVEiYNThcdJxexzNd53imu7g5aRH415Z8bD9TA43OAC83lh/IfvB3I9mVNTkV0BtlDIn0w6AIx7oBfSVuu+02fPLJJzhy5AgaGxsRGhqKm266Cb///e8xfPjwXv96HR0deOihhzB37txO29KHDh2KFStW4Omnn8bq1asRERGBf/zjH/jNb37T61kuZffu3di9ezckSYKPjw+CgoIwffp0TJ06FXfccQfCwpxvFvfF3DgqFltOV+Pbw+V4bM4gqJVs7CUicmavbjJ3hc0ZEo6MGH/RcbqNZ5vO8WzTPb+aNADLs8ux5lgFnpiXiqgAz8t/EBERUT/6/sg5AMDEgSEIcsL9SDzTdY5nuotLi/JDXJAXSuo12HyqGouGRYmORGQjybIsiw5BZHX923twqLgBTy0Y7DS7MYh6g95owvjnN6O2VYd/3zYC89IjRUciIqI+crqyGfNe3QkAWPvQZAyOtI9F4EQi3PSfvdhXWI/fTE1kdzwREdkVWZYx86XtKKxtw8s3DsO1I2JERyKyC8vWn8abWwswe0g43l06SnQcIhu2FpDdKKnT4FBxAxQScPVw3hog+im1UoEbR8UCAD7dXyI4DRER9aVXNp4BACzMiGQhjFze3ZPMF+Q+21+Ctg7DZV5NRETUf3LKm1BY2wYPtQJz0pxvXxhRT1m7wbbn1qCpXS84DdGPWAwju7HCshdj4sAQhPt5CE5DZH9uHhMHSQJ25tXibG2b6DhERNQH9hXWYf2JKigk4KFZyaLjEAk3IzUMiSHeaNEa8NWhUtFxiIiIbFZkm0ckzh4SAR93bqIhskqN8ENKuA90RhM2nKgUHYfIhsUwsguyLGNFtrkYtmR4tOA0RPYpNsgL01JCAQCfH2B3GBGRszGaZPxl1UkAwC1j45AS7jr7U4kuRqGQcNekAQCA93efhdHEKf9ERCSe0SRj1TFzMWwJpxsRXWDRUPP/LlYePSc4CdGPWAwju3C0zNxa7qlWYl46W8uJLubWsfEAgK8PlUKrNwpOQ0REvenLg6U4VdEMPw8VHp09SHQcIrtx3YgYBHipUVrfjo0nebuYiIjE21NQi5qWDgR6qTHFcmmViH50lWVU4p6COtS2dghOQ2TGYhjZhW8PlwEA5qSFw5ut5UQXNT01DFH+HmjQ6LH2eIXoOERE1EuqW7T457rTAICHZqUgyNtNcCIi++HppsRtlgtB7+48KzgNERHRjyMSFw6NhFrJx6tEPzcgxBsZ0f4wmmSszeHzK7IP/NOahNPqjfjesi/s+pExgtMQ2TelQsLNY+IAAJ/u46hEIiJn8ZdVJ9HUrkd6tB/uGB8vOg6R3Vk6Ph5uSgUOFzfgwNl60XGIiMiFteuMWG/Zg8RVH0QXd7WlO+w7y2ocItFYDCPhNp6sQrPWgCh/D0xIChEdh8ju/WJ0LFQKCYeKG3C6sll0HCIiukIbT1ZhzbEKKBUS/nHtUKh4u5joAmF+Hrh+lPni3Btb8wWnISIiV7bpVBVaOwyICfTEyPhA0XGI7NbizCgoFRKySxqRV9UiOg4Ri2Ek3teWEYnXjYyBUiEJTkNk/8L8PDAnLRwA8Mm+YsFpiIjoSrRo9XhmxXEAwN2TByA92l9wIiL7de+UJCgVEnacqUFOWZPoOERE5KKWW7pclgyPhiTxORbRxYT5emD6oDAAPz7/JRKJxTASqqKpHTvzagBwRCJRd1j3ZnyXVY5mrV5wGiIi6qk/rzyJymYt4oK88PDMFNFxiOxaXLCXbdzOm+wOIyIiASqbtNiWWw0AuHYERyQSXc6Nls7+77LKoTeaBKchV8diGAn1XVY5ZBkYkxCE+GBv0XGIHMb4pGCkhPtAozPi60O8XUNE5IjWHKvAt1llUEjAizcMg6ebUnQkIrv322lJAIB1Jyo5boeIiPrdt1llMFmeYyWG+oiOQ2T3pqeGIcTHDbWtHdiWWyM6Drk4FsNIGFmW8fWhUgCwzf8noq6RJAm/nDAAAPDhniIYTbLgRERE1B0VTe34v+U5AID/Ny0JYwYECU5E5BiSw30x1zIu+u1tBYLTEBGRKzGZZHx50Pwc6xejYwWnIXIMaqUC144wP/f9yvIcmEgUFsNImEPFDSiq08DLTYmFGZGi4xA5nCWZUfD3VKOkXmMb00BERPbPaJLx6JdH0dSux9AYfzw8i+MRibrj/unJAIDvj55DSZ1GcBoiInIV+wrrUFKvga+7Cgv4HIuoy26wrMbZcroa1S1awWnIlbEYRsJ8YxnttiAjEt7uKsFpiByPl5sKN1luo32wp0hsGCIi6rI3t+Zjb2EdPNVKvPqL4VAreSQn6o6MGH9MSQmF0STjnR3sDiMiov7xhaUr7OrhURxvTdQNyeG+GB4bAKNJ5qoPEoo/eZMQbR0GrD52DsCPtwOIqPtuGxcPhQTszKvl3gwiIgewt6AOr246AwD465J07pog6qH7LLvDvj5Uhqpm3jAmIqK+1ajRYd2JSgDATaPjBKchcjy3j4sHAHyyrxgGo0lwGnJVLIaREN8fOYc2nREDQry5I4PoCsQGeWH2EPPejA/3FokNQ0REl1Tb2oGHvsiGSQauHxmD63khiKjHxiYGY3RCIHRGE/69nd1hRETUt1Zkl0NnMGFIpB/So/1ExyFyOFcNi0SIjxsqmrTYcLJKdBxyUSyGUb+TZRmf7i8GANwyJg6SJAlOROTYfjlhAADg28PlaGrXC05DRESdMZlkPPLlEVS3dCA5zAfPLk4THYnI4T0407w77NP9JewOIyKiPiPLsm1E4i9Gx/I5FlEPuKuUuHmMuavyg91FYsOQy2IxjPrdsbImnDjXDDeVAtfxRjTRFRuXGITUCF+06434+lCp6DhERNSJt7cXYGdeLTzUCrx56wh4uXFfKtGVmjQwxNwdZjDhra35ouMQEZGTOlrWhNOVLXBTKbBkeLToOEQO69ax8VApJBwoqsfJc82i45ALYjGM+p21K2xhRiSCvN0EpyFyfJIk4ZcTEgCYRyUaTbLYQEREdJ4DZ+vx0oZcAMCzi9OREu4rOBGRc5AkCY/MSgEAfH6gFBVN7YITERGRM/p474/Psfy91ILTEDmuCH8PzE2PAAB8uKdIbBhySSyGUb9qatdj5dFzAIBbx3LhKFFvWTw8GgFeapTWt2PL6WrRcYiIyKK+TYcHPzfvCbs2Mxo3sCueqFeNTwrG2AFB0BlNeJPdYURE1Mvq23RYdcz8HOv28fGC0xA5vjstl7lXHClHbWuH2DDkclgMo361IrscWr0JKeE+GBkfKDoOkdPwdFPiptGW2ct7zgpOQ0REgHm/xOPfHEVlsxZJod7465J07pgg6mWSJOGR2ebusC8PlqK8kd1hRETUe748WAqdwYT0aD9kxgaIjkPk8EbGB2J4bAA6DCa8v4vPr6h/sRhG/UaWZduIxFvHxvNhEFEvu318PBQSsDu/jrOXiYjswCf7irHpVDXclAq8fvMIeLtzTxhRXxiXGIwJScHQG2W8sYXdYURE1DuMJhmf7DM/x1o6LoHPsYh6gSRJuG/6QADmEaRN7XrBiciVsBhG/eZQcQPOVLXCU63ENSO4cJSot0UHeGJBRiQA4N2dhYLTEBG5tjNVLfjbmlMAgCfnp2JIlJ/gRETOzdod9vWhUpTWawSnISIiZ7D1dDXKG9vh76nGomFRouMQOY2ZqWEYFO6Llg4DPt5bJDoOuRAWw6jffGq5TXP1sCj4eXDhKFFf+M2UJADAyqPnUNbAB0FERCJo9UY8+Hk2OgwmTE0JxZ0TE0RHInJ6oxOCMDk5BAaTjNe35ImOQ0RETuAjy3OsX4yOhaebUnAaIuehUEj47XTz86v3dxdBozMITkSugsUw6hf1bTr8kFMJALhlbJzgNETOKyPGHxOSgmE0yXh/V5HoOERELumf607jdGULQnzc8OINwzhSh6ifPDzL3B32bVY5CmtaBachIiJHll/dgh1naiBJwK18jkXU6xZmRCIuyAv1bTp8caBUdBxyESyGUb/4+lApdEbzwtGhMf6i4xA5td9MNd+u+eJgCZo0nL1MRNSf9hXW4X+7iwAAy64fhlBfd7GBiFzIyPhAzEgNg9Ek4+WNZ0THISIiB/bezrMAgNmDwxEf7C04DZHzUSkVuNfy/Oo/OwqhM5gEJyJXwGIY9TmD0YSP9ppby28fF8/b0UR9bEpyCFIjfKHRGfHJ/mLRcYiIXEa7zognvz0GALh5TCymp4YJTkTkeh6bMwgAsPpYBY6XNwlOQ0REjqimpQPfZZUDAH49JVFwGiLndd3IaIT7uaOyWYtvs8pExyEXwGIY9bmNJ6tQ3tiOQC81Fg+PFh2HyOlJkoTfTDUf2P+3uwhavVFwIiIi1/DyxlwU1WkQ6e+BPywYLDoOkUsaEuWHq4dFAQBe3JArOA0RETmij/cWQWc0YXhsAEbGB4qOQ+S03FVK/HqKuTvs9c15fH5FfY7FMOpz7+82t5bfOjYeHmouHCXqD1cNjUKUvwdqWzuwPLtcdBwiIqeXXdKA/+4yn3n+fk0G/DzUghMRua5HZ6dApZCwLbcG+wvrRMchIiIH0q4z4uN95gkrv56SyOlGRH3s1rFxiPT3wLkmLT7Zx+lG1LdYDKM+lVPWhINFDVApJNw+Pl50HCKXoVYqcNekAQCAd3cUwmSSBSciInJeHQYjHv/mGEwycG1mNMcjEgmWEOKNX4yOBQC8sD4XssxzEBERdc03WWVo0OgRG+SJuWkRouMQOT0PtRIPz0oGALy5NR8tWr3gROTMWAyjPvU/S1fYwqGRCPfzEJyGyLXcNCYOvh4qFNa2YeOpKtFxiIic1ltbC5BX3YoQH3f8cdEQ0XGICMCDM5PhoVbgcHEDtpyuFh2HiIgcgMkk431Lp/9dEwdAqWBXGFF/uG5EDBJDvdGg0ePdnWdFxyEnxmIY9ZnqFi1WHTsHALhz4gDBaYhcj4+7CrePM3dk/mdHoeA0RETOqbiuDW9vLwAA/PnqIQjwchOciIgAINzPA3dMSAAALFufyy55IiK6rE2nqnC2tg1+HircOCpWdBwil6FSKvD7OYMAAO/tLERNS4fgROSsWAyjPvPJvhLojTJGxAVgeGyA6DhELumXExLgpjTfij5YVC86DhGRU5FlGX9eeQI6gwmTk0OwMCNSdCQi+on/NzUJvh4qnK5ssV3SIyIi6owsy3hzaz4A4NZx8fB2VwlORORa5qVHYFiMPzQ6o+1/i0S9jcUw6hNavRGf7TcvPWRXGJE4YX4euHZENADgjS08TBAR9aZNp6qxNbcGaqWEP1+dxgXrRHYmwMsNv5mSCAB4eeMZ6I0mwYmIiMhebTtTg6NlTfBUK/GrSXyORdTfJEnCE/NSAQCf7i9GUW2b4ETkjFgMoz7xbVYZalt1iPL3wLx0LhwlEun/TUuCUiFh+5kaHC1tFB2HiMgpaPVG/GXVCQDA3ZMTkRTqIzgREXXmzokDEOLjjuI6Db48WCo6DhER2SFZlvHapjwAwG3j4hDi4y44EZFrmjAwBFNSQqE3yvjbmpOi45ATYjGMep3RJNv2E909ORFqJX+bEYkUH+yNxcOjAACvb8kTnIaIyDm8v/ssyhraEenvgQdmDBQdh4guwttdZfvf6L8256FdZxSciIiI7M3OvFocKW2Eu0qBX09JEh2HyKX98aohUCkkyxSOatFxyMmwSkG9bu3xChTXaRDgpcZNY7hwlMge3Dd9IBSSeaTX8fIm0XGIiBxafZsOb28tAAA8Pm8QvNy4U4LInt08Jg4xgZ6obunAB3uKRMchIiI7IssyXttsvjR669h4hPqyK4xIpIFhPrhzYgIA4NlVJ6EzcMw19R4Ww6hXybKMt7eZHw7dMT6BD4eI7ERSqA+uGmruDuPuMCKiK/P6ljy0dBgwJNIPi4dFi45DRJfhplLgkVkpAIB/by9AU7tecCIiIrIXO/Jqcbi4AW4qBe6dmig6DhEBeHBmMkJ83HG2tg3v7z4rOg45ERbDqFftzKvFiXPN8FQrcceEBNFxiOgn7p8xEJIErDtRidzKFtFxiIgcUnFdGz7ZVwwA+L8Fg6FQSIITEVFXLMmMRkq4D5ra9fjPjgLRcYiIyA6YTDL+ufY0AOD2cfEI8/MQnIiIAMDXQ40n56cCAF7blIfSeo3gROQsWAyjXmXtCrtpTCyCvN0EpyGin0oJ98X89AgA3B1GRNRTy9bnQm+UMSUlFJOSQ0THIaIuUiok/G7OIADA+7uKUN2iFZyIiIhEW3XsHE5WNMPXXYX7pnMHLJE9uTYzGmMGBKFdb8Qz3x+HLMuiI5ETYDGMes2R0kbsLayDSiHh7slsLSeyRw/MSAYArMmpYHcYEVE3na5sxupjFZAk4A+Wm4pE5DjmDAnH8NgAtOuNeJNjo4mIXFqHwYhl63MBAPdOS+KFbiI7o1BI+Ps1GXBTKrAttwarjlWIjkROgMUw6jVvbjX/QLl4eDSiAzwFpyGizgyO9MOCjAjIMvDihlzRcYiIHMrrlofnCzIiMTjST3AaIuouSZLw+Dxzd9hnB0o4coeIyIV9tr8EZQ3tCPN1x50TE0THIaJODAzzwf0zzF2bz646gUaNTnAicnQshlGvOFbWiI0nq6CQgP83LUl0HCK6hEdnD4JCAjaerEJ2SYPoOEREDiGvqgU/5JhvIz4wg2N0iBzVhKQQTE4Ogd4o45WNZ0THISIiARradPjXZvPqgEdmp8DLTSU4ERFdzL1Tk5Ac5oPaVh3+/sMp0XHIwbEYRr3ipQ3mHySXZEZjYJiP4DREdCkDw3xw3YgYAOwOIyLqqje25kOWgXlpEUiNYFcYkSP7/Vxzd9jyI+UcG01E5IJeWH8aDRo9BoX74oaRMaLjENEluKkU+Md1GQCArw6VYU9+reBE5MhYDKMrdri4HtvP1ECpkPDQzGTRcYioCx6alQy1UsLu/Drs5kGCiOiSCmpaseroOQDAAzPZFUbk6IbGBGB+OsdGExG5ouySBnxxsBQA8Ncl6VAp+WiUyN6NjA/C7ePiAQC//+YYWjsMghORo+Kf+HTFrF1hN4yMQXywt+A0RNQVMYFeuHWs+SDxj7WnYTLJghMREdmvN7fmwyQDswaHIy3KX3QcIuoFv5uTYhsbncWx0URELsFokvHM98chy8B1I2IwZkCQ6EhE1EVPzE9FbJAnyhvb8dyak6LjkINiMYyuyJ6CWuwpqIObUoEH2BVG5FDunzEQvu4q5JQ34bvsctFxiIjsUlFtG74/Yu4Ke5BdYUROY2CYL663jMZati4XssyLQUREzu7jvUU4Xt4MPw8V/rAgVXQcIuoGH3cVll0/DJIEfH6gFFtPV4uORA6IxTDqMVmW8bKlK+ymMbGIDvAUnIiIuiPExx33zTA/2F22/jQ0OraZExH93Jtb82E0yZg+KBRDYwJExyGiXvTQrBS4KRXYW1iHXRwbTUTk1ErqNPjnOvNo3N/PHYQQH3fBiYiou8YlBuOuiQMAAE98ewyNGp3gRORoWAyjHtuWW4NDxQ1wVylw33TelCZyRHdOTEBskCeqmjvw7+2FouMQEdmV0nqNrXP2QXbAEzmd6ABP3GbZP/ECu8OIiJyWySTjsW+Ool1vxNgBQbaVAUTkeH4/dxASQ71R3dKBP35/QnQccjAshlGPGIwmPPfDKQDALyckINzPQ3AiIuoJd5US/zd/MADgPzsKcK6xXXAiIiL78dY2c1fYlJRQZMYFio5DRH3gvulJ8HZTIqe8CWtyKkTHISKiPvDh3iIcOFsPLzclll0/DAqFJDoSEfWQh1qJl24YBoUErDx6Dt8f4doP6joWw6hHvjxUivzqVgR6qfFbdoURObR56REYMyAIWr0Jz67iElIiIgAoa9Dgm8NlAICHuCuMyGkF+7jj11OSAADP/3AaWr1RcCIiIupNBTWt+Oe60wCAPywYjLhgL8GJiOhKZcYF4v4Z5skdTy8/jtJ6jeBE5ChYDKNua9Hq8cpG866wh2Ymw99TLTgREV0JSZLw7OI0qBQS1p2oxKaTVaIjEREJ9+/tBdAbZUwcGIyR8UGi4xBRH/r1lERE+XugvLEd7+3k2GgiImeh1Rtx36dZ0OpNmDQwBLeNjRMdiYh6yYMzBiIzLgAtHQY8+tURGIwm0ZHIAbAYRt327+0FqG3VYUCIN27hnGUip5Aa4YdfTTYvIf3TyhPQ6AyCExERiVPR1I6vDpq7wh6cwV1hRM7O002JJ+anAgDe2laAqmat4ERERNQb/rLqBE5XtiDExw0v3zgMksTxiETOQqVU4LVfZMLHXYWDRQ14e1uB6EjkAFgMo24pqdPg3Z1nAQBPzk+Fm4q/hYicxUMzkxEd4Inyxna8uilPdBwiImHe2V4IndGEsQOCMDYxWHQcIuoHVw+Lwsj4QGh0Rts4LSIiclzfHynH5wdKIUnAq7/IRBh33RM5nbhgLzy7OA0A8OrmPGSXNAhORPaOlQzqMlmW8edVJ6AzmDAhKRhzhoSLjkREvcjLTYW/LjEfIv676yyOlDaKDUREJEBVsxafHSgBYL4kQESuQZIk/PGqIQCA77LKeQ4iInJgx8ub8OS3OQCAB6YPxKTkEMGJiKivXJMZjUXDomA0yXjoiyNo7eCkI7o4FsOoyzaerMKW09VQKyU8uzid7eVETmhGajiuthwiHv3yCNp1XCJPRK7lne2F0BlMGBUfiPFJ7AojciXDYgNw7YhoAObRWiaTLDgRERF1V2WTFr/68CDa9UZMTg7BQ7NSREcioj4kSRL+tiQd0QGeKKnX4M8rT4iORHaMxTDqknadEX9ZdRIAcPfkRAwM8xGciIj6yrOL0xDu547C2jb8Y+0p0XGIiPpNdYsWn+4vBgA8ODOZF3+IXNAT81Lh7aZEdkkjvjxUKjoOERF1Q1uHAb/68CCqmjuQHOaDN24ZAaWC5zkiZ+fvqcYrvxgOhQR8c7gMq46eEx2J7BSLYdQlr2/JQ3ljO6IDPPHAjIGi4xBRHwrwcsOy64cBAD7cW4ydeTWCExER9Y/3dp5Fh8GEzLgATOY4HSKXFO7ngd/NGQQAeP6HU6hp6RCciIiIusI6Iu3EuWYEe7vh/V+Ohr+nWnQsIuonYwYE4b7p5mfW//ddDkrqNIITkT1iMYwu68S5JryzoxAA8MdFQ+DlphKciIj62pSUUNw+Lh4A8MiXR1HVrBWciIiob9W0dODjvZausBnsCiNyZXdMSEB6tB+atQb8bc1J0XGIiKgL/rH2FDadqoKbSoH/LB2F2CAv0ZGIqJ89NDMZo+ID0dJhwANfZENnMImORHaGxTC6JIPRhMe/OQajScaCjAjMTYsQHYmI+sn/LRiM1Ahf1LZ24LefZvEQQURO7Z3tBWjXGzEsNgDTBoWKjkNEAikVEp6/ZigUEvD9kXPskicisnOf7i/GuzvPAgCWXT8UI+MDBSciIhFUSgVeuzkTfh4qHC1txEsbckVHIjvDYhhd0rs7z+LEuWb4e6rx56vTRMchon7k6abEv28bCV8PFQ4XN+DvP3B/GBE5p+pmLT7eZ+4Ke2QWu8KICMiI8cfS8QkAgKdXHIdWbxQbiIiIOrUzrwZ//P4EAODR2SlYPDxacCIiEik6wBMvWFZ/vLOjENvP8FIT/YjFMLqo/OpWvLLpDADgmauGIMzXQ3AiIupvCSHeePnG4QCAD/YU4ZvDZWIDERH1gbe3F6DDYMKIuABMTWFXGBGZ/W5OCiL8PFBcp7H9XERERPYjr6oFv/00C0aTjGsyo7njnogAAPPSI2yrPx798giqufqDLFgMo07pDCY8/KV5tuqUlFBcN4I3a4hc1ewh4bYfKv7w3THsLagTnIiIqPdUNmnx6f4SAMCjswexK4yIbHw91Hh2sXk6xn92FOJgUb3gREREZFXb2oG7PjyIFq0BoxMC8Y/rMniOIyKbpxaaV3/Utenw6FdHYTLJoiORHWAxjDr16qYzOF7ejAAvNZZdP5QHCiIX98isFCwcGgm9UcZvPj6E/OpW0ZGIiHrF29vyoTOYMDohEBMHBouOQ0R2Zk5aBK4bEQNZBn731VG0dRhERyIicnlavRG//ugQSuvbERfkhXduHwV3lVJ0LCKyIx5qJd64JROeaiV25dfi3zsKREciO8BiGF1gf2Ed3t5u/gPiH9dmINyP4xGJXJ1CIeGlG4ZhRFwAmrUG3PnBAVQ0tYuORUR0Rc41tuPzA6UAgEdmp/DyDxF16k9XD0F0gCdK6jV4jjtUiYiEkmUZj39zDFkljfDzUOH9X45GkLeb6FhEZIcGhvniL1ebu/xf2nAGh4sbBCci0VgMo/M0WFpHZRm4YWQM5qVHio5ERHbCQ63Eu0tHIT7YC6X17bjl3f2o4txlInJgr23Kg85owtgBQZiQFCI6DhHZKT8PNZbdMBQA8Nn+Eqw/USk4ERGR63p1Ux5WHj0HlULCv28biYFhPqIjEZEdu2FUDK4eFgWjScaDn2ejqV0vOhIJxGIY2ZhMMh756gjKG9uREOyFP1kq50REVsE+7vj07rGICfTE2do23PyffVxESkQO6VRFM746bO4Ke3xequA0RGTvJiSF4J7JAwAAj319FKX1GsGJiIhcz6qj5/Da5jwAwN+WpGPCQF5mIqJLkyQJz12TjrggL5Q3tuPJb49Blrk/zFWxGEY2b27Nx7bcGrirFHjr1pHwcVeJjkREdigm0Auf3zMO0QGeKKxtw83v7kN1CwtiRORYnl97GrIMLMyIxMj4QNFxiMgBPD4vFZlxAWjRGnDfZ1noMBhFRyIichnHyhrx2NdHAQD3TB6Am8bECU5ERI7C10ON12/OhEohYe3xSnyyr1h0JBKExTACAOzKq8XLm84AMN+uGRLlJzgREdmz2CAvfPHrcYjy90BBTRt+8c4+lDXwhjQROYbtZ2qw40wN1EoJj88bJDoOETkItVKBN24ZgQAvNY6VNeG5NdwfRkTUH6qatbjno0PoMJgwfVAonpw/WHQkInIww2ID8OR880SQZ1efRHYJ94e5IhbD7IRWq8Wf/vQnpKSkwMPDA1FRUbjrrrtQVlbW48+Zn5+Pe+65BwkJCfDw8EBoaCgmTJiAZcuWnfe6wppW3PdZFmQZuCYtEDkr30V6ejq8vb3h7++P9PR03HfffWhtbb3Sb5OInEhrVTEC972B8jduxfY/zEXK4DT837PPw2Qy9fhzfvPNN5gzZw5CQkLg4eGBuLg4XHvttdi1a1enr//0008xceJE+Pr6wsfHB6NHj8Z7773X469PRL2jt841BoMBf/7zn7Fw4UIkJibC19cXHh4eSE5Oxn333YeSkpKLfuypU6dw6623IjIyEu7u7khISMADDzyAquoaPP+D+QH20vEJiA/2vqLvlYicx6lTp3DDDTcgNDQUnp6eyMjIwCuvvHLe2SY6wBOv3DgcAPDR3mJ8ceDifw791LPPPgtJkiBJEr744osL3t/Q0IA//OEPmDVrFuLj4+Hl5QUvLy+kpaXhiSeeQF1dXa98j0REV0LEGU+rN+LXHx1CVXMHolCPlJoduPWWm5GYmGj7c7WykrsciejyZ7lfTRqAeWkR0Btl/PbTLNS1dnT6eY4dO4b7778f48aNQ1RUFNzd3eHv74/x48fjjTfegMFg6PTjrH8mXewfrZZTlUSTZA7JFE6r1WLmzJnYs2cPIiMjMXnyZBQVFeHAgQMIDQ3F3r17kZSU1K3PuXz5ctxyyy3o6OhAZmYmUlJSUFdXh5ycHHh7eyM/Px8A0KjR4Zq39uBsbRuS3Ztx+n9PoKy0FAMGDMDIkSPR0dGB3NxcnDlzBqWlpYiJiemLXwIicjD79u3DzJkzodFokDlyFM4ZfFGbfwTGtgbMnL8IG9d8D0mSuvz5jEYjli5dis8++wze3t6YNGkSAgICUFJSgsOHD+OZZ57B008/fd7H/Pa3v8Xbb78Nd3d3jB8/Hl5eXti9ezeamppw11134b///W9vf9tE1AW9ea5pbW21FbuHDh2KqKgo6HQ6HDlyBCUlJfD398eWLVswYsSI8z5uy5YtWLRoETQaDQYPHozBgwcjJycHeXl5CAqLhOf1zyMoNAI7Hp+OAC+3vvhlICIH89OzzZgxY5CQkIAdO3agsrIS1113Hb7++uvzzjb/2pyHlzeegUoh4ZO7x2JcYvBFP3dubi6GDRsGnU4HWZbx+eef46abbjrvNcePH0dGRgaCgoKQlpaGqKgotLS04NChQ6iurkZMTAx27dqF+Pj4Pvs1ICK6FBFnvMzMTDz4xRGsOnoOgV5qjDj3Pd5/560LPl9FRQUiIiJ6+1smIgfS1bNci1aPxW/sRmFtGyYnh+CDO8dAqTj/+dUbb7yBBx54APHx8Rg4cCBCQ0NR8//bu+/wKMq1DeD3lmTTewIhQAihhBJ6kd6LggqiSFFBKeoBC6IiIoJ+cizHguXoOeCRqqhUAQUE6UgHqSFAgCQkBFJJT7Y83x8hKyEJpGwym937d1250Knv+8zsO8/MOyUxEfv27UNubi769u2LzZs3w8HBoch8KpUKrq6uePTRR0ss48KFC4vNQ9VMSHGzZ88WANKlSxfJyMgwD//kk08EgPTs2bNcy/vrr7/E0dFRfH19Zc+ePUXGGY1GOXz4sIiI5BuMMnrBfgmesVE6v7NR6jdoIGq1Wv7973+LyWQqMt+pU6ckKyurgjUkIlui1+slNDRUAMinn34qIiIpmXky5JPfRVcnTADIG+9/Xq5lvv766wJAHnjgAUlOTi4yLiUlRc6fP19k2KpVqwSAeHt7y9GjR83Dr169Ks2aNRMA8uOPP1awhkRUGZbMa/R6vezdu1f0en2R4QaDQWbOnCkApHPnzkXGZWVlSa1atQSAzJkzxzzcaDTKpOenCgBxCmkvyw9cqVgFicjmlJTbiIhkZGRIly5dBIB89913ReYxmUwy5fujEjxjo7R5Z4tEJ5V8rmQymaRnz55Sq1YtefjhhwWArFixoth0aWlpcuTIETEajUWG5+TkyJNPPikA5PHHH7dAbYmIKkaJHO+LbecleMZGCZ35q/x5MUm+/fZbmTFjhqxevVpiYmIkODhYAMi1a9csVk8iqnnKm8udu5YuYW9tkuAZG+XjLeeKLS8qKkqioqKKDU9ISJCWLVsKAPnmm2+KjQcgwcHBlqkUVQl2hiksPz9fvLy8BIAcO3as2PhWrVoJADly5EiZl9mjRw8BIBs2bCh1GpPJJG+sPinBMzZK89mb5PlpBReip0+fXqF6EJH9+PnnnwWAtG7dusjwzFy9PPD2EgEgjv7BsvFEfJmWd/78edFoNFK/fv0yd7r369dPAMi8efOKjdu4caMAkLZt25ZpWURkOVWR15RGr9eLk5OTAJDMzEzz8GXLlgkAadq0abGLyhP/96do3HwFgBw//lely0BEtqG03EZE5NixYwJAWrZsWWxcTr5BHvxyjwTP2Cj9P9kp6Tn5xaZZsGCBAJDly5fLuHHjSu0Mu5urV68KAPH39y/XfERElqJUjldv2ioJnrFRfjgYXeK07AwjIpGK5XJrj12V4BkbJXjGRvkjIqHM61q+fLkAkMcee6zYOHaGWT9+M0xhe/fuRVpaGkJDQ9G2bdti4wsfq9ywYUOZlhcREYE9e/agSZMmGDp0aKnT/XvHRaw4FAOVCpj/eGus+3EZVCoVpk2bVrGKEJHd2LhxIwAUe+zbVafFmtlj4REQhPzEaDz7zSb8cPDe39H49ttvYTQa8dxzz8HFxaVMZTh69CgAoHfv3sXGFQ47fvw4YmNjy7Q8IrIMS+c1d6NSqaBWq6FWq6HVas3DC9uHnj17Qq3+O9X9I+I6tp5PgVPdsFtlWF/pMhCRbSgttwGAtm3bomHDhjh9+jSuXLlSZJyTgwYLn+qAWh46XLiRiWeXHUWewWgen5CQgNdffx39+vXD2LFjK1w+jUYDAHB05GtdiUgZ1Z3jqVRqQKWGSq3B+K4NMLpT/Uovl4hsV0VyuWFtg/BUl4LXT7/841+ITcku07qYl9Vs2ntPQlXpxIkTAFDsWxeFCocXTncvf/zxBwBgwIAByM3NxU8//YQjR45ApVKhVatWGDlyJH45m4qPfz8PAHh7aHMESjKuXbuGFi1aICgoCFu2bMHWrVuRlZWF0NBQjBgxAiEhIZWtKhHZiLu1WzqtBgN6dMHq1auQf+My3lx7CqnZ+ZjSp1Gpy7u93bp8+TJWrFiB6Oho+Pj4oF+/fujfv3+xebKysgAA3t7exca5urpCp9MhLy8PJ06cQL169SpUTyIqP0vnNaUREXzwwQfIzs5G//79odPpzONKah/SsvPx1rrTAIDmIXVw+Fzly0BEtqMsbdelS5dw4sQJNGjQoMi4Wh5O+Papjhi1YD/+jErGKz+dwBej20KjVuHFF19ETk4OvvnmmwqXTa/XY+7cuQCA+++/v8LLISKqjOrM8eb83zzk5GTDKbgNujWtjVlDmlVqmURk+yqay701pDlOXr2Jv2LT8Nzyo1j9fFc4OWhKXU9qaio++eQTAKXnZVlZWZg3bx5iYmLg4uKCtm3b4pFHHoGbm1sFa0eWxM4whcXEFDw1Ubdu3RLHFw4vnO5ezpw5AwBwdnZGmzZtEBkZWWT89NdnwOX+16Gr1xIv9m2Ep7uF4KeffgIAhISEYNiwYfjll1+KzPPmm2/iX//6F1566aWyV4yIbNa92q169QqGd60l+AvAv7ZEIiPXgBmDmxb58Hyhwnbr4MGDmD59OvLy8szjPvjgA/Tv3x+rV6+Gh4eHebi/vz/i4+MRHR2NZs2KnhwlJCSYl3HnHdxEVLUsndfcbsaMGbh+/TrS09Nx8uRJREVFISwsDAsWLCgynb+/PwAgOjoaQMFFlTfXnsK1m7kI8XOF1nATANsHIvpbZduu8Lqe+O+THfD04kP49dQ1+Lo5oqP6MlauXIl33nkHjRs3Lld5JkyYAKPRiNTUVBw9ehRxcXHo2rUrPvjgg3Ith4jIUqo7x9P61EWLx1/FV2PawUHDl1oR0d1VtI1y1Krx9dh2GPrlXpyJT8estafx8WOtzNeuLly4gHnz5sFkMuH69ev4888/kZmZiWeffRZjxowpcV1JSUl46623igx75ZVXsGTJEgwZMqRS9aTK4xFFYZmZmQBQ6qvBXF1di0x3L6mpqQCA+fPnIyUlBWvWrEFaWhoiIyPRf+gjSE9NwY017+HhJs6YNqBJkXk2b96MX3/9FR999BHi4+MRFxeHDz74ACKCl19+GZs2bapUXYnINpS13epczxWzHijoqPrPrii8te40TCYpMm1ubi5yc3MBAC+//DJ69eqFkydPIj09HVu3bkVISAi2bduGyZMnF5mvV69eAIDFixcXW/+iRYvM/52RkVGBGhJRRVk6r7nd6tWrsWTJEqxduxZRUVFo2bIlfvrpp2JPrxe2D7/++iuSkpKw6uhV/HYqAVq1Cm/08MXuXTsBsH0gor9Zou3q3tgPn45sA5UKWLzrHJ6a8CyaNGmCGTNmlLs8S5YswZIlS7B+/XrExcWhZ8+e+P777+Hr61vuZRERWUJ15ngOfsGoO+JNLHv5Qfi48jVkRHRvlWmj6ng544tRbaFWAauPXcV/d18yj7t+/TqWLFmCZcuW4ffff0dmZiamTp2Kjz76qMSbvZ966ils3rwZcXFxyMzMxPHjx/Hkk08iOTkZjzzyCA4dOmSJ6lIlsDNMYSIFF4ZL+gHdPr6sjMaCd9QbDAYsX74cw4cPh6enJxLVPohpPRGOgY1hys2Ea9Qf5nXePs9rr72G1157DYGBgahTpw5mzJiBl19+GQAwb968ilSRiGxUWdqtST0b4v1HwqFSAd8fjMG0n/+C3mgyjy9sfwAgKCgIGzZsQHh4ONzd3dG/f3/88ssvUKvV+Pnnn3HhwgXztK+99hocHBzw008/YcaMGYiNjUViYiK++eYbvPvuu+bvB93+vSAiqnqWzmtud/HiRYgIEhMTsXnzZuh0OrRv3x5LliwpMt2AAQPQoUMHZGZmot+AQZjxnzUw5efgocAMTJ8wGiZTQRvE9oGI7lTZtuvB1nUw98EWSNu9FGmJ1zDixblFXuNaVgaDASKC+Ph4rFy5EvHx8QgPD8eWLVvKvSwiIkuojhxv0bYTCHjsHai0Dohd9CIO/b62wsskIvtU0Taqe2M/zHmwBQDgw83nsOVMQsHw7t0hIjAYDLh06RI++eQTLF26FB06dCjxTSNLlizBoEGDUKdOHbi6uqJNmzZYunQpZs6cifz8/GJPjFH141UAhbm7uwP4+/sWd8rOLvh4X1nfK1q4vKCgIAwcOBAA8OfFJExYchh5BhPa9x8OANi9a1exeQDgmWeeKbbMwmEHDhwo8voyIrJPhe1RWdut0Z3q4/NRbaFVq/DLX/F4fvlR5OoLOsFcXV3NF6SfeOKJYh8gDQ8PR4cOHSAi2HVbu9W2bVssWbIEzs7O+Oijj1C/fn0EBATgH//4B7p27YqHHnoIQMnfFCOiqmPpvKYkfn5+GDRoEP744w/UqVMHzz//PGJjY83jVSoV1qxZgxYtW+LkX8dw+X8vI/azx/DZi6OQkJCAt99+GwDbByL6W3lzm7tppr2BzOO/wrVFH/x41QObTl2rcLkCAwPx6KOPYtu2bVCpVBg/fnyFnrogIqqsqs7xTl5Nwz93xMG5YXu89e8VCCohxyMiKo0lcrlxXRvgyfuCIQK8/ONfOB130zxOo9EgJCQEr7zyChYvXowLFy7ghRdeKHP5ZsyYAY1Gg507dyI/P7/M85HlsTNMYfXr1wcAXL16tcTxhcMLp7uXwo8ABgcHAwD+jErCM0sOI1dvQt+wALwxsgcA4MaNG8XmuX2+kpZpNBqRnJxcpnIQke2qSLv1UOs6WPBUe+i0amyLuIGnFx1GZp4BwN/tTkntD/B3G3R7uwUAo0ePRlRUFD777DM899xzeOmll7BmzRps3brVXIYWLVpUsJZEVBGWzmvuxtPTE0OHDkVOTg62bt1aZFxQUF3c98pC+A2biVpdR+DJpyfgs88+Q0REBPz8/ACwfSCiv1my7frtt98gJhNcs68h/vs3MGLoILTp1A29e/fG5s2bAQDvvvsuevfuja+++qpM5QsODkaPHj2QkJDA1+sQkSKqMse7kZGLyUuPIt9gQv9mAZg1rH2pOR4RUUks1UbNebA5ejT2Q47eiElLj+BGem6xaYYNGwY3Nzds2rSpzB1bnp6eCAgIgF6vR1JSUpnmoarBzjCFtW7dGgBw7NixEscXDm/VqlWZlte2bVsAQEpKCvZdTMIziws6wvo09cc3T7RDeloagKI94a1atYJGozHPd6fbO8Aqcyc3EdmGirZbfcNqYckzneDqqMH+S8l44tuDSMvOL9JulaSwDSqp/QkMDMTLL7+Mb775BvPnz8fw4cORlpaG48ePw93dHe3atatYJYmoQiyd19xLYcdWYmJikeHzt53HtshkeDfvgd9WLMTS777Fyy+/DH9/f2zbtg0A0Lt3b4uUgYhqvqpou25cPoe82NPIiTmFE4f/xK5du3D9+nUAQEREBHbt2oWLFy+WeXmltXdERNWhqnK8PIMRzy8/hoT0XIT6u+Kzx9tArVaxzSOicrFUG6XVqPHVmHYI9XfFtZu5mLj0CLLzDUWmUalU8PHxgdFoRGpqapnKZzKZkJ6eDoDX1pXGzjCFdevWDZ6enoiKisLx48eLjV+1ahUAYOjQoWVaXr9+/eDq6oqLF6PwxOe/IVdvQu+m/vjmifbQaQsexwRQ5AKxl5cXevQoeGJsx44dxZZZOE9oaCg8PDzKUz0iskFDhgwB8Hf7dLvjx4/j0qVLaN68OUJCQoqNv6+hL36YdB+8XBzwV2waRi04gN4D7gdQcvuTkZFhTlrK2rH15ZdfQq/X48knn4Szs3OZ60VElWfpvOZeCl+fGhoaah7246EYfLG94ALzPx8JR7v6f78O8cKFC9i4cSN8fX3xyCOPWKQMRFTzVSa3udPcuXMhIhAR5OmNmLD4EIJnbESz2ZswdMRoAMCKFSsgIpg/f36Zymc0GrF3714ARds7IqLqUhU5nohg5upTOBqdCncnLRY+1QHuTg4ASs7xiIhKY8lcztPZAd+N7whvFwecvHoTzy8/hnyDyTz+0qVLiI2NhYeHh7nj/l42b96MrKwsNGrUiNfWFcbOMIU5Ojpi6tSpAICpU6cWebfpp59+ipMnT6J79+7o2LFjkfm++uorhIWFYebMmUWGu7i4oP+j42Aw6HF901cY2NgL/32yPZwcNNi8eTOWLFkClUqFyZMnF5nvjTfeAADMmjULly9fNg+PiorC7NmzAQDPPfec5SpORDXW8OHDERISghMnTuCzzz4zD8/KysKUKVMAAK+88kqx+fr164ewsDDkXTuPnyZ3QYC7DucSMrAytR7q1Q/Gli1bsGTJEvP0BoMBL730ElJTU9GyZUt069atyPKOHDlSbB3Lly/HvHnz4Ofnh3feecdSVSaiMrJ0XrN+/Xps2rSp2AePs7OzMWvWLOzatQu1a9fG4MGDAQAbTsRj5tpTyE+MxsSudfFo+7rmeaKiojB8+HDk5+fjk08+YWc5EZlVNrcp7dWFjtqCu4t7NPZDdr4Rey+W/oTDsmXLzB1et0tJScHkyZNx6dIlhIeHo3379uWtHhFRpVVFjjf5n99i9bGr0KhV+GpMOzT0dys1xyMiuhtL53I//e/fmNvHH04Oauw6n4jXVp2AySSIjIzEmDFjICJ46qmnzG9aAwo64s6fP19sHbt27cKkSZMAAP/4xz8sUl+qBCHF5eTkSOfOnQWABAYGysiRI83/7+vrKxcuXCg2z5w5cwSAjBs3zjzMZDLJf3ddlPrT14guqLl5ecOGDZOuXbuKWq0WADJv3rwSyzF9+nQBIG5ubjJo0CAZOHCguLq6CgC5//77xWAwVFUIiKiG2bdvnzg7OwsA6dy5s4wcOVICAwMFgAwbNkyMRmOxeYKDgwWA7NixQ0REriRlSrcP/pDgGRulxXNfiItLQXvTrl07eeSRR6RBgwbmdvDkyZPFlgdAGjVqJA8++KA8/vjj0rRpU/P0hw8fruoQEFEpLJXX3D68Tp06MmTIEBkzZoz07dtXfHx8BIB4enrK7t27RUTkj4gECZ35qwTP2CjhfR4ST09P6dOnj4wePVp69+4tDg4OAkBmz55dHWEgohrGErlNabLzDPLYf/4U15b9BID86+v/FZtm3LhxAkAaNmwoDz/8sIwePVp69uwpbm5uAkCCgoLk7NmzlqouEVG5WTLHe3TSywJANG4+0rZb37vmeLc7evSodO7c2fzn6OhoPocsHLZw4cKqCgERWTFL5nLBwcGiVqulUfNwcQ3rLi5Nu0mdxi3N19Z79uwpGRkZReYpzOUaN24sAwcOlMcee0zatGkjAASAjBo1qsQyUPXik2FWwMnJCTt27MDs2bPh4uKCdevW4cqVKxg3bhyOHz+ORo0a3XMZBqMJc9afwT9/OweV1hGzvv4B7733Hry8vLBp0yacOXMGffr0wcaNG/Hmm2+WuIyPP/4YK1asQKtWrbBv3z7s2bMHTZo0weeff47169cX6e0mIvvWtWtXHD58GCNGjMDFixfxyy+/wNvbGx9//DFWrVoFtfreh5dgX1eseq4rGgW4IdOzIYInfokHhj+GuLg4bNiwAQaDAZMmTcKxY8cQHh5ebP5p06bB3d0de/bswbp162AymfDKK6/g7Nmz6NChQ1VUm4jKwBJ5TaFHHnkEr7zyCoKCgnD48GH8/PPPOHz4MIKDgzFz5kxERESgR48e+O3UNTy77CgMJsHDbepg7tTxuO+++xAREYFVq1bh7NmzeOCBB7Bjxw68++67VVh7IqqpLJHblMbZUYPvxneEj6sjAODLPy7i5NW0ItNMnDgR//jHP+Du7o59+/Zh5cqVOHnyJFq2bIl58+bhzJkzaNasWWWqSERUKZbK8fZdTMIBUyO4dxyGwDpBiLtwutQc707p6ek4ePCg+S8/Px9AwfeACoddvXrVovUmoprBkrncvHnzMGrUKKgNeZCrJ5B94SAS4q+iSbuuWLx4MXbs2FHs21+PP/44xo4dC41Gg0OHDmHt2rWIj4/H/fffj5UrV2LFihWVyifJMlQid7x3hmqczDwDXvjhGHZEJkKlAt68vxkm9WyodLGIiMokJSsfTy86hBNXb8LVUYOF4zqga2jZ3rtMRLTiUAxmrT0FkwBDwgMxf1QbOGh4kkFE1ic9V4/x3x3CsZg0uOu0WPxMJ7QP9r73jERENuKv2DQ88e1BZOYZ8FDrOpj/eBuo1Sqli0VEdFeL9l3GOxvOAgBeHdgEU/s2VrhEVFHsDKvh4tNyMGHJEURcS4eTgxrzH2+LwS1rK10sIqJyycwzYPLSI/gzKrng+xqj22JgC7ZlRFQ6EcGX2y/i060F72Uf3ak+3hvWEhpeUCEiK5aZZ8Aziw/j0OUUuNx6Yuy+hr5KF4uIqMpFXEvHqAUHcDNHjy4NfbH4mY7QafkGIiKqGf694yL+tSUSADvEajJ2htVgey8k4cUfjyMlKx9+bjr8b1wHtK7npXSxiIgqJFdvxEs/HseWM9ehUavw4YhWeLR9XaWLRURWKFdvxBurT2LdX/EAgOd7h+L1QU2hUrEjjIisX06+EZOWHsHei0nQadX4fFQbDG4ZqHSxiIiqzMUbmXj8v/uRnJWPdvW9sGxCZ7jqtEoXi4ioXG7vEHttUFNM6VP2TwCQdWBnWA1kMgm+3nkRn2w9DxGgZZAH/vNEe9T1dlG6aERElWIwmvDGmlNYdbTgPe+zhzbHhO4hCpeKiKzJjfRcPLf8KI7FpEGrVuHdh1tiTOf6SheLiKhccvVGTP3hOLZFXIdKBcwZ2hzjuzHnISLbE52chZH/3Y/r6XloGeSB7yfeB09nB6WLRURUIewQq9nYGVbDJGbkYcbqk9h+7gYAYFTHepj7UAs4OfDRciKyDSaT4J+/ReDbvZcBAFP6hGL6gKZ8lzwR4eClZEz54TiSMvPg4aTFN0+0R7dG/MYgEdVMBqMJczecwfIDMQCAZ3s2xIzBYcx5iMhmnEtIx5P/O4TEjDw0qeWGHyd3gY+ro9LFIiKqlNs7xPiWkpqFnWE1yG+nruGtdaeRkpUPR60a7z3cEiM71lO6WEREFici+HpnlDm5GBIeiI8faw1nR3b8E9kjk0mwYM8l/GtLJIwmQdNa7vjPk+0R4ueqdNGIiCpFRPDNrih8tLkg5+nfLACfPNYGni58aoKIaraj0Sl4etFhpOcaEFbbHUsndEKAu5PSxSIisohvdkbhw83nAAAjO9TFP4eHQ6tRK1wquhd2htUAqVn5eHv9GWw4UfBdjGaBHvjksdZoXsdD4ZIREVWtn4/EYtbaU9AbBS2DPLDwqQ4I9HRWulhEVI3i03Iw/ecT2H8pGQAwrE0d/PORcLg48jsTRGQ71h6/ihmrTyHfYEI9H2d8M7Y9WgZ5Kl0sIqIK2XgyHq+uPIFcvQntg73x3biO7OQnIpvz0+EYzFxzCiYpuKHpy9HteBO3lWNnmBUzGE344VAMPt16HmnZemjUKvyjdyhe6NsYjlr2NBORfTh8JQXPLjuKlKx8+Lvr8PXYdujYwEfpYhFRNVh/Ih5vrT2F9FwDnB00mD20OUZ3qsdXUBCRTToddxPPf38UsSk5cNSqMefB5hjTqT7bPCKqMYwmwSe/R+LrnVEAgN5N/fH12Ha8iYmIbNbWs9cx9YdjyDOY0K6+F/77ZAf4u+uULhaVgp1hVmrvhSS8u/EMzl/PBACE1XbHhyNaoXU9L2ULRkSkgNiUbExaegTnEjKgVgEv9muMqX0a8RF0IhuVcDMXc9efweYzCQCA1vW88NnI1mjo76ZwyYiIqtbNbD2mr/wL2yIKvhHdrZEv5g0LRwO+FpaIrNyNjFy8uvIkdp9PBABM7tkQrw9qynM2IrJ5h6+kYMLigtfCBnk5Y+FTHfhGNyvFzjArIiLYeT4RX++4iMNXUgEA3i4OmD6wKUZ1rMcEgojsWlaeAbN/OY01x+IAAB0beOPDEa14cZzIhhhNgu8PRuOjzZHIzDNAo1ZhSp9GeKFvIzgwDyIiO2EyCf639zI+/j0SeQYTdFo1pvRphIk9Qvh0BRFZpT8iruP1VSeRnJUPnVaND0e0wrC2QUoXi4io2lxKzMTEJUdwKSkLLo4azH+8DQa2qK10segO7AyzAjdz9Pjlrzj8cDAG5xIyAACOGjXGdK6Paf2b8L3KRES3+eWvOMxaexqZeQY4atV4sW8jTO4ZytfHEtVwBy4l4/3fInDi6k0AQJt6Xnj/kXA0C+QddURkn6KTs/Dm2lPYd7Hgm4kB7jq8MqAJRrSvyxsEiMgqJGfm4f1N57Dq6FUABW81+mJ0WzSp5a5wyYiIqt/NbD2m/HAMey8mQaUCXujbGC/1awyNmq+8thbsDFNITr4RBy4l47dT17DhZDxy9SYAgIujBmM718fEHg1Ry8NJ4VISEVmn2JRszFp32vwKjob+rnhjcBgGNK/F72oQ1TAR19Lx0eZz2BFZ8Ht212nx+uCmGNM5mCcNRGT3RAQbTl7Dv7acQ2xKDgAgyMsZE7qHYFSnenxSjIgUYTIJfjoSiw82ncPNHD0A4JluIXh9cFM4OWgULh0RkXL0RhP+b+NZLN0fDQDoGuqLz0e15XfErAQ7w6rR5aQs7Iy8gR2RiTh4KRl5BpN5XJNabhjTqT6Gt63LJ8GIiMpARLD+RDze3XAWyVn5AApenTitfxN0CfVlpxiRlTsRm4YFuy/ht9PXIAJo1SqM6lQPL/ZrjAB33hBERHS7PIMRy/ZH4z+7opCUWZD3eLk44InOwRjVqR7qersoXEIishf7o5Lx4eZz+Cs2DQDQLNAD7w1rifbB3soWjIjIiqw7Hoc3155Cdr4R/u46fD6qDbqG+ildLLvHzrAqlKs3Yv+lZOyKTMSOyBuITs4uMj7Iyxm9mvpjRLsgtKvvzQu3REQVkJ6rx393ReHbPZfNNxk0D/TA5J4NMaRVIF8jRGRF8gxGbD17HcsPROPApRTz8CGtAvHqwKYI8XNVsHRERNYvV2/EqqNXsXDPJfP5pUoF9G7ij9Gd6qNvWAC/NU1EVeJodCo++T0Sf0YVvLrV1VGDaQOaYHzXBmx3iIhKcPFGJv7x/VGcv54JABjXJRivDw6Dq45P9iuFnWEWduW2p78O3PH0l4NGhY4NfNC7qT96Nw1A4wA3doAREVnItZs5+GZnFFYeuYocvREAUMtDh2Ftg/Bou7pozPfWEylCRHD+eiZWHY3F6mNxSLn1JKdWrcJDretgUs+G/C4YEVE5GU2CLWcSsPxAtPnCNPB37jO8bRDCarNtJaLKMZkEO8/fwP/2XjZ/v9BBo8LoTvUxpU8jft6DiOgesvMNeHfDWfx4OBYAUNfbGR+OaIVujfiUmBLYGVZJuXojDl1OwY7IG9gZmYjLSVlFxtfxdEKvpgHo09QfXRv5wc3Ge34TExOVLgIRVZK/v7/SRaiU1Kx8fH8wGov/jEZSZp55eFhtdwxoXgv9m9VCeJAn1PwWEVGVERGciU/HptPXsOl0Ai4l/p0f1fLQ4bH29TCmc33U8XJWsJT3xryGyDbU9NzmXi4nZeHHQzFYefSq+YYDoODVZcPb1sHDbYJ4wZqIyiUjV491f8Vj0b7L5jxOo1bh0XZ18UK/RjX+1azM8YhqFlvI5fZcSMQbq08hLq3gG7DD2wZhxuAw1PZkjlad2BlWAXFpOdhx7gZ2Rt7AvovJ5icQgII7ZDoE+6BPmH0+/WVPdSWyVbZyWMgzGLHj3A2sPhaHHeduwGD6u14B7jr0axaA7o38cV9DH/i68UOmRJWVkavH/qhk7LmQhJ3nbyA2Jcc8zlGjRs8m/hjVsR56N/WvMa/SYV5DZBtsJbe5lzyDEdsjbmDt8TjsiLwBvbGg3ioV0C3UD8PbBmFgi1pwd+I3qomoOBHBsZg0/HgoBhtPXjNf63LXaTGqUz081aUB6vnU7E6wQszxiGoWW8nlMvMM+HDTOSw7EA0AcHbQ4PneoXime4jNP0BjLdgZVgZ6owlHo1MLnv46l4jI6xlFxtfy0KFP0wD0bhqAbo187frkggkFUc1ni4eF1Kx87Ii8gW0R17ErMhFZ+cYi45sFeqBrqC+6hvqiU4iPXbfjRGVlMJpwOj4du88nYs+FRByLSYPxtk5nJwc1ejcJwP3htdE3LKBG/q6Y1xDZBlvMbe4lLTsfG09ew7rjcTgSnWoe7qhRo1sjXwxuWRv9m9XiDUFEhLi0HGw8EY9VR6/iwo1M8/BQf1eM7RyMkR3r2dxFWuZ4RDWLreVyJ2LT8O7Gszh6K0fzcnHAhG4hGNetATxq4HlzTcLOsFLEpmRj1/lE7D6fiP1RycjIM5jHqVVA+2Bv9G4agD5NA9As0J0H0lsYB6Kaz9YPC3kGIw5cSsHOyBvYH5WMcwlFb3DQqFVoVdcTXRoWdIy1D/aukRfxiSwtM8+A4zGpOHIlFUejU3E8JrVYx3KInyt6NPZDj8b+6NbIFy6ONfvCCfMaIttg67nNvcQkZ2PdX3H45a84RN322lq1CugU4oPBLWqjf/NaNf61Z0RUdokZefjt1DVsOBFfpMPcyUGNIeF1MLpTPbQP9rbZXMhW60Vkq2wxlxMRbDh5DfO3nselW59dcnfSYmznYIzuVA/Bvq4Kl9A2sTPslpvZehyJTsGeC0nYfT7RvBMW8nF1RO8m/ugdFoCejf3g5eKoUEmtGxMKoprP3g4LSZl52B+VjD+jkvFnVBKik7OLjFergLDaHugU4oMODbzRqYEPAvjdDbJxadn5OHstHWfj0xFxLQNn4m/i/PUMmO5oHtydtOga6oueTfzRs7G/zbw6pxDzGiLbYG+5zd1cvJGBzacTsOl0As7EpxcZ18DXBd0a+aF7Iz90CfXlOS+RjbmSlIU/zt3AHxHXceBSsjmvU6mATg188FCbOniwdR27eCqBOR5RzWLLuZzRJNh4Mh5fbb9Y5OncHo398GDrOhjQrBa8XZmTWYpddoaZTIKYlGycuJqGI1dScfhKCiKvZ+D2SGjUKrSv742eTfzQs4k/WtbxhFrNg+W98COkRDWfLXyYtDKupmZjf1Qy9l9KxpErqYhJyS42TS0PHZoHeqB5HQ80C/RA01ruqOfjAicHjQIlJro7vdGEtGw99EYT8g0m6I0m5OpNSM3OR2p2PtKy9UhIz0VMSjZiU7IRk5KNtGx9icsK8nJGhwbe6NDABx2CvdGkljs0NpwfMa8hsg32ntuUJjYlG1vOJGDLmYRir7oFgIZ+rmhdzwut6nqiVV0vNAt0r/FP/BLZk8w8A45cScHeC0nYfu5GsZu+W9fzwoOtAjG0VR3U9rSvm/2Y4xHVLPaQy5lMgq0R1/H9wRjsuZBo7qfQqFXo0tAX/ZsFoFOIL8Jqu7OPohJsujMsV2/E1dQcxKYWXNyJTMhAxLV0RCZkFHutD1CQ7N8X6ouejf3RtZGvXdwNQ0REd3c9PReHr6TgyJVUHLqcgoiEdJR25KzloUN9HxfU83aBn7sOXi4O8HJ2hLeLA9yctHDUqOGoVcNBo4bu1r8l3ZSoQtGBni4O8HTmMYkq5mh0CkZ8s7/c89XzcS7o9A30RPM6HggP8rS7CyVERPYiI1ePg5dSsPdiEv6MSsL565klTlfH0wkN/d0Q6u+Khv5uaODniiAvZ9TxcmJHGZHCbqTn4lTcTRy+kooDl5JxKu5mkU5urVqFTiE+6BsWgAHNa/EVXEREVio2JRtrjsVh85kERFwr+iS/u5MWHYK90aKOJxrXckPjAHc09He16puzjSZBnsEIg0ngpNXAUatWrCyKdoYZjCZk5BpgFIFJBCYTYBKB0SQQwW3DBSYpCFyuwYic/IK/bL0RuflGpOfqkZJVcHdzSlY+kjLzEZuSjRsZeaWu21GrRrPa7mgf7IOOt+5w9nfnx4OJiOjuMvMMiEwoeH3c2WsZOBt/E1GJWci87duSljbz/jA82yu0ypZPtu3U1Zt48Ku9t3XGqqDTago6a10c4O3iCH/3Wx25Pi7mf23tQ+lERFR2KVn5OHk1DSdibxb8e/UmkjJLP78GCj7+XsfTGXW8nBHk5YRAr4L/DvR0gp+bDn5ujnDTafl6MqJKEBGkZutxJTkLMcnZiErMxOm4mzgdn47EEq6B1fNxxn0hvugTFoDujf140zcRUQ1zJSkLW84kYO/FJByLLv7d7kLeLg6o5eGE2p5OqO3hBE9nB7g4auGq08DFUQsXRw1cHAs6ojRqFdQqFVQqQK1S3fr/glfIihT02RhMAr3RBINRYDCZkGcwITvfiKw8A7LyjMjONyAzz/D3sPyC/87JNyJXb0SOvvC/Tcg3mszl/Ozx1hjetm51ha8YRTvDIhMyMGj+7ipdh6ujBvV8XFDX2wWhAa637nD2QIifK7Qa5XohiYjIdogI0rL1iLn1irnY1GykZuUjNVuPtOyCf7PyDMg3FCQBhf/qDaZ7LxzAKwObYkL3kCquBdmqwlSPFx+JiKgyUrPycSkpE1GJWbiUmIWoxExEJ2fhWlouMsp4U5BOqy7oGHPXwd/N8VYnWUFHmZ+7Dl7OjnDVaeCm08LNSQtXnRYuDhpo1KoSj2MiUpBTGcX8KuA8vQk5+oILMbl6I3INJuTkG5FnKBx2+3iTebrhbYPQuaGvpcNGduL89Qx8/scFaFQqaNUFFxbv/HPQFFyAdFCroFGrodUUTKvVqG/9q4LBKH/vmwYjsvMMSM4quPE7JSsfcWk5yMgt+femVgGNAtzQuq4XuoT6onNDXwR5OVdzJIiIqKoYjCZEXMvA0egURF7PxMUbGTh/PRM3c0r+zIE1+uSx1hjRXrnOMEVv+b399ZYqFaBRFfRKqtW3eiVv9VAW9laq1So4Oajh4qCFk6MGLg4aODsWJMo+ro7wcXWEt6sjfFwcUdfbGfV8XODt4sCLP0REVKVUKhW8bx2DWtfzUro4REUwDyIiIkvwdnVEe1cftA/2KTYuPVePa2m5iE/LQVxaDuIL/27mIuFmLpIy85Cdb0SewYS4W9OUl/mawa27l40mgd5ouXt7W9TxYGcYVVhiRh5+PXmt2tYX6OmEYF8XNPB1RfM6HmhRxxPNAz3g7Gi9r8kiIqLK0WrUCK/rifC6nuZhIoKbOQXfAU+4mYvr6bm4np6HjFw9svILbqrIzjciO9+IzDwD9EYTTIJbb+Ir/IP5vwHA4dYNGw4aNbQaNRxu3dDhqit40sxVp4WrY+G/WvNwZ4eCp9CcHdVwctDAyaFgmLODBjqHwhtClH04SdEnw+RWsAsfwyMiIiIiIiIi25Odb0ByZj4SM/OQlJGHpMx8JGXm/f2XkY/0XD0ycgtetZOZa4DBVL7LFRq1Cjqt2nzxReeghpNWAycHNZwdNbf+u2C4862LNE63punV1B+t6npVTeXJ5sWn5eD3MwkwCmA0FbxeymQSGEwFnwIx/3vrdVMGk8BoFOhNJvNwvdFU8G1hh1sXEbUFr7TydnWE760bwGt7OqG+j4tVfxuGiIjIWinaGUZEREREREREdCcRQd6tVxwab31L3Fh497JJzHcsO2rVcNSoza+gIyIiIiIqCTvDiIiIiIiIiIiIiIiIyGYp+5JGIiIiIiIiIiIiIiIioirEzjAiIiIiIiIiIiIiIiKyWewMIyIiIiIiIiIiIiIiIpvFzjAiIiIiIiIiIiIiIiKyWewMIyIiIiIiIiIiIiIiIpvFzjAiIiIiIiIiIiIiIiKyWewMIyIiIiIiIiIiIiIiIpvFzjAiIiIiIiIiIiIiIiKyWewMIyIiIiIiIiIiIiIiIpvFzjAiIiIiIiIiIiIiIiKyWewMIyIiIiIiIiIiIiIiIpvFzjAiIiIiIiIiIiIiIiKyWewMIyIiIiIiIiIiIiIiIpvFzjAiIiIiIiIiIiIiIiKyWdqyTCQiyM/Pr+qyEBERUTVzdHSESqVSuhgE5ltERES2ivmW9WC+RUREZJvKkm+VqTMsPz8fH3zwgUUKRURERNbjjTfegE6nU7oYBOZbREREtor5lvVgvkVERGSbypJvqURE7rUga71zJiEhAYsXL8b48eNRu3ZtpYujCMaAMQAYA3uvP8AYAIxBRevPO5WtR3XkW/b+OwEYA4AxABgDgDEAGAOAMQCqJwbMt6yHtV7fqi78zdsfbnP7wu1tf7jN/2axJ8NUKpVV3sXk6Oho/tcay1cdGAPGAGAM7L3+AGMAMAb2Xn9bUB35FvcTxgBgDADGAGAMAMYAYAwAxsDeWOv1rerC/d3+cJvbF25v+8NtXj5qpQtAREREREREREREREREVFVqdGeYm5sbevXqBTc3N6WLohjGgDEAGAN7rz/AGACMgb3Xn8qG+wljADAGAGMAMAYAYwAwBgBjQPaF+7v94Ta3L9ze9ofbvHzK9M0wIiIiIiIiIiIiIiIiopqoRj8ZRkRERERERERERERERHQ37AwjIiIiIiIiIiIiIiIim8XOMCIiIiIiIiIiIiIiIrJZ7AwjIiIiIiIiIiIiIiIim8XOMCIiIiIiIiIiIiIiIrJZinWGHT58GA888AC8vb3h6uqKTp064Ycffij3cjIyMjBnzhy0bNkSLi4u8PLyQrt27fDOO+/cc96PPvoIKpUKKpUKBw4cqEg1KkWJGDRo0MBc5zv/nnvuOUtUq8yU3AfWrl2LAQMGwNfXF87OzggJCcHo0aMRGxtbmSqVW3XHYPHixaVu/8K/fv36Wap6ZaLEfiAiWLNmDfr06YPAwEC4uLigadOmePbZZ3Hp0iVLVKtclIiByWTCV199hXbt2sHFxQUeHh7o1asX1q9fb4kqlUtl69+7d+977tfLli2z+HotSYkYLF++HM8++yw6dOgAnU4HlUqFxYsXW7hmZCmV3Ud27tyJMWPGoFmzZvDy8jK3e8888wwiIyNLnMfW2sqKxMCa2krA8u2WXq9HmzZtoFKpEBYWVm3rrQwlYmCN7WV1xyEuLg7z58/HwIEDUb9+fTg6OqJ27doYMWIEDh48WJmqVFh1xyAtLQ0vvvgiunTpgtq1a0On0yEoKAh9+/bF6tWrISKVqU6FKNUm3M5WzqkLlSUG1nROTfZFiVzIEuuliqnu7W2Nx3p7o9Rv/HZKH9ftiZLb21quiytBq8RKd+7ciUGDBsHR0RGjRo2Cp6cn1qxZg7Fjx+LKlSt48803y7ScmJgY9O3bF5cuXUL//v0xZMgQ5OXl4eLFi1i9ejXmzJlT6rwRERF4++234erqiqysLEtVrcyUjIGnpydefvnlYsM7dOhQ2WqVmVL1FxE899xzWLBgAUJDQzFq1Ci4u7sjPj4eu3btQnR0NOrVq1cVVS5GiRi0adOm1N/FqlWrcObMGQwaNMgi9SsLpfaDV199FZ9++ikCAwMxbNgweHh44MSJE1i4cCFWrFiBP//8Ey1btqyKKhejRAxEBCNHjsTq1asRGhqKCRMmIC8vD7/88gsefvhhfPnll5g6dWpVVbkIS9R//Pjx6N27d7Hher0e77//PtRqdbFOXkvF3RKUisFbb72F6Oho+Pn5ITAwENHR0ZaqElmYJfaRbdu2Ye/evejcubN5WREREVi6dCl++OEHbNq0CX369Ckyj621leWNgTW1lUDVtFv/93//h4sXL1b7eitKqRhYW3upRBy+/PJLfPjhhwgNDcWAAQMQEBCACxcuYN26dVi3bh1WrFiBkSNHVqZa5aJEDJKSkvDdd9/hvvvuw7Bhw+Dj44MbN25gw4YNePTRRzFp0iQsWLCgMtUqF6V+D7ezlXPq25U1BtZwTk32Ral80JryAHuixPa2tmO9vVHqN347pY/r9kSp7W1N18UVI9VMr9dLaGio6HQ6OXbsmHl4enq6tGjRQrRarZw/f/6eyzEYDNKxY0dxdnaW7du3l7iee83bqVMneeKJJwSA7N+/v2IVqgAlYxAcHCzBwcGVKn9lKVn/zz//XADIlClTxGAwlGmeqmANv4Pb5eXlia+vr2i1WklISCh7RSpBqRhcu3ZN1Gq1NGjQQG7evFlk3GeffSYA5Omnn65grcpHqRisXLlSAEi3bt0kOzvbPDwxMVGCg4NFp9PJ5cuXK16xMrJU/UuzatUqASAPPvhgta63PJSKgYjI1q1b5cqVKyIi8v777wsAWbRoUYXXRVXDUvtITk5OicO3bdsmAKRDhw5FhttiW1neGFhLWylSNW3F0aNHRavVyhdffCEApGnTptWy3opSKgYi1tVeKhWH1atXy+7du4sN3717tzg4OIiPj4/k5uaWv0IVoFQMDAZDibl1enq6NG/eXADI6dOny1+hClDy91DIVs6pb1fWGFjDOTXZF6VyIWvKA+yJUtvbmo719kapbX47pY/r9kTJ7W0t18WVVO2dYVu2bCn1AsqPP/4oAGTmzJn3XE7htLNnzy53GebNmyeOjo5y+vRpGTduXLX/wJWMgTUk7krVPzs7W3x8fKRhw4aK/7it4XdQ0nKGDRtWqeWUh1Ix2L9/vwCQsWPHFht3/vx5ASBDhgwp07IqS6kYjB07VgDIr7/+Wmzc/PnzBYC8/fbbZVpWZViq/qUZPHiwAJB169ZV63rLQ6kY3Enpi7tUuurYX729vcXLy6vIMFtsK++mpBhYS1spYvkY5OXlSXh4uHTv3l1MJlOpF31tub0sawzupHR7aS1xuN3AgQMFgBw+fLhc81WUNcZg2rRpZTreWoo1xMBWzqkLlScG1nBOTfZFqVzImvIAe6LU9r6b6j7W2xtr2OZKH9ftiVLb25quiyup2l+TuHPnTgDAwIEDi40rHLZr1657Luenn34CADz22GOIjY3Fr7/+irS0NISGhuL++++Hm5tbifOdPn0a77zzDt566y20aNGigrWoHKVjkJeXhyVLliAuLg7e3t7o2rUrWrduXcHalJ9S9d+6dStSUlIwfvx4GI1GrF+/HufPn4eXlxf69++PRo0aVbJmZaf0PnCn//3vfwCAiRMnlml6S1AqBo0bN4ajoyP27duHjIwMuLu7m8f99ttvAIC+fftWqE7lpVQMrl+/DgAICQkptqzCYdu3by/Ttxcrw1L1L8nVq1fx+++/o3bt2hgyZEi1rbe8lIoB1RxVvb/u378fqamp6N69e5HhtthWlqa0GFhLWwlYPgZz587FhQsXcOLECahUqmpbb2UoFQNrY41xcHBwAABotdVzamltMcjNzcX27duhUqnQvHnzcs9fEUrHwJbOqQuVNwZKn1OTfVEqF7KmPMCeKLW976a6j/X2Rultbg3HdXui1Pa2puviSqr2VuzChQsACi6y3Mnb2xt+fn7mae7myJEjAIC9e/di2rRpyMvLM4/z9/fHzz//XOz7KQaDAePHj0ezZs3wxhtvVKIWlaNkDAAgISEB48ePLzJs8ODBWLZsGfz8/MpRk4pRqv6F02u1WrRu3brIxwTVajWmTZuGjz/+uEJ1Ki+l94HbRUdH448//kBQUBAGDx5cjlpUjlIx8PX1xbx58/Daa6+hWbNmeOihh+Du7o5Tp05h27ZtmDx5Ml544YVK1q5slIqBv78/AODy5cto1qxZkWVdvnwZAHD+/PnyVaYCLFX/kixatAgmkwnjx48vlrBX5XrLS6kYUM1h6X1k586d2LlzJ/Ly8nDhwgVs3LgRfn5++Oyzz4pMZ4ttZaGyxsBa2krAsjE4fPgwPvroI/zzn/9EkyZNqm29laVUDKyNtcUhJiYG27ZtQ+3atREeHl6hZZSX0jFIS0vD/PnzYTKZcOPGDfz222+IjY3FnDlzSixTVVAyBrZ2Tg1UbD9Q+pya7ItSuZA15QH2RKntXRoljvX2Rsltbi3HdXui1Pa2puviiqruR9EGDBggAOTChQsljm/YsKE4Ojreczk6nU4AiEajkRkzZkhsbKwkJibKF198IY6OjuLp6Snx8fFF5nnnnXdEq9XK0aNHzcOUePRT6Rjs3LlTEhMTJT09XQ4cOCD333+/AJAuXbqIyWSySB3vRqn6P/vss+bpO3bsKIcOHZKMjAzZvXu3hIWFCQD5+uuvLVbPu1FyH7jTnDlzBIC89dZbFapLRSkdg++//17c3NwEgPmva9euJb4ju6ooFYOlS5cKAOnRo0eRdwwnJSVJgwYNBECZ1ltZlqr/nUwmk4SEhJS67Kpab0UoFYM7Kf3aLyqdpfeRwja/8K9Ro0Zy5MiRUqe3pbayUFljYC1tpYjlYpCbmyvNmzeXDh06FHlHPEp5HZgttpfljcGdlG4vrSUOIiL5+fnSs2dPASBLly4tWwUsQOkYXL58uUgb4uDgIP/617+q5TyqkJIxsLVz6orGQOlzarIvSuVC1pQH2BOl8//bKXWstzdKbnNrOa7bE6W2tzVdF1eSurydZ9bCZDIBAIYOHYoPPvgAdevWhZ+fH1544QVMmzYNN2/eNL/6DQBOnDiB9957D6+++iratWunVLEtqrwxAIC3334bvXr1gp+fH9zd3dG5c2ds3LgR3bt3x/79+82vPqoJylv/wukdHR2xbt06dOzYEW5ubujRowdWrVoFtVqNTz75RJG6VFRF9oE751+0aBFUKhWeeeaZ6iq2RVUkBu+99x7Gjx+PmTNnIjY2FpmZmdi7dy8MBgP69OmDNWvWKFGVCitvDEaPHo0+ffpgz549CA8PxwsvvIDnnnsOLVq0gIeHBwBAo9EoUhdL2L59Oy5fvoxevXrZzWPed2IMqDRz586FiCAzMxOHDh1CWFgYunXrhh9++KHYtLbWVhYqawxssa2cPXs2Lly4gO+++67Gld1SGIMClY2DyWTCM888g927d2PSpEl48sknq6CUVauiMWjQoAFEBAaDAZcvX8a7776LWbNmYcSIETAYDFVYYssrbwxs8Zy6IvuBLZ1Tk30qTz5INV9Ft7ctHOvtVVm3uS0e1+1RWbe3LV4Xr4hq7wzz9PQEANy8ebPE8enp6eZpyrKchx56qNi4Bx98EMDfj/8BwLhx4xAaGoq5c+eWt8gWp1QMSqNWq/H0008DAPbt23fP6StLqfoXTt+hQwfUqVOnyPQtWrRAw4YNERUVhbS0tHtXopKsZR/YunUrYmJi0Ldv3xK/iVKVlIrB9u3bMXv2bEydOhVvvvkm6tatC1dXV3Tr1g0bN26Es7Mzpk2bVu76VIRSMdBqtdi0aRPmzp0LtVqNBQsWYM2aNXj44YexatUqAH+/HqwqWar+d/r2228BlP4NvKpab0UoFQOqOapqH3F1dUXHjh2xdu1ahIWFYfLkyUhMTDSPt8W28k73ioG1tJWAZWJw7NgxfPrpp5g1a1aZX3Fja+1lRWJgbawhDiKCSZMmYfny5XjiiSfwn//8p9zLqAxriAFQ0BneoEEDvPHGG3jvvfewdu1aLFy4sELLKi+lYmBr59SWbBOq+5ya7ItSuZA15QH2RKntfTulj/X2Rqltbk3HdXuidJtuDdfFlVTtnWGF78Ms6d2XqampSEpKKtO71ps2bQoA8PLyKjaucFhOTo552IkTJ3Du3Dk4OTlBpVKZ/5YsWQIA6NKlC1QqFdatW1fOGpWfUjG4m8L3mmdnZ5dp+spQqv53m760eaqKtewDhU8LKXHBXKkY/PrrrwCAPn36FJve398f4eHhiImJQVJS0j3XXVlK7gc6nQ5z5sxBZGQk8vLycOPGDfz3v/9FXFwcgIKDY1WzVP3vnG/t2rXw8vLCiBEjqm29FaVUDKjmqOr9VavVok+fPsjKyirSaW6LbWVpSosBYB1tJWCZGJw8eRJGoxFz584tkgurVCoAQGRkJFQqVZFjia21lxWJgbVROg4mkwkTJkzAd999h9GjR2Px4sVQq6v3lFLpGJSk8GPnhR9Er2pKxcDWzqktvR9U5zk12RelciFrygPsiZK5L2Adx3p7o9Q2t6bjuj1Rantb03VxJVV7a9arVy8AwO+//15sXOGwwmnupm/fvgCAs2fPFhtXOKxBgwbmYRMmTCjxr3DneuihhzBhwoQi81QVpWJwNwcPHizX9JWhVP0LL+hFREQUm16v1+PixYtwdXWtlru8rWEfSE5Oxi+//AIfHx8MHz68TOW2JKVikJ+fDwCl3gFVOFyn091z3ZVlDfvBnb7//nsAwKhRo8o0fWVYqv63W758OfLy8jB27Fg4OztX23orSqkYUM1RHftrfHw8gIKkuZAttpV3U1IM7qY620rAMjFo0qRJqfkwUHCn4IQJE/DUU09ZdL2WolQMrI2ScTCZTJg4cSIWLVqExx9/HMuWLVPkVZPWuC+Utw2pLKViYGvn1JbeD6rznJrsi1K5kDXlAfZEydzXWo719kapbW5Nx3V7otT2tqbr4oqq7o+U6fV6adiwoeh0Ojl+/Lh5eHp6urRo0UK0Wq1ERkaahycmJkpERIQkJiYWWc6lS5dEp9NJQECAXL16tchy2rRpIwBk27Zt9yyPEh8FVCoGZ86ckdTU1GLl2bNnjzg5OYlOp5Po6GjLVbQUSu4DAwcOFACycOHCIsPfffddASBPPPGEBWtaOmv4HXz22WcCQF588UXLVq6MlIrBihUrBIC0aNFC0tLSiixr8eLFAkDat29v4dqWTMn94ObNm8XKs3LlSlGr1dKxY8ciHxCvKpaq/+1at24tAOTYsWMWW29VUioGd3r//fcFgCxatKgi1aAqZKl9ZNeuXWIymYotf8uWLeLg4CCenp6SmZlpHm6LbWV5YyBiHW2lSNW0FbcDIE2bNq30equSUjG4k9LtpVJxMBqNMn78eAEgjz32mOj1+krXpaKUisHx48eLtYciIsnJyeZ8a9myZeWvUAVYy++hUE0+py5NaTGwlnNqsi9K5ULWlAfYE6W2tzUd6+2Nkuc7JVHiuG5PlNze1nJdXEnV3hkmIrJ9+3ZxcHAQNzc3mTRpkkyfPl1CQkIEgLz33ntFpp0zZ44AkDlz5hRbzhdffCEAxNfXVyZOnChTpkyRBg0aCACZPHlymcqi1A9ciRjMmTNHnJ2dZejQoTJ16lSZPn26DBo0SFQqlWg0mmI/hKqk1D5w8eJFCQgIEAAyZMgQmT59uvTt21cASHBwsFy7dq2qqlyM0r+Dli1bCgA5efKkpatWZkrEwGAwSO/evQWA+Pv7y4QJE+TVV1+VAQMGCADR6XSyZ8+eqqx2EUrtB2FhYTJgwAB58cUX5fXXXzfHpGHDhnLlypWqqm4xlqq/iMiRI0cEgLRr186i661qSsVg4cKFMm7cOBk3bpy0a9dOAEi3bt3Mw9auXWuB2pElWGIf8fT0lNDQUBk1apS89tprMnXqVOnZs6cAEAcHB1m5cmWR6W2xrSxvDESsp60UsWxbcae7Xfi21fbyTneLgbW1l0rEoXA5bm5uMmvWLJkzZ06xv9tP5quaEjF46aWXxNXVVYYOHSpTpkyR119/XR5//HFxc3MTADJixAgxGo2WqF6ZKPV7KElNP6cuyd1+C9ZyTk32RalcyJryAHuixPa2tmO9vVHqN14SdoZVPaW2tzVdF1eKIp1hIiIHDx6UwYMHi6enpzg7O0uHDh1k+fLlxaa7V9K6fv166dGjh7i5uYmTk5O0b99eFixYUOZyKPkDr+4Y7Ny5U0aOHCmNGjUSd3d3cXBwkLp168qoUaPk4MGDlq7ePSm1D8TExMj48eOldu3a4uDgIPXq1ZMpU6bI9evXLVW1MlMqBgcPHhQA0qlTJ0tVpcKUiEFubq58+OGH0q5dO3FxcRGtVitBQUEyZswYOXXqlCWrVyZKxGDOnDkSHh4u7u7u4uTkJM2aNZO33nqrxKcgqpql6v/8888LAPn6668tut7qoEQMCo9/pf2V9WIRVY/K7iPz58+XwYMHS926dUWn04mTk5M0btxYJk6cKKdPny5xnbbWVlYkBtbUVopYrq24070ufNtie3mnu8XAGtvL6o7DvWIAVP/TctUdgz179sj48eMlLCxMPDw8RKvVSkBAgAwePFh++OGHEu/MrWpKtQl3soVz6juVFgNrO6cm+6JELlSe9ZJlVff2tsZjvb1R6jd+J3aGVQ+ltrc1XRdXgkpEBEREREREREREREREREQ2SK10AYiIiIiIiIiIiIiIiIiqCjvDiIiIiIiIiIiIiIiIyGaxM4yIiIiIiIiIiIiIiIhsFjvDiIiIiIiIiIiIiIiIyGaxM4yIiIiIiIiIiIiIiIhsFjvDiIiIiIiIiIiIiIiIyGaxM4yIiIiIiIiIiIiIiIhsFjvDiIiIiIiIiIiIiIiIyGaxM4yIiIiIiIiIiIiIiIhsFjvDiIiIiIiIiIiIiIiIyGaxM4yIiIiIiIiIiIiIiIhsFjvDiIiIiIiIiIiIiIiIyGb9PxOrM/mLE7dWAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 2208x1104 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print((mu_mu + mu_true) / 2)\n",
+    "\n",
+    "with model as m:\n",
+    "    idata = pm.sample()\n",
+    "\n",
+    "az.plot_posterior(idata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "da854429-9cd2-4850-abab-68b75a2dc23b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1.47480745 1.77934647 4.15323425]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ERROR (pytensor.graph.rewriting.basic): Rewrite failure due to: constant_folding\n",
+      "ERROR (pytensor.graph.rewriting.basic): node: Subtensor{i}([], 0)\n",
+      "ERROR (pytensor.graph.rewriting.basic): TRACEBACK:\n",
+      "ERROR (pytensor.graph.rewriting.basic): Traceback (most recent call last):\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/graph/rewriting/basic.py\", line 1933, in process_node\n",
+      "    replacements = node_rewriter.transform(fgraph, node)\n",
+      "                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/graph/rewriting/basic.py\", line 1086, in transform\n",
+      "    return self.fn(fgraph, node)\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/tensor/rewriting/basic.py\", line 1163, in constant_folding\n",
+      "    return unconditional_constant_folding.transform(fgraph, node)\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/graph/rewriting/basic.py\", line 1086, in transform\n",
+      "    return self.fn(fgraph, node)\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/tensor/rewriting/basic.py\", line 1109, in unconditional_constant_folding\n",
+      "    required = thunk()\n",
+      "               ^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/graph/op.py\", line 544, in rval\n",
+      "    r = p(n, [x[0] for x in i], o)\n",
+      "        ^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/tensor/subtensor.py\", line 932, in perform\n",
+      "    out[0] = np.asarray(x.__getitem__(cdata))\n",
+      "                        ^^^^^^^^^^^^^^^^^^^^\n",
+      "IndexError: index 0 is out of bounds for axis 0 with size 0\n",
+      "\n",
+      "ERROR (pytensor.graph.rewriting.basic): Rewrite failure due to: constant_folding\n",
+      "ERROR (pytensor.graph.rewriting.basic): node: Subtensor{i}([], 1)\n",
+      "ERROR (pytensor.graph.rewriting.basic): TRACEBACK:\n",
+      "ERROR (pytensor.graph.rewriting.basic): Traceback (most recent call last):\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/graph/rewriting/basic.py\", line 1933, in process_node\n",
+      "    replacements = node_rewriter.transform(fgraph, node)\n",
+      "                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/graph/rewriting/basic.py\", line 1086, in transform\n",
+      "    return self.fn(fgraph, node)\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/tensor/rewriting/basic.py\", line 1163, in constant_folding\n",
+      "    return unconditional_constant_folding.transform(fgraph, node)\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/graph/rewriting/basic.py\", line 1086, in transform\n",
+      "    return self.fn(fgraph, node)\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/tensor/rewriting/basic.py\", line 1109, in unconditional_constant_folding\n",
+      "    required = thunk()\n",
+      "               ^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/graph/op.py\", line 544, in rval\n",
+      "    r = p(n, [x[0] for x in i], o)\n",
+      "        ^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/home/michaln/git/pytensor/pytensor/tensor/subtensor.py\", line 932, in perform\n",
+      "    out[0] = np.asarray(x.__getitem__(cdata))\n",
+      "                        ^^^^^^^^^^^^^^^^^^^^\n",
+      "IndexError: index 1 is out of bounds for axis 0 with size 0\n",
+      "\n"
+     ]
+    },
+    {
+     "ename": "TypeError",
+     "evalue": "Only tensors with the same number of dimensions can be joined. Input ndims were: [2, 2, 3, 4, 2, 2, 2, 3, 3, 4]",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mTypeError\u001b[39m                                 Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[15]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;28mprint\u001b[39m((mu_mu+mu_true)/\u001b[32m2\u001b[39m)\n\u001b[32m      3\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m model \u001b[38;5;28;01mas\u001b[39;00m m:\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m     idata = \u001b[43mpmx\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n        idata \u001b[34m= \u001b[39m\u001b[34mInference data with groups:\u001b[39m\n\u001b[34m\t> posterior\u001b[39m\n\u001b[34m\t> sample_stats\u001b[39m\n\u001b[34m\t> observed_data\u001b[39m\n        pmx \u001b[34m= \u001b[39m\u001b[34m<module 'pymc_extras' from '/home/michaln/git/pymc-extras/pymc_extras/__init__.py'>\u001b[39m\n        x \u001b[34m= \u001b[39m\u001b[34mx\u001b[39m\n        [n, y_obs] \u001b[34m= \u001b[39m\u001b[34m[10000, array([[-0.69153803,  1.04000235,  0.69387204],\u001b[39m\n\u001b[34m       [-1.27660839,  2.7385192 ,  1.30131083],\u001b[39m\n\u001b[34m       [-0.08313251,  1.29330782, -0.13413925],\u001b[39m\n\u001b[34m       ...,\u001b[39m\n\u001b[34m       [ 0.28806391,  2.48479233,  0.98893543],\u001b[39m\n\u001b[34m       [ 1.29758078,  0.67646451, -0.25756165],\u001b[39m\n\u001b[34m       [-0.05729306,  0.83726859, -0.5232307 ]])]\u001b[39m\n        n \u001b[34m= \u001b[39m\u001b[34m10000\u001b[39m\n        y_obs \u001b[34m= \u001b[39m\u001b[34marray([[-0.69153803,  1.04000235,  0.69387204],\u001b[39m\n\u001b[34m       [-1.27660839,  2.7385192 ,  1.30131083],\u001b[39m\n\u001b[34m       [-0.08313251,  1.29330782, -0.13413925],\u001b[39m\n\u001b[34m       ...,\u001b[39m\n\u001b[34m       [ 0.28806391,  2.48479233,  0.98893543],\u001b[39m\n\u001b[34m       [ 1.29758078,  0.67646451, -0.25756165],\u001b[39m\n\u001b[34m       [-0.05729306,  0.83726859, -0.5232307 ]])\u001b[39m\u001b[32m      5\u001b[39m \u001b[43m        \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mINLA\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m      6\u001b[39m \u001b[43m        \u001b[49m\u001b[43mx\u001b[49m\u001b[43m=\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m      7\u001b[39m \u001b[43m        \u001b[49m\u001b[43mtemp_kwargs\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_obs\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m      8\u001b[39m \u001b[43m        \u001b[49m\u001b[43mreturn_latent_posteriors\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\n\u001b[32m      9\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     11\u001b[39m az.plot_posterior(idata)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pymc-extras/pymc_extras/inference/fit.py:47\u001b[39m, in \u001b[36mfit\u001b[39m\u001b[34m(method='INLA', **kwargs={'return_latent_posteriors': False, 'temp_kwargs': [10000, array([[-0.69153803,  1.04000235,  0.69387204],\u001b[39m\n\u001b[34m...\u001b[39m\n\u001b[34m       [-0.05729306,  0.83726859, -0.5232307 ]])], 'x': x})\u001b[39m\n\u001b[32m     44\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m method == \u001b[33m\"\u001b[39m\u001b[33mINLA\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m     45\u001b[39m     \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpymc_extras\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01minference\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01minla\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m fit_INLA\n\u001b[32m---> \u001b[39m\u001b[32m47\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfit_INLA\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n        kwargs \u001b[34m= \u001b[39m\u001b[34m{'x': x, 'temp_kwargs': [10000, array([[-0.69153803,  1.04000235,  0.69387204],\u001b[39m\n\u001b[34m       [-1.27660839,  2.7385192 ,  1.30131083],\u001b[39m\n\u001b[34m       [-0.08313251,  1.29330782, -0.13413925],\u001b[39m\n\u001b[34m       ...,\u001b[39m\n\u001b[34m       [ 0.28806391,  2.48479233,  0.98893543],\u001b[39m\n\u001b[34m       [ 1.29758078,  0.67646451, -0.25756165],\u001b[39m\n\u001b[34m       [-0.05729306,  0.83726859, -0.5232307 ]])], 'return_latent_posteriors': False}\u001b[39m\u001b[32m     49\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m     50\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m     51\u001b[39m         \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mmethod \u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmethod\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m\u001b[33m not supported. Use one of \u001b[39m\u001b[33m'\u001b[39m\u001b[33mpathfinder\u001b[39m\u001b[33m'\u001b[39m\u001b[33m, \u001b[39m\u001b[33m'\u001b[39m\u001b[33mlaplace\u001b[39m\u001b[33m'\u001b[39m\u001b[33m or \u001b[39m\u001b[33m'\u001b[39m\u001b[33mINLA\u001b[39m\u001b[33m'\u001b[39m\u001b[33m.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m     52\u001b[39m     )\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pymc-extras/pymc_extras/inference/inla.py:173\u001b[39m, in \u001b[36mfit_INLA\u001b[39m\u001b[34m(x=x, temp_kwargs=[10000, array([[-0.69153803,  1.04000235,  0.69387204],\u001b[39m\n\u001b[34m...\u001b[39m\n\u001b[34m       [-0.05729306,  0.83726859, -0.5232307 ]])], model=<pymc.model.core.Model object>, minimizer_kwargs={'method': 'L-BFGS-B', 'optimizer_kwargs': {'tol': 1e-08}}, return_latent_posteriors=False, **sampler_kwargs={})\u001b[39m\n\u001b[32m    170\u001b[39m marginal_model = marginalize(model, x, use_laplace=\u001b[38;5;28;01mTrue\u001b[39;00m, **marginalize_kwargs)\n\u001b[32m    172\u001b[39m \u001b[38;5;66;03m# Sample over the hyperparameters\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m173\u001b[39m idata = \u001b[43mpm\u001b[49m\u001b[43m.\u001b[49m\u001b[43msample\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmarginal_model\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43msampler_kwargs\u001b[49m\u001b[43m)\u001b[49m\n        marginal_model \u001b[34m= \u001b[39m\u001b[34m<pymc.model.core.Model object at 0x7f0898ceccb0>\u001b[39m\n        pm \u001b[34m= \u001b[39m\u001b[34m<module 'pymc' from '/home/michaln/git/pymc/pymc/__init__.py'>\u001b[39m\n        sampler_kwargs \u001b[34m= \u001b[39m\u001b[34m{}\u001b[39m\u001b[32m    175\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m return_latent_posteriors:\n\u001b[32m    176\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m idata\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pymc/pymc/sampling/mcmc.py:782\u001b[39m, in \u001b[36msample\u001b[39m\u001b[34m(draws=1000, tune=1000, chains=4, cores=4, random_seed=None, progressbar=True, progressbar_theme=None, step=None, var_names=None, nuts_sampler='pymc', initvals=None, init='auto', jitter_max_retries=10, n_init=200000, trace=None, discard_tuned_samples=True, compute_convergence_checks=True, keep_warning_stat=False, return_inferencedata=True, idata_kwargs=None, nuts_sampler_kwargs={}, callback=None, mp_ctx=None, blas_cores=4, model=<pymc.model.core.Model object>, compile_kwargs=None, **kwargs={})\u001b[39m\n\u001b[32m    779\u001b[39m     msg = \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mOnly \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdraws\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m samples per chain. Reliable r-hat and ESS diagnostics require longer chains for accurate estimate.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    780\u001b[39m     _log.warning(msg)\n\u001b[32m--> \u001b[39m\u001b[32m782\u001b[39m provided_steps, selected_steps = \u001b[43massign_step_methods\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstep\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethods\u001b[49m\u001b[43m=\u001b[49m\u001b[43mpm\u001b[49m\u001b[43m.\u001b[49m\u001b[43mSTEP_METHODS\u001b[49m\u001b[43m)\u001b[49m\n        model \u001b[34m= \u001b[39m\u001b[34m<pymc.model.core.Model object at 0x7f0898ceccb0>\u001b[39m\n        step \u001b[34m= \u001b[39m\u001b[34mNone\u001b[39m\n        pm.STEP_METHODS \u001b[34m= \u001b[39m\u001b[34m[<class 'pymc.step_methods.hmc.nuts.NUTS'>, <class 'pymc.step_methods.hmc.hmc.HamiltonianMC'>, <class 'pymc.step_methods.metropolis.Metropolis'>, <class 'pymc.step_methods.metropolis.BinaryMetropolis'>, <class 'pymc.step_methods.metropolis.BinaryGibbsMetropolis'>, <class 'pymc.step_methods.slicer.Slice'>, <class 'pymc.step_methods.metropolis.CategoricalGibbsMetropolis'>, <class 'pymc_extras.distributions.timeseries.DiscreteMarkovChainGibbsMetropolis'>]\u001b[39m\n        pm \u001b[34m= \u001b[39m\u001b[34m<module 'pymc' from '/home/michaln/git/pymc/pymc/__init__.py'>\u001b[39m\u001b[32m    783\u001b[39m exclusive_nuts = (\n\u001b[32m    784\u001b[39m     \u001b[38;5;66;03m# User provided an instantiated NUTS step, and nothing else is needed\u001b[39;00m\n\u001b[32m    785\u001b[39m     (\u001b[38;5;129;01mnot\u001b[39;00m selected_steps \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(provided_steps) == \u001b[32m1\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(provided_steps[\u001b[32m0\u001b[39m], NUTS))\n\u001b[32m   (...)\u001b[39m\u001b[32m    792\u001b[39m     )\n\u001b[32m    793\u001b[39m )\n\u001b[32m    795\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m nuts_sampler != \u001b[33m\"\u001b[39m\u001b[33mpymc\u001b[39m\u001b[33m\"\u001b[39m:\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pymc/pymc/sampling/mcmc.py:253\u001b[39m, in \u001b[36massign_step_methods\u001b[39m\u001b[34m(model=<pymc.model.core.Model object>, step=None, methods=[<class 'pymc.step_methods.hmc.nuts.NUTS'>, <class 'pymc.step_methods.hmc.hmc.HamiltonianMC'>, <class 'pymc.step_methods.metropolis.Metropolis'>, <class 'pymc.step_methods.metropolis.BinaryMetropolis'>, <class 'pymc.step_methods.metropolis.BinaryGibbsMetropolis'>, <class 'pymc.step_methods.slicer.Slice'>, <class 'pymc.step_methods.metropolis.CategoricalGibbsMetropolis'>, <class 'pymc_extras.distributions.timeseries.DiscreteMarkovChainGibbsMetropolis'>])\u001b[39m\n\u001b[32m    251\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m has_gradient:\n\u001b[32m    252\u001b[39m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m253\u001b[39m         \u001b[43mtg\u001b[49m\u001b[43m.\u001b[49m\u001b[43mgrad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_logp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvar\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n        model_logp \u001b[34m= \u001b[39m\u001b[34m__logp\u001b[39m\n        var \u001b[34m= \u001b[39m\u001b[34mmu\u001b[39m\n        tg \u001b[34m= \u001b[39m\u001b[34m<module 'pytensor.gradient' from '/home/michaln/git/pytensor/pytensor/gradient.py'>\u001b[39m\u001b[32m    254\u001b[39m     \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mNotImplementedError\u001b[39;00m, tg.NullTypeGradError):\n\u001b[32m    255\u001b[39m         has_gradient = \u001b[38;5;28;01mFalse\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/gradient.py:747\u001b[39m, in \u001b[36mgrad\u001b[39m\u001b[34m(cost=__logp, wrt=mu, consider_constant=None, disconnected_inputs='raise', add_names=True, known_grads={}, return_disconnected='zero', null_gradients='raise')\u001b[39m\n\u001b[32m    744\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(g.type, \u001b[33m\"\u001b[39m\u001b[33mdtype\u001b[39m\u001b[33m\"\u001b[39m):\n\u001b[32m    745\u001b[39m         \u001b[38;5;28;01massert\u001b[39;00m g.type.dtype \u001b[38;5;129;01min\u001b[39;00m pytensor.tensor.type.float_dtypes\n\u001b[32m--> \u001b[39m\u001b[32m747\u001b[39m _rval: Sequence[Variable] = \u001b[43m_populate_grad_dict\u001b[49m\u001b[43m(\u001b[49m\n        Sequence \u001b[34m= \u001b[39m\u001b[34m<class 'collections.abc.Sequence'>\u001b[39m\n        Variable \u001b[34m= \u001b[39m\u001b[34m<class 'pytensor.graph.basic.Variable'>\u001b[39m\n        var_to_app_to_idx \u001b[34m= \u001b[39m\u001b[34m{Sum{axes=None}.0: {Add(Sum{axes=None}.0, Sum{axes=None}.0): [0]}, mu_logprob: {Sum{axes=None}(mu_logprob): [0]}, Sub.0: {Check{posdef covariance}(Sub.0, ScalarFromTensor.0): [0]}, Sub.0: {Sub(Sub.0, Sum{axis=0}.0): [0]}, Mul.0: {Sub(Mul.0, Mul.0): [1]}, Subtensor{i}.0: {Mul(0.5, Subtensor{i}.0): [1]}, Sum{axis=1}.0: {Subtensor{i}(Sum{axis=1}.0, 0): [0]}, Pow.0: {Sum{axis=1}(Pow.0): [0]}, Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0: {Pow(Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0, ExpandDims{axes=[0, 1]}.0): [0]}, Sub.0: {Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}(ExpandDims{axis=0}.0, Sub.0): [1]}, ExpandDims{axis=0}.0: {Sub(ExpandDims{axis=0}.0, ExpandDims{axis=0}.0): [0]}, mu: {ExpandDims{axis=0}(mu): [0], ExpandDims{axis=0}(mu): [0]}, Sum{axes=None}.0: {Add(Sum{axes=None}.0, Sum{axes=None}.0): [1]}, y_logprob: {Sum{axes=None}(y_logprob): [0]}, Sum{axes=None}.0: {Sub(Sum{axes=None}.0, Add.0): [0]}, MakeVector{dtype='float64'}.0: {Sum{axes=None}(MakeVector{dtype='float64'}.0): [0]}, Sum{axes=None}.0: {MakeVector{dtype='float64'}(Sum{axes=None}.0, Sum{axes=None}.0): [0]}, x_logprob: {Sum{axes=None}(x_logprob): [0]}, Sub.0: {Check{posdef covariance}(Sub.0, ScalarFromTensor.0): [0]}, Sub.0: {Sub(Sub.0, Sum{axis=0}.0): [0]}, Mul.0: {Sub(Mul.0, Mul.0): [1]}, Subtensor{i}.0: {Mul(0.5, Subtensor{i}.0): [1]}, Sum{axis=1}.0: {Subtensor{i}(Sum{axis=1}.0, 0): [0]}, Pow.0: {Sum{axis=1}(Pow.0): [0]}, Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0: {Pow(Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0, ExpandDims{axes=[0, 1]}.0): [0]}, Sub.0: {Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}(ExpandDims{axis=0}.0, Sub.0): [1]}, ExpandDims{axis=0}.0: {Sub(ExpandDims{axis=0}.0, ExpandDims{axis=0}.0): [0]}, MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0: {ExpandDims{axis=0}(MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0): [0], ExpandDims{axis=0}(MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0): [0], Scan{scan_fn, while_loop=False, inplace=none}(Subtensor{i}.0, Subtensor{:stop}.0, Subtensor{i}.0, Squeeze{axis=0}.0, MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0): [4]}, ExpandDims{axis=0}.0: {MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False)([0.2273360 ... .79736546], ScalarFromTensor.0, Sum{axis=1}.0, ExpandDims{axes=[0, 1]}.0, Switch.0, ExpandDims{axis=0}.0, ScalarFromTensor.0, Sum{axis=0}.0, ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0): [9], Sub(ExpandDims{axis=0}.0, ExpandDims{axis=0}.0): [1], MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False)([0.2273360 ... .79736546], ScalarFromTensor.0, Sum{axis=1}.0, ExpandDims{axes=[0, 1]}.0, Switch.0, ExpandDims{axis=0}.0, ScalarFromTensor.0, Sum{axis=0}.0, ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0): [9]}, Sum{axes=None}.0: {MakeVector{dtype='float64'}(Sum{axes=None}.0, Sum{axes=None}.0): [1]}, y_logprob: {Sum{axes=None}(y_logprob): [0]}, Sub.0: {Check{posdef covariance}(Sub.0, ScalarFromTensor.0): [0]}, Sub.0: {Sub(Sub.0, Sum{axis=1}.0): [0]}, Mul.0: {Sub(ExpandDims{axis=0}.0, Mul.0): [1]}, Sum{axis=1}.0: {Mul(ExpandDims{axis=0}.0, Sum{axis=1}.0): [1]}, Pow.0: {Sum{axis=1}(Pow.0): [0]}, Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0: {Pow(Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0, ExpandDims{axes=[0, 1]}.0): [0]}, Sub.0: {Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}(Switch.0, Sub.0): [1]}, ExpandDims{axis=0}.0: {Sub(y{[[-0.69153 ... 5232307 ]]}, ExpandDims{axis=0}.0): [1]}, Add.0: {Sub(Sum{axes=None}.0, Add.0): [1]}, Mul.0: {Add(Mul.0, Sum{axis=0}.0): [0]}, Add.0: {Mul(-0.5, Add.0): [1]}, Squeeze{axes=[0, 1]}.0: {Add(Mul.0, Squeeze{axes=[0, 1]}.0): [1]}, Matmul.0: {Squeeze{axes=[0, 1]}(Matmul.0): [0]}, ExpandDims{axis=0}.0: {Matmul(ExpandDims{axis=0}.0, ExpandDims{axis=1}.0): [0]}, Squeeze{axis=1}.0: {ExpandDims{axis=0}(Squeeze{axis=1}.0): [0]}, Matmul.0: {Squeeze{axis=1}(Matmul.0): [0]}, Transpose{axes=[1, 0]}.0: {Matmul(Transpose{axes=[1, 0]}.0, ExpandDims{axis=1}.0): [0]}, Sub.0: {Transpose{axes=[1, 0]}(Sub.0): [0], Blockwise{Cholesky{lower=True, check_finite=False, on_error='nan', overwrite_a=False}, (m,m)->(m,m)}(Sub.0): [0]}, Scan{scan_fn, while_loop=False, inplace=none}.0: {Sub([[1. 0. 0. ... 0. 0. 1.]], Scan{scan_fn, while_loop=False, inplace=none}.0): [1]}, ExpandDims{axis=1}.0: {Matmul(Transpose{axes=[1, 0]}.0, ExpandDims{axis=1}.0): [1]}, Sub.0: {ExpandDims{axis=1}(Sub.0): [0], ExpandDims{axis=1}(Sub.0): [0]}, MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0: {Sub(MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0, MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0): [0, 1]}, ExpandDims{axis=1}.0: {Matmul(ExpandDims{axis=0}.0, ExpandDims{axis=1}.0): [1]}, Sum{axis=0}.0: {Add(Mul.0, Sum{axis=0}.0): [1]}, Log.0: {Sum{axis=0}(Log.0): [0]}, ExtractDiag{offset=0, axis1=0, axis2=1, view=True}.0: {Log(ExtractDiag{offset=0, axis1=0, axis2=1, view=True}.0): [0]}, Blockwise{Cholesky{lower=True, check_finite=False, on_error='nan', overwrite_a=False}, (m,m)->(m,m)}.0: {ExtractDiag{offset=0, axis1=0, axis2=1, view=True}(Blockwise{Cholesky{lower=True, check_finite=False, on_error='nan', overwrite_a=False}, (m,m)->(m,m)}.0): [0]}}\u001b[39m\n        grad_dict \u001b[34m= \u001b[39m\u001b[34m{__logp: Second.0, Sum{axes=None}.0: Second.0, mu_logprob: (d__logp/dmu_logprob), Sub.0: (d__logp/dmu_logprob), Sub.0: (d__logp/dmu_logprob), Mul.0: Neg.0, Subtensor{i}.0: Mul.0, Sum{axis=1}.0: IncSubtensor{i}.0, Pow.0: Second.0, Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0: Mul.0, Sub.0: Blockwise{SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0, ExpandDims{axis=0}.0: Blockwise{SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0, Sum{axes=None}.0: Second.0, y_logprob: (d__logp/dy_logprob), Sum{axes=None}.0: (d__logp/dy_logprob), MakeVector{dtype='float64'}.0: Second.0, Sum{axes=None}.0: Subtensor{i}.0, x_logprob: (d__logp/dx_logprob), Sub.0: (d__logp/dx_logprob), Sub.0: (d__logp/dx_logprob), Mul.0: Neg.0, Subtensor{i}.0: Mul.0, Sum{axis=1}.0: IncSubtensor{i}.0, Pow.0: Second.0, Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0: Mul.0, Sub.0: Blockwise{SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0, ExpandDims{axis=0}.0: Blockwise{SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0, Sum{axes=None}.0: Subtensor{i}.0, y_logprob: (d__logp/dy_logprob), Sub.0: (d__logp/dy_logprob), Sub.0: (d__logp/dy_logprob), Mul.0: Neg.0, Sum{axis=1}.0: Mul.0, Pow.0: Second.0, Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0: Mul.0, Sub.0: Blockwise{SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0, ExpandDims{axis=0}.0: ExpandDims{axis=0}.0, Add.0: Neg.0, Mul.0: Neg.0, Add.0: Mul.0, Squeeze{axes=[0, 1]}.0: Mul.0, Matmul.0: ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0: Matmul.0, Squeeze{axis=1}.0: Squeeze{axis=0}.0, Matmul.0: ExpandDims{axis=1}.0, Transpose{axes=[1, 0]}.0: Matmul.0, Sum{axis=0}.0: Neg.0, Log.0: Second.0, ExtractDiag{offset=0, axis1=0, axis2=1, view=True}.0: True_div.0, Blockwise{Cholesky{lower=True, check_finite=False, on_error='nan', overwrite_a=False}, (m,m)->(m,m)}.0: SetSubtensor{:stop, start:stop}.0, Sub.0: Add.0, Scan{scan_fn, while_loop=False, inplace=none}.0: Neg.0, MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0: Add.0, success: <DisconnectedType>}\u001b[39m\n        _wrt \u001b[34m= \u001b[39m\u001b[34m[mu]\u001b[39m\n        cost_name \u001b[34m= \u001b[39m\u001b[34m'__logp'\u001b[39m\u001b[32m    748\u001b[39m \u001b[43m    \u001b[49m\u001b[43mvar_to_app_to_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrad_dict\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_wrt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcost_name\u001b[49m\n\u001b[32m    749\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    751\u001b[39m rval: MutableSequence[Variable | \u001b[38;5;28;01mNone\u001b[39;00m] = \u001b[38;5;28mlist\u001b[39m(_rval)\n\u001b[32m    753\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(_rval)):\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/gradient.py:1541\u001b[39m, in \u001b[36m_populate_grad_dict\u001b[39m\u001b[34m(var_to_app_to_idx={Sum{axes=None}.0: {Add(Sum{axes=None}.0, Sum{axes=None}.0): [0]}, mu_logprob: {Sum{axes=None}(mu_logprob): [0]}, Sub.0: {Check{posdef covariance}(Sub.0, ScalarFromTensor.0): [0]}, Sub.0: {Sub(Sub.0, Sum{axis=0}.0): [0]}, Mul.0: {Sub(Mul.0, Mul.0): [1]}, Subtensor{i}.0: {Mul(0.5, Subtensor{i}.0): [1]}, Sum{axis=1}.0: {Subtensor{i}(Sum{axis=1}.0, 0): [0]}, Pow.0: {Sum{axis=1}(Pow.0): [0]}, Blockwise{SolveTriangular{unit_diagonal=False, l..., b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0: {Pow(Blockwise{SolveTriangular{unit_diagonal=Fals...e}, (m,m),(m)->(m)}.0, ExpandDims{axes=[0, 1]}.0): [0]}, Sub.0: {Blockwise{SolveTriangular{unit_diagonal=False, l...se}, (m,m),(m)->(m)}(ExpandDims{axis=0}.0, Sub.0): [1]}, ...}, grad_dict={__logp: Second.0, Sum{axes=None}.0: Second.0, mu_logprob: (d__logp/dmu_logprob), Sub.0: (d__logp/dmu_logprob), Sub.0: (d__logp/dmu_logprob), Mul.0: Neg.0, Subtensor{i}.0: Mul.0, Sum{axis=1}.0: IncSubtensor{i}.0, Pow.0: Second.0, Blockwise{SolveTriangular{unit_diagonal=False, l..., b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}.0: Mul.0, ...}, wrt=[mu], cost_name='__logp')\u001b[39m\n\u001b[32m   1538\u001b[39m     \u001b[38;5;66;03m# end if cache miss\u001b[39;00m\n\u001b[32m   1539\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m grad_dict[var]\n\u001b[32m-> \u001b[39m\u001b[32m1541\u001b[39m rval = [\u001b[43maccess_grad_cache\u001b[49m\u001b[43m(\u001b[49m\u001b[43melem\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m elem \u001b[38;5;129;01min\u001b[39;00m wrt]\n        wrt \u001b[34m= \u001b[39m\u001b[34m[mu]\u001b[39m\u001b[32m   1543\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m rval\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/gradient.py:1496\u001b[39m, in \u001b[36m_populate_grad_dict.<locals>.access_grad_cache\u001b[39m\u001b[34m(var=mu)\u001b[39m\n\u001b[32m   1494\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m node \u001b[38;5;129;01min\u001b[39;00m node_to_idx:\n\u001b[32m   1495\u001b[39m     \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m node_to_idx[node]:\n\u001b[32m-> \u001b[39m\u001b[32m1496\u001b[39m         term = \u001b[43maccess_term_cache\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnode\u001b[49m\u001b[43m)\u001b[49m[idx]\n        node \u001b[34m= \u001b[39m\u001b[34mExpandDims{axis=0}(mu)\u001b[39m\n        idx \u001b[34m= \u001b[39m\u001b[34m0\u001b[39m\n        term \u001b[34m= \u001b[39m\u001b[34mSqueeze{axis=0}.0\u001b[39m\u001b[32m   1498\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(term, Variable):\n\u001b[32m   1499\u001b[39m             \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[32m   1500\u001b[39m                 \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnode.op\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m.grad returned \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(term)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m, expected\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   1501\u001b[39m                 \u001b[33m\"\u001b[39m\u001b[33m Variable instance.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   1502\u001b[39m             )\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/gradient.py:1171\u001b[39m, in \u001b[36m_populate_grad_dict.<locals>.access_term_cache\u001b[39m\u001b[34m(node=ExpandDims{axis=0}(mu))\u001b[39m\n\u001b[32m   1168\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m node \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m term_dict:\n\u001b[32m   1169\u001b[39m     inputs = node.inputs\n\u001b[32m-> \u001b[39m\u001b[32m1171\u001b[39m     output_grads = [\u001b[43maccess_grad_cache\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvar\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m var \u001b[38;5;129;01min\u001b[39;00m node.outputs]\n        node \u001b[34m= \u001b[39m\u001b[34mExpandDims{axis=0}(mu)\u001b[39m\n        node.outputs \u001b[34m= \u001b[39m\u001b[34m[ExpandDims{axis=0}.0]\u001b[39m\u001b[32m   1173\u001b[39m     \u001b[38;5;66;03m# list of bools indicating if each output is connected to the cost\u001b[39;00m\n\u001b[32m   1174\u001b[39m     outputs_connected = [\n\u001b[32m   1175\u001b[39m         \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(g.type, DisconnectedType) \u001b[38;5;28;01mfor\u001b[39;00m g \u001b[38;5;129;01min\u001b[39;00m output_grads\n\u001b[32m   1176\u001b[39m     ]\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/gradient.py:1496\u001b[39m, in \u001b[36m_populate_grad_dict.<locals>.access_grad_cache\u001b[39m\u001b[34m(var=ExpandDims{axis=0}.0)\u001b[39m\n\u001b[32m   1494\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m node \u001b[38;5;129;01min\u001b[39;00m node_to_idx:\n\u001b[32m   1495\u001b[39m     \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m node_to_idx[node]:\n\u001b[32m-> \u001b[39m\u001b[32m1496\u001b[39m         term = \u001b[43maccess_term_cache\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnode\u001b[49m\u001b[43m)\u001b[49m[idx]\n        node \u001b[34m= \u001b[39m\u001b[34mMinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False)([0.2273360 ... .79736546], ScalarFromTensor.0, Sum{axis=1}.0, ExpandDims{axes=[0, 1]}.0, Switch.0, ExpandDims{axis=0}.0, ScalarFromTensor.0, Sum{axis=0}.0, ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0)\u001b[39m\n        idx \u001b[34m= \u001b[39m\u001b[34m9\u001b[39m\u001b[32m   1498\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(term, Variable):\n\u001b[32m   1499\u001b[39m             \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[32m   1500\u001b[39m                 \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnode.op\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m.grad returned \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(term)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m, expected\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   1501\u001b[39m                 \u001b[33m\"\u001b[39m\u001b[33m Variable instance.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   1502\u001b[39m             )\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/gradient.py:1326\u001b[39m, in \u001b[36m_populate_grad_dict.<locals>.access_term_cache\u001b[39m\u001b[34m(node=MinimizeOp(method=L-BFGS-B, jac=True, hess=False...]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0))\u001b[39m\n\u001b[32m   1318\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m o_shape != g_shape:\n\u001b[32m   1319\u001b[39m             \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m   1320\u001b[39m                 \u001b[33m\"\u001b[39m\u001b[33mGot a gradient of shape \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   1321\u001b[39m                 + \u001b[38;5;28mstr\u001b[39m(o_shape)\n\u001b[32m   1322\u001b[39m                 + \u001b[33m\"\u001b[39m\u001b[33m on an output of shape \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   1323\u001b[39m                 + \u001b[38;5;28mstr\u001b[39m(g_shape)\n\u001b[32m   1324\u001b[39m             )\n\u001b[32m-> \u001b[39m\u001b[32m1326\u001b[39m input_grads = \u001b[43mnode\u001b[49m\u001b[43m.\u001b[49m\u001b[43mop\u001b[49m\u001b[43m.\u001b[49m\u001b[43mL_op\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnode\u001b[49m\u001b[43m.\u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnew_output_grads\u001b[49m\u001b[43m)\u001b[49m\n        node \u001b[34m= \u001b[39m\u001b[34mMinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False)([0.2273360 ... .79736546], ScalarFromTensor.0, Sum{axis=1}.0, ExpandDims{axes=[0, 1]}.0, Switch.0, ExpandDims{axis=0}.0, ScalarFromTensor.0, Sum{axis=0}.0, ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0)\u001b[39m\n        inputs \u001b[34m= \u001b[39m\u001b[34m[TensorConstant(TensorType(float64, shape=(3,)), data=array([0.2 ... 79736546])), ScalarFromTensor.0, Sum{axis=1}.0, ExpandDims{axes=[0, 1]}.0, Switch.0, ExpandDims{axis=0}.0, ScalarFromTensor.0, Sum{axis=0}.0, ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0]\u001b[39m\n        node.outputs \u001b[34m= \u001b[39m\u001b[34m[MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0, success]\u001b[39m\n        new_output_grads \u001b[34m= \u001b[39m\u001b[34m[Add.0, <DisconnectedType>]\u001b[39m\n        node.op \u001b[34m= \u001b[39m\u001b[34mMinimizeOp()\u001b[39m\u001b[32m   1328\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m input_grads \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m   1329\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[32m   1330\u001b[39m         \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnode.op\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m.grad returned NoneType, expected iterable.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   1331\u001b[39m     )\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/tensor/optimize.py:565\u001b[39m, in \u001b[36mMinimizeOp.L_op\u001b[39m\u001b[34m(self=MinimizeOp(), inputs=[TensorConstant(TensorType(float64, shape=(3,)), data=array([0.2 ... 79736546])), ScalarFromTensor.0, Sum{axis=1}.0, ExpandDims{axes=[0, 1]}.0, Switch.0, ExpandDims{axis=0}.0, ScalarFromTensor.0, Sum{axis=0}.0, ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0], outputs=[MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0, success], output_grads=[Add.0, <DisconnectedType>])\u001b[39m\n\u001b[32m    560\u001b[39m implicit_f = grad(inner_fx, inner_x)\n\u001b[32m    562\u001b[39m df_dx, *df_dtheta_columns = jacobian(\n\u001b[32m    563\u001b[39m     implicit_f, [inner_x, *inner_args], disconnected_inputs=\u001b[33m\"\u001b[39m\u001b[33mignore\u001b[39m\u001b[33m\"\u001b[39m, vectorize=\u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m    564\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m565\u001b[39m grad_wrt_args = \u001b[43mimplict_optimization_grads\u001b[49m\u001b[43m(\u001b[49m\n        df_dx \u001b[34m= \u001b[39m\u001b[34mAdd.0\u001b[39m\n        df_dtheta_columns \u001b[34m= \u001b[39m\u001b[34m[Alloc.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, Alloc.0, Add.0, Neg.0, Add.0]\u001b[39m\n        args \u001b[34m= \u001b[39m\u001b[34m[ScalarFromTensor.0, Sum{axis=1}.0, ExpandDims{axes=[0, 1]}.0, Switch.0, ExpandDims{axis=0}.0, ScalarFromTensor.0, Sum{axis=0}.0, ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0]\u001b[39m\n        x_star \u001b[34m= \u001b[39m\u001b[34mMinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0\u001b[39m\n        output_grad \u001b[34m= \u001b[39m\u001b[34mAdd.0\u001b[39m\n        self.fgraph \u001b[34m= \u001b[39m\u001b[34mFunctionGraph(*4 -> Neg(Sum{axes=None}(*6 -> MakeVector{dtype='float64'}(Sum{axes=None}(*10 -> Check{posdef covariance}(Sub(Sub(Mul(Mul(-0.5, Cast{float64}(Subtensor{i}(Shape(x), -1))), 1.8378770664093453), Mul(0.5, Subtensor{i}(*9 -> Sum{axis=1}(*1 -> Pow(*3 -> Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}(<Tensor3(float64, shape=(1, 3, 3))>, Sub(ExpandDims{axis=0}(x), <Matrix(float64, shape=(1, 3))>)), <Matrix(int8, shape=(1, 1))>)), 0))), <Scalar(float64, shape=())>), <bool>)), Sum{axes=None}(*8 -> Check{posdef covariance}(Sub(Sub(ExpandDims{axis=0}(Mul(Mul(-0.5, Cast{float64}(Subtensor{i}(Shape(y{[[-0.69153 ... 5232307 ]]}), -1))), 1.8378770664093453)), Mul(<Vector(float32, shape=(1,))>, Sum{axis=1}(*2 -> Pow(*5 -> Blockwise{SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}(<Tensor3(float64, shape=(1, 3, 3))>, Sub(y{[[-0.69153 ... 5232307 ]]}, ExpandDims{axis=0}(x))), <Matrix(int8, shape=(1, 1))>)))), <Vector(float64, shape=(1,))>), <bool>))))), Add(Squeeze{axis=0}(Blockwise{SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}(Transpose{axes=[0, 2, 1]}(<Tensor3(float64, shape=(1, 3, 3))>), Mul(Mul(Second(*1, ExpandDims{axis=1}(IncSubtensor{i}(Second(*9, ExpandDims{axis=0}(0.0)), Mul(Neg(Second(*10, Subtensor{i}(*7 -> Second(*6, ExpandDims{axis=0}(Neg(Second(*4, 1.0)))), 0))), 0.5), 0))), <Matrix(int8, shape=(1, 1))>), Pow(*3, Sub(<Matrix(int8, shape=(1, 1))>, ExpandDims{axes=[0, 1]}(1)))))), Squeeze{axis=0}(ExpandDims{axis=0}(Sum{axis=0}(Neg(Blockwise{SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=1, overwrite_b=False}, (m,m),(m)->(m)}(Transpose{axes=[0, 2, 1]}(<Tensor3(float64, shape=(1, 3, 3))>), Mul(Mul(Second(*2, ExpandDims{axis=1}(Mul(Neg(Second(*8, ExpandDims{axis=0}(Subtensor{i}(*7, 1)))), <Vector(float32, shape=(1,))>))), <Matrix(int8, shape=(1, 1))>), Pow(*5, Sub(<Matrix(int8, shape=(1, 1))>, ExpandDims{axes=[0, 1]}(1)))))))))))\u001b[39m\n        self \u001b[34m= \u001b[39m\u001b[34mMinimizeOp()\u001b[39m\u001b[32m    566\u001b[39m \u001b[43m    \u001b[49m\u001b[43mdf_dx\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdf_dx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    567\u001b[39m \u001b[43m    \u001b[49m\u001b[43mdf_dtheta_columns\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdf_dtheta_columns\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    568\u001b[39m \u001b[43m    \u001b[49m\u001b[43margs\u001b[49m\u001b[43m=\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    569\u001b[39m \u001b[43m    \u001b[49m\u001b[43mx_star\u001b[49m\u001b[43m=\u001b[49m\u001b[43mx_star\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    570\u001b[39m \u001b[43m    \u001b[49m\u001b[43moutput_grad\u001b[49m\u001b[43m=\u001b[49m\u001b[43moutput_grad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    571\u001b[39m \u001b[43m    \u001b[49m\u001b[43mfgraph\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    572\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    574\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m [zeros_like(x), *grad_wrt_args]\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/tensor/optimize.py:333\u001b[39m, in \u001b[36mimplict_optimization_grads\u001b[39m\u001b[34m(df_dx=Add.0, df_dtheta_columns=[Alloc.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, Alloc.0, Add.0, Neg.0, Add.0], args=[ScalarFromTensor.0, Sum{axis=1}.0, ExpandDims{axes=[0, 1]}.0, Switch.0, ExpandDims{axis=0}.0, ScalarFromTensor.0, Sum{axis=0}.0, ExpandDims{axes=[0, 1]}.0, ExpandDims{axis=0}.0, ExpandDims{axis=0}.0], x_star=MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0, output_grad=Add.0, fgraph=FunctionGraph(*4 -> Neg(Sum{axes=None}(*6 -> Mak...pe=(1, 1))>, ExpandDims{axes=[0, 1]}(1))))))))))))\u001b[39m\n\u001b[32m    290\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33mr\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    291\u001b[39m \u001b[33;03mCompute gradients of an optimization problem with respect to its parameters.\u001b[39;00m\n\u001b[32m    292\u001b[39m \n\u001b[32m   (...)\u001b[39m\u001b[32m    329\u001b[39m \u001b[33;03m    The function graph that contains the inputs and outputs of the optimization problem.\u001b[39;00m\n\u001b[32m    330\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    331\u001b[39m df_dx = cast(TensorVariable, df_dx)\n\u001b[32m--> \u001b[39m\u001b[32m333\u001b[39m df_dtheta = \u001b[43mconcatenate\u001b[49m\u001b[43m(\u001b[49m\n        atleast_2d \u001b[34m= \u001b[39m\u001b[34mfunctools.partial(<function atleast_Nd at 0x7f07dc686de0>, n=2)\u001b[39m\n        TensorVariable \u001b[34m= \u001b[39m\u001b[34m<class 'pytensor.tensor.variable.TensorVariable'>\u001b[39m\n        df_dtheta_columns \u001b[34m= \u001b[39m\u001b[34m[Alloc.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, Alloc.0, Add.0, Neg.0, Add.0]\u001b[39m\u001b[32m    334\u001b[39m \u001b[43m    \u001b[49m\u001b[43m[\u001b[49m\n\u001b[32m    335\u001b[39m \u001b[43m        \u001b[49m\u001b[43matleast_2d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mjac_col\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mleft\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m    336\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mjac_col\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mcast\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mTensorVariable\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdf_dtheta_columns\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    337\u001b[39m \u001b[43m    \u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    338\u001b[39m \u001b[43m    \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m=\u001b[49m\u001b[43m-\u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m    339\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    341\u001b[39m replace = \u001b[38;5;28mdict\u001b[39m(\u001b[38;5;28mzip\u001b[39m(fgraph.inputs, (x_star, *args), strict=\u001b[38;5;28;01mTrue\u001b[39;00m))\n\u001b[32m    343\u001b[39m df_dx_star, df_dtheta_star = cast(\n\u001b[32m    344\u001b[39m     \u001b[38;5;28mlist\u001b[39m[TensorVariable],\n\u001b[32m    345\u001b[39m     graph_replace([atleast_2d(df_dx), df_dtheta], replace=replace),\n\u001b[32m    346\u001b[39m )\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/tensor/basic.py:2997\u001b[39m, in \u001b[36mconcatenate\u001b[39m\u001b[34m(tensor_list=[ExpandDims{axis=1}.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, ExpandDims{axis=1}.0, Add.0, Neg.0, Add.0], axis=-1)\u001b[39m\n\u001b[32m   2990\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tensor_list, \u001b[38;5;28mtuple\u001b[39m | \u001b[38;5;28mlist\u001b[39m):\n\u001b[32m   2991\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[32m   2992\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mThe \u001b[39m\u001b[33m'\u001b[39m\u001b[33mtensors\u001b[39m\u001b[33m'\u001b[39m\u001b[33m argument must be either a tuple \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   2993\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mor a list, make sure you did not forget () or [] around \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   2994\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33marguments of concatenate.\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m   2995\u001b[39m         tensor_list,\n\u001b[32m   2996\u001b[39m     )\n\u001b[32m-> \u001b[39m\u001b[32m2997\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43mtensor_list\u001b[49m\u001b[43m)\u001b[49m\n        axis \u001b[34m= \u001b[39m\u001b[34m-1\u001b[39m\n        tensor_list \u001b[34m= \u001b[39m\u001b[34m[ExpandDims{axis=1}.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, ExpandDims{axis=1}.0, Add.0, Neg.0, Add.0]\u001b[39m",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/tensor/basic.py:2811\u001b[39m, in \u001b[36mjoin\u001b[39m\u001b[34m(axis=-1, *tensors_list=(ExpandDims{axis=1}.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, ExpandDims{axis=1}.0, Add.0, Neg.0, Add.0))\u001b[39m\n\u001b[32m   2809\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m tensors_list[\u001b[32m0\u001b[39m]\n\u001b[32m   2810\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m2811\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_join\u001b[49m\u001b[43m(\u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43mtensors_list\u001b[49m\u001b[43m)\u001b[49m\n        tensors_list \u001b[34m= \u001b[39m\u001b[34m(ExpandDims{axis=1}.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, ExpandDims{axis=1}.0, Add.0, Neg.0, Add.0)\u001b[39m\n        _join \u001b[34m= \u001b[39m\u001b[34mJoin()\u001b[39m\n        axis \u001b[34m= \u001b[39m\u001b[34m-1\u001b[39m",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/graph/op.py:293\u001b[39m, in \u001b[36mOp.__call__\u001b[39m\u001b[34m(self=Join(), name=None, return_list=False, *inputs=(-1, ExpandDims{axis=1}.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, ExpandDims{axis=1}.0, Add.0, Neg.0, Add.0), **kwargs={})\u001b[39m\n\u001b[32m    249\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__call__\u001b[39m(\n\u001b[32m    250\u001b[39m     \u001b[38;5;28mself\u001b[39m, *inputs: Any, name=\u001b[38;5;28;01mNone\u001b[39;00m, return_list=\u001b[38;5;28;01mFalse\u001b[39;00m, **kwargs\n\u001b[32m    251\u001b[39m ) -> Variable | \u001b[38;5;28mlist\u001b[39m[Variable]:\n\u001b[32m    252\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33mr\u001b[39m\u001b[33;03m\"\"\"Construct an `Apply` node using :meth:`Op.make_node` and return its outputs.\u001b[39;00m\n\u001b[32m    253\u001b[39m \n\u001b[32m    254\u001b[39m \u001b[33;03m    This method is just a wrapper around :meth:`Op.make_node`.\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    291\u001b[39m \n\u001b[32m    292\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m293\u001b[39m     node = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmake_node\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n        self \u001b[34m= \u001b[39m\u001b[34mJoin()\u001b[39m\n        inputs \u001b[34m= \u001b[39m\u001b[34m(-1, ExpandDims{axis=1}.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, ExpandDims{axis=1}.0, Add.0, Neg.0, Add.0)\u001b[39m\n        kwargs \u001b[34m= \u001b[39m\u001b[34m{}\u001b[39m\u001b[32m    294\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m    295\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(node.outputs) == \u001b[32m1\u001b[39m:\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/git/pytensor/pytensor/tensor/basic.py:2504\u001b[39m, in \u001b[36mJoin.make_node\u001b[39m\u001b[34m(self=Join(), axis=TensorConstant(TensorType(int8, shape=()), data=array(1, dtype=int8)), *tensors=[ExpandDims{axis=1}.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, ExpandDims{axis=1}.0, Add.0, Neg.0, Add.0])\u001b[39m\n\u001b[32m   2501\u001b[39m ndim = tensors[\u001b[32m0\u001b[39m].type.ndim\n\u001b[32m   2503\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m builtins.all(x.ndim == ndim \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m tensors):\n\u001b[32m-> \u001b[39m\u001b[32m2504\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n        tensors \u001b[34m= \u001b[39m\u001b[34m[ExpandDims{axis=1}.0, Alloc.0, Add.0, Add.0, ExpandDims{axis=1}.0, Cast{float64}.0, ExpandDims{axis=1}.0, Add.0, Neg.0, Add.0]\u001b[39m\u001b[32m   2505\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mOnly tensors with the same number of dimensions can be joined. \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   2506\u001b[39m         \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mInput ndims were: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m[x.ndim\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mfor\u001b[39;00m\u001b[38;5;250m \u001b[39mx\u001b[38;5;250m \u001b[39m\u001b[38;5;129;01min\u001b[39;00m\u001b[38;5;250m \u001b[39mtensors]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m   2507\u001b[39m     )\n\u001b[32m   2509\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m   2510\u001b[39m     static_axis = \u001b[38;5;28mint\u001b[39m(get_scalar_constant_value(axis))\n",
+      "\u001b[31mTypeError\u001b[39m: Only tensors with the same number of dimensions can be joined. Input ndims were: [2, 2, 3, 4, 2, 2, 2, 3, 3, 4]"
+     ]
+    }
+   ],
+   "source": [
+    "print((mu_mu + mu_true) / 2)\n",
+    "\n",
+    "with model as m:\n",
+    "    idata = pmx.fit(method=\"INLA\", x=x, temp_kwargs=[n, y_obs], return_latent_posteriors=False)\n",
+    "\n",
+    "az.plot_posterior(idata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "93dbf1e3-0242-4da8-aa2f-62c5541f14cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<!-- Generated by graphviz version 13.0.1 (20250616.1512)\n",
+       " -->\n",
+       "<!-- Pages: 1 -->\n",
+       "<svg width=\"268pt\" height=\"283pt\"\n",
+       " viewBox=\"0.00 0.00 268.00 283.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 279.5)\">\n",
+       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-279.5 264,-279.5 264,4 -4,4\"/>\n",
+       "<g id=\"clust1\" class=\"cluster\">\n",
+       "<title>cluster3</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M20,-141.75C20,-141.75 240,-141.75 240,-141.75 246,-141.75 252,-147.75 252,-153.75 252,-153.75 252,-255.5 252,-255.5 252,-261.5 246,-267.5 240,-267.5 240,-267.5 20,-267.5 20,-267.5 14,-267.5 8,-261.5 8,-255.5 8,-255.5 8,-153.75 8,-153.75 8,-147.75 14,-141.75 20,-141.75\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"239.5\" y=\"-149.7\" font-family=\"Times,serif\" font-size=\"14.00\">3</text>\n",
+       "</g>\n",
+       "<g id=\"clust2\" class=\"cluster\">\n",
+       "<title>cluster10000 x 3</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M38,-8C38,-8 222,-8 222,-8 228,-8 234,-14 234,-20 234,-20 234,-121.75 234,-121.75 234,-127.75 228,-133.75 222,-133.75 222,-133.75 38,-133.75 38,-133.75 32,-133.75 26,-127.75 26,-121.75 26,-121.75 26,-20 26,-20 26,-14 32,-8 38,-8\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"190.38\" y=\"-15.95\" font-family=\"Times,serif\" font-size=\"14.00\">10000 x 3</text>\n",
+       "</g>\n",
+       "<!-- mu_param -->\n",
+       "<g id=\"node1\" class=\"node\">\n",
+       "<title>mu_param</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"130\" cy=\"-217.25\" rx=\"114.2\" ry=\"42.25\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-229.82\" font-family=\"Times,serif\" font-size=\"14.00\">mu_param</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-212.57\" font-family=\"Times,serif\" font-size=\"14.00\">~</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-195.32\" font-family=\"Times,serif\" font-size=\"14.00\">Multivariate_normal</text>\n",
+       "</g>\n",
+       "<!-- y -->\n",
+       "<g id=\"node2\" class=\"node\">\n",
+       "<title>y</title>\n",
+       "<ellipse fill=\"lightgrey\" stroke=\"black\" cx=\"130\" cy=\"-83.5\" rx=\"95.64\" ry=\"42.25\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-96.07\" font-family=\"Times,serif\" font-size=\"14.00\">y</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-78.82\" font-family=\"Times,serif\" font-size=\"14.00\">~</text>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"130\" y=\"-61.57\" font-family=\"Times,serif\" font-size=\"14.00\">MarginalLaplace</text>\n",
+       "</g>\n",
+       "<!-- mu_param&#45;&gt;y -->\n",
+       "<g id=\"edge1\" class=\"edge\">\n",
+       "<title>mu_param&#45;&gt;y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M130,-174.56C130,-162.67 130,-149.56 130,-137.11\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"133.5,-137.43 130,-127.43 126.5,-137.43 133.5,-137.43\"/>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "<graphviz.graphs.Digraph at 0x7fee0e8a3c50>"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "minimizer_kwargs = {\"method\": \"L-BFGS-B\", \"optimizer_kwargs\": {\"tol\": 1e-8}}\n",
+    "kwargs = {\"Q\": Q_val, \"temp_kwargs\": None, \"minimizer_kwargs\": minimizer_kwargs}\n",
+    "\n",
+    "model_marg = marginalize(model, x, use_inla=True, **kwargs)\n",
+    "pm.model_to_graphviz(model_marg, var_names=[\"y\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "41d721e1-fdd4-4d58-95b7-bc978c468ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rng = np.random.default_rng(12345)\n",
+    "mu = rng.random(d)\n",
+    "\n",
+    "f_logp = model_marg.compile_logp(profile=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "41b19afc-dc41-4e6a-908f-41f9fd06f188",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "11.4 ms ± 2.39 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "f_logp({\"mu_param\": mu})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "8440ca77-e7c8-40ba-a106-40fef8b87d34",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Function profiling\n",
+      "==================\n",
+      "  Message: /home/michaln/git/pymc/pymc/pytensorf.py:942\n",
+      "  Time in 811 calls to Function.__call__: 7.526662e+00s\n",
+      "  Time in Function.vm.__call__: 7.505440152948722s (99.718%)\n",
+      "  Time in thunks: 7.487781524658203s (99.483%)\n",
+      "  Total compilation time: 2.368786e+00s\n",
+      "    Number of Apply nodes: 29\n",
+      "    PyTensor rewrite time: 1.740722e+00s\n",
+      "       PyTensor validate time: 6.187005e-03s\n",
+      "    PyTensor Linker time (includes C, CUDA code generation/compiling): 0.6244314390060026s\n",
+      "       C-cache preloading 3.356296e-03s\n",
+      "       Import time 4.223835e-02s\n",
+      "       Node make_thunk time 6.202545e-01s\n",
+      "           Node MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False)([0.2273360 ... .79736546], True, [0.], [[2]], [[[1. 0. 0 ... . 0. 1.]]], [0.5], True, 0.0, [[2]], ExpandDims{axis=0}.0, [[[1. 0. 0 ... . 0. 1.]]]) time 5.042768e-01s\n",
+      "           Node Scan{scan_fn, while_loop=False, inplace=none}(3, [0 1 2], 3, Neg.0, Neg.0) time 8.727831e-02s\n",
+      "           Node CAReduce{Composite{(i0 + sqr(i1))}, axis=1}(Transpose{axes=[1, 0]}.0) time 2.509011e-03s\n",
+      "           Node Sub(ExpandDims{axis=1}.0, ExpandDims{axis=1}.0) time 2.409338e-03s\n",
+      "           Node Neg(Sum{axis=0}.0) time 2.064528e-03s\n",
+      "\n",
+      "Time in all call to pytensor.grad() 2.629620e-01s\n",
+      "Time since pytensor import 43.737s\n",
+      "Class\n",
+      "---\n",
+      "<% time> <sum %> <apply time> <time per call> <type> <#call> <#apply> <Class name>\n",
+      "  83.9%    83.9%       6.279s       7.74e-03s     Py     811       1   pytensor.tensor.optimize.MinimizeOp\n",
+      "  10.0%    93.9%       0.749s       9.24e-04s     Py     811       1   pytensor.scan.op.Scan\n",
+      "   3.8%    97.7%       0.284s       8.76e-05s     Py    3244       4   pytensor.tensor.slinalg.SolveTriangular\n",
+      "   0.7%    98.4%       0.054s       3.30e-05s     C     1622       2   pytensor.tensor.math.Sum\n",
+      "   0.7%    99.1%       0.053s       8.14e-06s     C     6488       8   pytensor.tensor.elemwise.Elemwise\n",
+      "   0.5%    99.6%       0.036s       1.48e-05s     C     2433       3   pytensor.tensor.elemwise.CAReduce\n",
+      "   0.4%    99.9%       0.028s       3.43e-05s     Py     811       1   pytensor.tensor.nlinalg.SLogDet\n",
+      "   0.1%   100.0%       0.005s       6.41e-07s     C     7299       9   pytensor.tensor.elemwise.DimShuffle\n",
+      "   ... (remaining 0 Classes account for   0.00%(0.00s) of the runtime)\n",
+      "\n",
+      "Ops\n",
+      "---\n",
+      "<% time> <sum %> <apply time> <time per call> <type> <#call> <#apply> <Op name>\n",
+      "  83.9%    83.9%       6.279s       7.74e-03s     Py     811        1   MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False)\n",
+      "  10.0%    93.9%       0.749s       9.24e-04s     Py     811        1   Scan{scan_fn, while_loop=False, inplace=none}\n",
+      "   2.6%    96.5%       0.194s       1.20e-04s     Py    1622        2   SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=2, overwrite_b=True}\n",
+      "   1.0%    97.5%       0.075s       9.23e-05s     Py     811        1   SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=2, overwrite_b=True}\n",
+      "   0.6%    98.1%       0.045s       5.55e-05s     C      811        1   Sum{axis=0}\n",
+      "   0.5%    98.5%       0.036s       1.48e-05s     C     2433        3   CAReduce{Composite{(i0 + sqr(i1))}, axis=1}\n",
+      "   0.4%    98.9%       0.029s       1.80e-05s     C     1622        2   Sub\n",
+      "   0.4%    99.3%       0.028s       3.43e-05s     Py     811        1   SLogDet\n",
+      "   0.3%    99.6%       0.019s       7.78e-06s     C     2433        3   Neg\n",
+      "   0.2%    99.8%       0.015s       1.86e-05s     Py     811        1   SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=2, overwrite_b=False}\n",
+      "   0.1%    99.9%       0.009s       1.05e-05s     C      811        1   Sum{axes=None}\n",
+      "   0.0%    99.9%       0.003s       4.21e-06s     C      811        1   Composite{(-2.756815599614018 - (0.5 * i0))}\n",
+      "   0.0%    99.9%       0.002s       6.43e-07s     C     3244        4   Transpose{axes=[1, 0]}\n",
+      "   0.0%   100.0%       0.001s       7.32e-07s     C     1622        2   ExpandDims{axis=1}\n",
+      "   0.0%   100.0%       0.001s       5.05e-07s     C     1622        2   Squeeze{axis=0}\n",
+      "   0.0%   100.0%       0.001s       8.36e-07s     C      811        1   Sub\n",
+      "   0.0%   100.0%       0.001s       7.27e-07s     C      811        1   ExpandDims{axis=0}\n",
+      "   0.0%   100.0%       0.001s       7.22e-07s     C      811        1   Composite{((-2.756815599614018 + i3) - ((0.5 * i2) + (0.5 * i1) + (0.5 * i0)))}\n",
+      "   ... (remaining 0 Ops account for   0.00%(0.00s) of the runtime)\n",
+      "\n",
+      "Apply\n",
+      "------\n",
+      "<% time> <sum %> <apply time> <time per call> <#call> <id> <Apply name>\n",
+      "  83.9%    83.9%       6.279s       7.74e-03s    811     2   MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False)([0.2273360 ... .79736546], True, [0.], [[2]], [[[1. 0. 0 ... . 0. 1.]]], [0.5], True, 0.0, [[2]], ExpandDims{axis=0}.0, [[[1. 0. 0 ... . 0. 1.]]])\n",
+      "  10.0%    93.9%       0.749s       9.24e-04s    811    25   Scan{scan_fn, while_loop=False, inplace=none}(3, [0 1 2], 3, Neg.0, Neg.0)\n",
+      "   2.3%    96.2%       0.176s       2.17e-04s    811     9   SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=2, overwrite_b=True}([[1. 0. 0. ... 0. 0. 1.]], Sub.0)\n",
+      "   1.0%    97.2%       0.075s       9.23e-05s    811    18   SolveTriangular{unit_diagonal=False, lower=False, check_finite=True, b_ndim=2, overwrite_b=True}([[1. 0. 0. ... 0. 0. 1.]], Neg.0)\n",
+      "   0.6%    97.8%       0.045s       5.55e-05s    811    22   Sum{axis=0}(Transpose{axes=[1, 0]}.0)\n",
+      "   0.5%    98.3%       0.035s       4.28e-05s    811    14   CAReduce{Composite{(i0 + sqr(i1))}, axis=1}(Transpose{axes=[1, 0]}.0)\n",
+      "   0.4%    98.7%       0.028s       3.44e-05s    811     6   Sub([[-0.42382 ... 6561215 ]], ExpandDims{axis=1}.0)\n",
+      "   0.4%    99.0%       0.028s       3.43e-05s    811    27   SLogDet(Sub.0)\n",
+      "   0.2%    99.3%       0.018s       2.26e-05s    811    11   SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=2, overwrite_b=True}([[1. 0. 0. ... 0. 0. 1.]], Sub.0)\n",
+      "   0.2%    99.5%       0.015s       1.86e-05s    811     3   SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=2, overwrite_b=False}([[1. 0. 0. ... 0. 0. 1.]], ExpandDims{axis=1}.0)\n",
+      "   0.1%    99.6%       0.009s       1.15e-05s    811    23   Neg(Transpose{axes=[1, 0]}.0)\n",
+      "   0.1%    99.7%       0.009s       1.14e-05s    811    15   Neg(SolveTriangular{unit_diagonal=False, lower=True, check_finite=True, b_ndim=2, overwrite_b=True}.0)\n",
+      "   0.1%    99.8%       0.009s       1.05e-05s    811    20   Sum{axes=None}(posdef covariance)\n",
+      "   0.0%    99.9%       0.003s       4.21e-06s    811    17   Composite{(-2.756815599614018 - (0.5 * i0))}(CAReduce{Composite{(i0 + sqr(i1))}, axis=1}.0)\n",
+      "   0.0%    99.9%       0.001s       1.68e-06s    811    26   Sub([[1. 0. 0. ... 0. 0. 1.]], Scan{scan_fn, while_loop=False, inplace=none}.0)\n",
+      "   0.0%    99.9%       0.001s       1.04e-06s    811    16   CAReduce{Composite{(i0 + sqr(i1))}, axis=1}(Transpose{axes=[1, 0]}.0)\n",
+      "   0.0%    99.9%       0.001s       8.36e-07s    811     8   Sub(ExpandDims{axis=1}.0, ExpandDims{axis=1}.0)\n",
+      "   0.0%    99.9%       0.001s       7.88e-07s    811     4   ExpandDims{axis=1}(MinimizeOp(method=L-BFGS-B, jac=True, hess=False, hessp=False).0)\n",
+      "   0.0%    99.9%       0.001s       7.27e-07s    811     0   ExpandDims{axis=0}(mu_param)\n",
+      "   0.0%    99.9%       0.001s       7.22e-07s    811    28   Composite{((-2.756815599614018 + i3) - ((0.5 * i2) + (0.5 * i1) + (0.5 * i0)))}(SLogDet.1, Squeeze{axis=0}.0, Squeeze{axis=0}.0, Sum{axes=None}.0)\n",
+      "   ... (remaining 9 Apply instances account for 0.06%%(0.00s) of the runtime)\n",
+      "\n",
+      "\n",
+      "Scan overhead:\n",
+      "<Scan op time(s)> <sub scan fct time(s)> <sub scan op time(s)> <sub scan fct time(% scan op time)> <sub scan op time(% scan op time)> <node>\n",
+      "  One scan node do not have its inner profile enabled. If you enable PyTensor profiler with 'pytensor.function(..., profile=True)', you must manually enable the profiling for each scan too: 'pytensor.scan(...,profile=True)'. Or use PyTensor flag 'profile=True'.\n",
+      "  No scan have its inner profile enabled.\n",
+      "Here are tips to potentially make your code run faster\n",
+      "                 (if you think of new ones, suggest them on the mailing list).\n",
+      "                 Test them first, as they are not guaranteed to always provide a speedup.\n",
+      "  - Try the PyTensor flag floatX=float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "f_logp.f.profile.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e344b7d0-f76e-4a28-9be9-884a2ba1f2c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
+      "platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0 -- /home/michaln/git/pymc-extras/.pixi/envs/default/bin/python\n",
+      "cachedir: .pytest_cache\n",
+      "rootdir: /home/michaln/git/pymc-extras\n",
+      "configfile: pyproject.toml\n",
+      "plugins: anyio-4.9.0\n",
+      "collected 0 items                                                              \u001b[0m\n",
+      "\n",
+      "\u001b[33m============================ \u001b[33mno tests ran\u001b[0m\u001b[33m in 0.00s\u001b[0m\u001b[33m =============================\u001b[0m\n",
+      "\u001b[31mERROR: file or directory not found: /home/michaln/Michal_Linux/git/GSoC/pymc-extras/tests/test_inla.py\n",
+      "\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "!python -m pytest -v /home/michaln/Michal_Linux/git/GSoC/pymc-extras/tests/test_inla.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "f1eb9a04-15dd-437d-bcf0-ce369feec912",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
+      "platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0 -- /home/michaln/git/pymc-extras/.pixi/envs/default/bin/python\n",
+      "cachedir: .pytest_cache\n",
+      "rootdir: /home/michaln/git/pymc-extras\n",
+      "configfile: pyproject.toml\n",
+      "plugins: anyio-4.9.0\n",
+      "collected 3 items                                                              \u001b[0m\u001b[1m\n",
+      "\n",
+      "../tests/test_inla.py::test_non_gaussian_latent \u001b[32mPASSED\u001b[0m\u001b[32m                   [ 33%]\u001b[0m\n",
+      "../tests/test_inla.py::test_non_precision_MvNormal \u001b[31mFAILED\u001b[0m\u001b[31m                [ 66%]\u001b[0m\n",
+      "../tests/test_inla.py::test_3_layer_normal \u001b[31mFAILED\u001b[0m\u001b[31m                        [100%]\u001b[0m\n",
+      "\n",
+      "=================================== FAILURES ===================================\n",
+      "\u001b[31m\u001b[1m_________________________ test_non_precision_MvNormal __________________________\u001b[0m\n",
+      "\n",
+      "rng = Generator(PCG64) at 0x7F6BDC40DC40\n",
+      "\n",
+      "    \u001b[0m\u001b[94mdef\u001b[39;49;00m\u001b[90m \u001b[39;49;00m\u001b[92mtest_non_precision_MvNormal\u001b[39;49;00m(rng):\u001b[90m\u001b[39;49;00m\n",
+      "    \u001b[90m    \u001b[39;49;00m\u001b[33m\"\"\"\u001b[39;49;00m\n",
+      "    \u001b[33m    INLA should raise an error if trying to use a latent not in precision form\u001b[39;49;00m\n",
+      "    \u001b[33m    \"\"\"\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "        n = \u001b[94m10000\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "        d = \u001b[94m3\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "    \u001b[90m\u001b[39;49;00m\n",
+      "        mu_mu = np.zeros((d,))\u001b[90m\u001b[39;49;00m\n",
+      "        mu_true = rng.random(d)\u001b[90m\u001b[39;49;00m\n",
+      "        tau = np.identity(d)\u001b[90m\u001b[39;49;00m\n",
+      "        cov = np.linalg.inv(tau)\u001b[90m\u001b[39;49;00m\n",
+      "        y_obs = rng.multivariate_normal(mean=mu_true, cov=cov, size=n)\u001b[90m\u001b[39;49;00m\n",
+      "    \u001b[90m\u001b[39;49;00m\n",
+      "        \u001b[94mwith\u001b[39;49;00m pm.Model() \u001b[94mas\u001b[39;49;00m model:\u001b[90m\u001b[39;49;00m\n",
+      "            mu = pm.MvNormal(\u001b[33m\"\u001b[39;49;00m\u001b[33mmu\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, mu=mu_mu, tau=tau)\u001b[90m\u001b[39;49;00m\n",
+      "            x = pm.MvNormal(\u001b[33m\"\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, mu=mu, cov=cov)\u001b[90m\u001b[39;49;00m\n",
+      "            y = pm.MvNormal(\u001b[33m\"\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, mu=x, tau=tau, observed=y_obs)\u001b[90m\u001b[39;49;00m\n",
+      "    \u001b[90m\u001b[39;49;00m\n",
+      "            \u001b[94mwith\u001b[39;49;00m pytest.raises(\u001b[96mValueError\u001b[39;49;00m):\u001b[90m\u001b[39;49;00m\n",
+      ">               pmx.fit(method=\u001b[33m\"\u001b[39;49;00m\u001b[33mINLA\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, x=x)\u001b[90m\u001b[39;49;00m\n",
+      "\n",
+      "\u001b[1m\u001b[31m../tests/test_inla.py\u001b[0m:67: \n",
+      "_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n",
+      "\u001b[1m\u001b[31m../pymc_extras/inference/fit.py\u001b[0m:47: in fit\n",
+      "    \u001b[0m\u001b[94mreturn\u001b[39;49;00m fit_INLA(**kwargs)\u001b[90m\u001b[39;49;00m\n",
+      "           ^^^^^^^^^^^^^^^^^^\u001b[90m\u001b[39;49;00m\n",
+      "_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n",
+      "\n",
+      "x = x, temp_kwargs = None, model = None, minimizer_kwargs = None\n",
+      "return_latent_posteriors = True, sampler_kwargs = {}\n",
+      "\n",
+      "    \u001b[0m\u001b[94mdef\u001b[39;49;00m\u001b[90m \u001b[39;49;00m\u001b[92mfit_INLA\u001b[39;49;00m(\u001b[90m\u001b[39;49;00m\n",
+      "        x: TensorVariable,\u001b[90m\u001b[39;49;00m\n",
+      "        temp_kwargs=\u001b[94mNone\u001b[39;49;00m,  \u001b[90m# TODO REMOVE. DEBUGGING TOOL\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "        model: pm.Model | \u001b[94mNone\u001b[39;49;00m = \u001b[94mNone\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n",
+      "        minimizer_kwargs: \u001b[96mdict\u001b[39;49;00m | \u001b[94mNone\u001b[39;49;00m = \u001b[94mNone\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n",
+      "        return_latent_posteriors: \u001b[96mbool\u001b[39;49;00m = \u001b[94mTrue\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n",
+      "        **sampler_kwargs,\u001b[90m\u001b[39;49;00m\n",
+      "    ) -> az.InferenceData:\u001b[90m\u001b[39;49;00m\n",
+      ">       warnings.warn(\u001b[33m'\u001b[39;49;00m\u001b[33mCurrently only valid for a nested normal model. WIP.\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[96mUserWarning\u001b[39;49;00m)\u001b[90m\u001b[39;49;00m\n",
+      "\u001b[1m\u001b[31mE       UserWarning: Currently only valid for a nested normal model. WIP.\u001b[0m\n",
+      "\n",
+      "\u001b[1m\u001b[31m../pymc_extras/inference/inla.py\u001b[0m:151: UserWarning\n",
+      "\u001b[31m\u001b[1m_____________________________ test_3_layer_normal ______________________________\u001b[0m\n",
+      "\n",
+      "rng = Generator(PCG64) at 0x7F6BDC40DC40\n",
+      "\n",
+      "    \u001b[0m\u001b[94mdef\u001b[39;49;00m\u001b[90m \u001b[39;49;00m\u001b[92mtest_3_layer_normal\u001b[39;49;00m(rng):\u001b[90m\u001b[39;49;00m\n",
+      "    \u001b[90m    \u001b[39;49;00m\u001b[33m\"\"\"\u001b[39;49;00m\n",
+      "    \u001b[33m    Test INLA against a simple toy problem:\u001b[39;49;00m\n",
+      "    \u001b[33m\u001b[39;49;00m\n",
+      "    \u001b[33m    mu ~ N(mu_mu, I)\u001b[39;49;00m\n",
+      "    \u001b[33m    x ~ N(mu, I)\u001b[39;49;00m\n",
+      "    \u001b[33m    y ~ N(x, I)\u001b[39;49;00m\n",
+      "    \u001b[33m\u001b[39;49;00m\n",
+      "    \u001b[33m    The mean of the posterior should be the midpoint between mu_mu and mu_true\u001b[39;49;00m\n",
+      "    \u001b[33m    \"\"\"\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "        n = \u001b[94m10000\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "        d = \u001b[94m3\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "    \u001b[90m\u001b[39;49;00m\n",
+      "        mu_mu = \u001b[94m10\u001b[39;49;00m * rng.random(d)\u001b[90m\u001b[39;49;00m\n",
+      "        mu_true = rng.random(d)\u001b[90m\u001b[39;49;00m\n",
+      "        tau = np.identity(d)\u001b[90m\u001b[39;49;00m\n",
+      "        cov = np.linalg.inv(tau)\u001b[90m\u001b[39;49;00m\n",
+      "        y_obs = rng.multivariate_normal(mean=mu_true, cov=cov, size=n)\u001b[90m\u001b[39;49;00m\n",
+      "    \u001b[90m\u001b[39;49;00m\n",
+      "        \u001b[94mwith\u001b[39;49;00m pm.Model() \u001b[94mas\u001b[39;49;00m model:\u001b[90m\u001b[39;49;00m\n",
+      "            mu = pm.MvNormal(\u001b[33m\"\u001b[39;49;00m\u001b[33mmu\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, mu=mu_mu, tau=tau)\u001b[90m\u001b[39;49;00m\n",
+      "            x = pm.MvNormal(\u001b[33m\"\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, mu=mu, tau=tau)\u001b[90m\u001b[39;49;00m\n",
+      "            y = pm.MvNormal(\u001b[33m\"\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, mu=x, tau=tau, observed=y_obs)\u001b[90m\u001b[39;49;00m\n",
+      "    \u001b[90m\u001b[39;49;00m\n",
+      ">           idata = pmx.fit(\u001b[90m\u001b[39;49;00m\n",
+      "                method=\u001b[33m\"\u001b[39;49;00m\u001b[33mINLA\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n",
+      "                x=x,\u001b[90m\u001b[39;49;00m\n",
+      "                temp_kwargs=[n, y_obs],  \u001b[90m# TODO REMOVE LATER - DEBUGGING TOOL\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "                return_latent_posteriors=\u001b[94mFalse\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n",
+      "            )\u001b[90m\u001b[39;49;00m\n",
+      "\n",
+      "\u001b[1m\u001b[31m../tests/test_inla.py\u001b[0m:94: \n",
+      "_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n",
+      "\u001b[1m\u001b[31m../pymc_extras/inference/fit.py\u001b[0m:47: in fit\n",
+      "    \u001b[0m\u001b[94mreturn\u001b[39;49;00m fit_INLA(**kwargs)\u001b[90m\u001b[39;49;00m\n",
+      "           ^^^^^^^^^^^^^^^^^^\u001b[90m\u001b[39;49;00m\n",
+      "_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n",
+      "\n",
+      "x = x\n",
+      "temp_kwargs = [10000, array([[-0.92256686,  0.34251042, -1.07012389],\n",
+      "       [ 1.54076702, -0.55042364,  1.023203  ],\n",
+      "       [ 2.251...37462 ,  0.78161016],\n",
+      "       [ 2.21600752, -0.66114102, -0.10427736],\n",
+      "       [ 1.37171357, -0.27766388, -0.73127505]])]\n",
+      "model = None, minimizer_kwargs = None, return_latent_posteriors = False\n",
+      "sampler_kwargs = {}\n",
+      "\n",
+      "    \u001b[0m\u001b[94mdef\u001b[39;49;00m\u001b[90m \u001b[39;49;00m\u001b[92mfit_INLA\u001b[39;49;00m(\u001b[90m\u001b[39;49;00m\n",
+      "        x: TensorVariable,\u001b[90m\u001b[39;49;00m\n",
+      "        temp_kwargs=\u001b[94mNone\u001b[39;49;00m,  \u001b[90m# TODO REMOVE. DEBUGGING TOOL\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n",
+      "        model: pm.Model | \u001b[94mNone\u001b[39;49;00m = \u001b[94mNone\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n",
+      "        minimizer_kwargs: \u001b[96mdict\u001b[39;49;00m | \u001b[94mNone\u001b[39;49;00m = \u001b[94mNone\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n",
+      "        return_latent_posteriors: \u001b[96mbool\u001b[39;49;00m = \u001b[94mTrue\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n",
+      "        **sampler_kwargs,\u001b[90m\u001b[39;49;00m\n",
+      "    ) -> az.InferenceData:\u001b[90m\u001b[39;49;00m\n",
+      ">       warnings.warn(\u001b[33m'\u001b[39;49;00m\u001b[33mCurrently only valid for a nested normal model. WIP.\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[96mUserWarning\u001b[39;49;00m)\u001b[90m\u001b[39;49;00m\n",
+      "\u001b[1m\u001b[31mE       UserWarning: Currently only valid for a nested normal model. WIP.\u001b[0m\n",
+      "\n",
+      "\u001b[1m\u001b[31m../pymc_extras/inference/inla.py\u001b[0m:151: UserWarning\n",
+      "\u001b[36m\u001b[1m=========================== short test summary info ============================\u001b[0m\n",
+      "\u001b[31mFAILED\u001b[0m ../tests/test_inla.py::\u001b[1mtest_non_precision_MvNormal\u001b[0m - UserWarning: Currently only valid for a nested normal model. WIP.\n",
+      "\u001b[31mFAILED\u001b[0m ../tests/test_inla.py::\u001b[1mtest_3_layer_normal\u001b[0m - UserWarning: Currently only valid for a nested normal model. WIP.\n",
+      "\u001b[31m========================= \u001b[31m\u001b[1m2 failed\u001b[0m, \u001b[32m1 passed\u001b[0m\u001b[31m in 2.37s\u001b[0m\u001b[31m ==========================\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "!python -m pytest -v /home/michaln/git/pymc-extras/tests/test_inla.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "427148a1-6c59-4e03-9f37-890656994d64",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pymc_extras/inference/__init__.py b/pymc_extras/inference/__init__.py
index a536f91e..276b9365 100644
--- a/pymc_extras/inference/__init__.py
+++ b/pymc_extras/inference/__init__.py
@@ -13,8 +13,9 @@
 #   limitations under the License.
 
 from pymc_extras.inference.fit import fit
+from pymc_extras.inference.inla import fit_INLA
 from pymc_extras.inference.laplace_approx.find_map import find_MAP
 from pymc_extras.inference.laplace_approx.laplace import fit_laplace
 from pymc_extras.inference.pathfinder.pathfinder import fit_pathfinder
 
-__all__ = ["fit", "fit_pathfinder", "fit_laplace", "find_MAP"]
+__all__ = ["fit", "fit_pathfinder", "fit_laplace", "find_MAP", "fit_INLA"]
diff --git a/pymc_extras/inference/fit.py b/pymc_extras/inference/fit.py
index ac51e76b..c05ad625 100644
--- a/pymc_extras/inference/fit.py
+++ b/pymc_extras/inference/fit.py
@@ -36,7 +36,17 @@ def fit(method: str, **kwargs) -> az.InferenceData:
 
         return fit_pathfinder(**kwargs)
 
-    if method == "laplace":
-        from pymc_extras.inference import fit_laplace
+    elif method == "laplace":
+        from pymc_extras.inference.laplace import fit_laplace
 
         return fit_laplace(**kwargs)
+
+    elif method == "INLA":
+        from pymc_extras.inference.inla import fit_INLA
+
+        return fit_INLA(**kwargs)
+
+    else:
+        raise ValueError(
+            f"method '{method}' not supported. Use one of 'pathfinder', 'laplace' or 'INLA'."
+        )
diff --git a/pymc_extras/inference/inla.py b/pymc_extras/inference/inla.py
new file mode 100644
index 00000000..e17cee0b
--- /dev/null
+++ b/pymc_extras/inference/inla.py
@@ -0,0 +1,54 @@
+import warnings
+
+import arviz as az
+import pymc as pm
+
+from pymc.distributions.multivariate import MvNormal
+from pytensor.tensor import TensorVariable
+from pytensor.tensor.linalg import inv as matrix_inverse
+
+from pymc_extras.model.marginal.marginal_model import marginalize
+
+
+def fit_INLA(
+    x: TensorVariable,
+    temp_kwargs=None,  # TODO REMOVE. DEBUGGING TOOL
+    model: pm.Model | None = None,
+    minimizer_kwargs: dict | None = None,
+    return_latent_posteriors: bool = True,
+    **sampler_kwargs,
+) -> az.InferenceData:
+    warnings.warn("Currently only valid for a nested normal model. WIP.", UserWarning)
+    # TODO ADD CHECK FOR NESTED NORMAL
+
+    model = pm.modelcontext(model)
+
+    # Check if latent field is Gaussian
+    if not isinstance(x.owner.op, MvNormal):
+        raise ValueError(
+            f"Latent field {x} is not instance of MvNormal. Has distribution {x.owner.op}."
+        )
+
+    _, _, _, tau = x.owner.inputs
+
+    # Latent field should use precison rather than covariance
+    if not (tau.owner and tau.owner.op == matrix_inverse):
+        raise ValueError(
+            f"Latent field {x} is not in precision matrix form. Use MvNormal(tau=Q) instead."
+        )
+
+    Q = tau.owner.inputs[0]
+
+    # Marginalize out the latent field
+    minimizer_kwargs = {"method": "L-BFGS-B", "optimizer_kwargs": {"tol": 1e-8}}
+    marginalize_kwargs = {"Q": Q, "temp_kwargs": temp_kwargs, "minimizer_kwargs": minimizer_kwargs}
+    marginal_model = marginalize(model, x, use_laplace=True, **marginalize_kwargs)
+
+    # Sample over the hyperparameters
+    idata = pm.sample(model=marginal_model, **sampler_kwargs)
+
+    if not return_latent_posteriors:
+        return idata
+
+    # TODO Unmarginalize stuff
+    raise NotImplementedError("Latent posteriors not supported yet, WIP.")
diff --git a/pymc_extras/inference/laplace.py b/pymc_extras/inference/laplace.py
new file mode 100644
index 00000000..9c0a0d27
--- /dev/null
+++ b/pymc_extras/inference/laplace.py
@@ -0,0 +1,585 @@
+#   Copyright 2024 The PyMC Developers
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+
+import logging
+
+from functools import reduce
+from importlib.util import find_spec
+from itertools import product
+from typing import Literal
+
+import arviz as az
+import numpy as np
+import pymc as pm
+import pytensor
+import pytensor.tensor as pt
+import xarray as xr
+
+from arviz import dict_to_dataset
+from better_optimize.constants import minimize_method
+from pymc import DictToArrayBijection
+from pymc.backends.arviz import (
+    coords_and_dims_for_inferencedata,
+    find_constants,
+    find_observations,
+)
+from pymc.blocking import RaveledVars
+from pymc.model.transform.conditioning import remove_value_transforms
+from pymc.model.transform.optimization import freeze_dims_and_data
+from pymc.util import get_default_varnames
+from scipy import stats
+
+from pymc_extras.inference.find_map import (
+    GradientBackend,
+    _unconstrained_vector_to_constrained_rvs,
+    find_MAP,
+    get_nearest_psd,
+    scipy_optimize_funcs_from_loss,
+)
+
+_log = logging.getLogger(__name__)
+
+
+def laplace_draws_to_inferencedata(
+    posterior_draws: list[np.ndarray[float | int]], model: pm.Model | None = None
+) -> az.InferenceData:
+    """
+    Convert draws from a posterior estimated with the Laplace approximation to an InferenceData object.
+
+
+    Parameters
+    ----------
+    posterior_draws: list of np.ndarray
+        A list of arrays containing the posterior draws. Each array should have shape (chains, draws, *shape), where
+        shape is the shape of the variable in the posterior.
+    model: Model, optional
+        A PyMC model. If None, the model is taken from the current model context.
+
+    Returns
+    -------
+    idata: az.InferenceData
+        An InferenceData object containing the approximated posterior samples
+    """
+    model = pm.modelcontext(model)
+    chains, draws, *_ = posterior_draws[0].shape
+
+    def make_rv_coords(name):
+        coords = {"chain": range(chains), "draw": range(draws)}
+        extra_dims = model.named_vars_to_dims.get(name)
+        if extra_dims is None:
+            return coords
+        return coords | {dim: list(model.coords[dim]) for dim in extra_dims}
+
+    def make_rv_dims(name):
+        dims = ["chain", "draw"]
+        extra_dims = model.named_vars_to_dims.get(name)
+        if extra_dims is None:
+            return dims
+        return dims + list(extra_dims)
+
+    names = [
+        x.name for x in get_default_varnames(model.unobserved_value_vars, include_transformed=False)
+    ]
+    idata = {
+        name: xr.DataArray(
+            data=draws,
+            coords=make_rv_coords(name),
+            dims=make_rv_dims(name),
+            name=name,
+        )
+        for name, draws in zip(names, posterior_draws)
+    }
+
+    coords, dims = coords_and_dims_for_inferencedata(model)
+    idata = az.convert_to_inference_data(idata, coords=coords, dims=dims)
+
+    return idata
+
+
+def add_fit_to_inferencedata(
+    idata: az.InferenceData, mu: RaveledVars, H_inv: np.ndarray, model: pm.Model | None = None
+) -> az.InferenceData:
+    """
+    Add the mean vector and covariance matrix of the Laplace approximation to an InferenceData object.
+
+
+    Parameters
+    ----------
+    idata: az.InfereceData
+        An InferenceData object containing the approximated posterior samples.
+    mu: RaveledVars
+        The MAP estimate of the model parameters.
+    H_inv: np.ndarray
+        The inverse Hessian matrix of the log-posterior evaluated at the MAP estimate.
+    model: Model, optional
+        A PyMC model. If None, the model is taken from the current model context.
+
+    Returns
+    -------
+    idata: az.InferenceData
+        The provided InferenceData, with the mean vector and covariance matrix added to the "fit" group.
+    """
+    model = pm.modelcontext(model)
+    coords = model.coords
+
+    variable_names, *_ = zip(*mu.point_map_info)
+
+    def make_unpacked_variable_names(name):
+        value_to_dim = {
+            x.name: model.named_vars_to_dims.get(model.values_to_rvs[x].name, None)
+            for x in model.value_vars
+        }
+        value_to_dim = {k: v for k, v in value_to_dim.items() if v is not None}
+
+        rv_to_dim = model.named_vars_to_dims
+        dims_dict = rv_to_dim | value_to_dim
+
+        dims = dims_dict.get(name)
+        if dims is None:
+            return [name]
+        labels = product(*(coords[dim] for dim in dims))
+        return [f"{name}[{','.join(map(str, label))}]" for label in labels]
+
+    unpacked_variable_names = reduce(
+        lambda lst, name: lst + make_unpacked_variable_names(name), variable_names, []
+    )
+
+    mean_dataarray = xr.DataArray(mu.data, dims=["rows"], coords={"rows": unpacked_variable_names})
+    cov_dataarray = xr.DataArray(
+        H_inv,
+        dims=["rows", "columns"],
+        coords={"rows": unpacked_variable_names, "columns": unpacked_variable_names},
+    )
+
+    dataset = xr.Dataset({"mean_vector": mean_dataarray, "covariance_matrix": cov_dataarray})
+    idata.add_groups(fit=dataset)
+
+    return idata
+
+
+def add_data_to_inferencedata(
+    idata: az.InferenceData,
+    progressbar: bool = True,
+    model: pm.Model | None = None,
+    compile_kwargs: dict | None = None,
+) -> az.InferenceData:
+    """
+    Add observed and constant data to an InferenceData object.
+
+    Parameters
+    ----------
+    idata: az.InferenceData
+        An InferenceData object containing the approximated posterior samples.
+    progressbar: bool
+        Whether to display a progress bar during computations. Default is True.
+    model: Model, optional
+        A PyMC model. If None, the model is taken from the current model context.
+    compile_kwargs: dict, optional
+        Additional keyword arguments to pass to pytensor.function.
+
+    Returns
+    -------
+    idata: az.InferenceData
+        The provided InferenceData, with observed and constant data added.
+    """
+    model = pm.modelcontext(model)
+
+    if model.deterministics:
+        idata.posterior = pm.compute_deterministics(
+            idata.posterior,
+            model=model,
+            merge_dataset=True,
+            progressbar=progressbar,
+            compile_kwargs=compile_kwargs,
+        )
+
+    coords, dims = coords_and_dims_for_inferencedata(model)
+
+    observed_data = dict_to_dataset(
+        find_observations(model),
+        library=pm,
+        coords=coords,
+        dims=dims,
+        default_dims=[],
+    )
+
+    constant_data = dict_to_dataset(
+        find_constants(model),
+        library=pm,
+        coords=coords,
+        dims=dims,
+        default_dims=[],
+    )
+
+    idata.add_groups(
+        {"observed_data": observed_data, "constant_data": constant_data},
+        coords=coords,
+        dims=dims,
+    )
+
+    return idata
+
+
+def fit_mvn_at_MAP(
+    optimized_point: dict[str, np.ndarray],
+    model: pm.Model | None = None,
+    on_bad_cov: Literal["warn", "error", "ignore"] = "ignore",
+    transform_samples: bool = False,
+    gradient_backend: GradientBackend = "pytensor",
+    zero_tol: float = 1e-8,
+    diag_jitter: float | None = 1e-8,
+    compile_kwargs: dict | None = None,
+) -> tuple[RaveledVars, np.ndarray]:
+    """
+    Create a multivariate normal distribution using the inverse of the negative Hessian matrix of the log-posterior
+    evaluated at the MAP estimate. This is the basis of the Laplace approximation.
+
+    Parameters
+    ----------
+    optimized_point : dict[str, np.ndarray]
+        Local maximum a posteriori (MAP) point returned from pymc.find_MAP or jax_tools.fit_map
+    model : Model, optional
+        A PyMC model. If None, the model is taken from the current model context.
+    on_bad_cov : str, one of 'ignore', 'warn', or 'error', default: 'ignore'
+        What to do when ``H_inv`` (inverse Hessian) is not positive semi-definite.
+        If 'ignore' or 'warn', the closest positive-semi-definite matrix to ``H_inv`` (in L1 norm) will be returned.
+        If 'error', an error will be raised.
+    transform_samples : bool
+        Whether to transform the samples back to the original parameter space. Default is True.
+    gradient_backend: str, default "pytensor"
+        The backend to use for gradient computations. Must be one of "pytensor" or "jax".
+    zero_tol: float
+        Value below which an element of the Hessian matrix is counted as 0.
+        This is used to stabilize the computation of the inverse Hessian matrix. Default is 1e-8.
+    diag_jitter: float | None
+        A small value added to the diagonal of the inverse Hessian matrix to ensure it is positive semi-definite.
+        If None, no jitter is added. Default is 1e-8.
+    compile_kwargs: dict, optional
+        Additional keyword arguments to pass to pytensor.function when compiling loss functions
+
+    Returns
+    -------
+    map_estimate: RaveledVars
+        The MAP estimate of the model parameters, raveled into a 1D array.
+
+    inverse_hessian: np.ndarray
+        The inverse Hessian matrix of the log-posterior evaluated at the MAP estimate.
+    """
+    if gradient_backend == "jax" and not find_spec("jax"):
+        raise ImportError("JAX must be installed to use JAX gradients")
+
+    model = pm.modelcontext(model)
+    compile_kwargs = {} if compile_kwargs is None else compile_kwargs
+    frozen_model = freeze_dims_and_data(model)
+
+    if not transform_samples:
+        untransformed_model = remove_value_transforms(frozen_model)
+        logp = untransformed_model.logp(jacobian=False)
+        variables = untransformed_model.continuous_value_vars
+    else:
+        logp = frozen_model.logp(jacobian=True)
+        variables = frozen_model.continuous_value_vars
+
+    variable_names = {var.name for var in variables}
+    optimized_free_params = {k: v for k, v in optimized_point.items() if k in variable_names}
+    mu = DictToArrayBijection.map(optimized_free_params)
+
+    _, f_hess, _ = scipy_optimize_funcs_from_loss(
+        loss=-logp,
+        inputs=variables,
+        initial_point_dict=optimized_free_params,
+        use_grad=True,
+        use_hess=True,
+        use_hessp=False,
+        gradient_backend=gradient_backend,
+        compile_kwargs=compile_kwargs,
+    )
+
+    H = -f_hess(mu.data)
+    if H.ndim == 1:
+        H = np.expand_dims(H, axis=1)
+    H_inv = np.linalg.pinv(np.where(np.abs(H) < zero_tol, 0, -H))
+
+    def stabilize(x, jitter):
+        return x + np.eye(x.shape[0]) * jitter
+
+    H_inv = H_inv if diag_jitter is None else stabilize(H_inv, diag_jitter)
+
+    try:
+        np.linalg.cholesky(H_inv)
+    except np.linalg.LinAlgError:
+        if on_bad_cov == "error":
+            raise np.linalg.LinAlgError(
+                "Inverse Hessian not positive-semi definite at the provided point"
+            )
+        H_inv = get_nearest_psd(H_inv)
+        if on_bad_cov == "warn":
+            _log.warning(
+                "Inverse Hessian is not positive semi-definite at the provided point, using the closest PSD "
+                "matrix in L1-norm instead"
+            )
+
+    return mu, H_inv
+
+
+def sample_laplace_posterior(
+    mu: RaveledVars,
+    H_inv: np.ndarray,
+    model: pm.Model | None = None,
+    chains: int = 2,
+    draws: int = 500,
+    transform_samples: bool = False,
+    progressbar: bool = True,
+    random_seed: int | np.random.Generator | None = None,
+    compile_kwargs: dict | None = None,
+) -> az.InferenceData:
+    """
+    Generate samples from a multivariate normal distribution with mean `mu` and inverse covariance matrix `H_inv`.
+
+    Parameters
+    ----------
+    mu: RaveledVars
+        The MAP estimate of the model parameters.
+    H_inv: np.ndarray
+        The inverse Hessian matrix of the log-posterior evaluated at the MAP estimate.
+    model : Model
+        A PyMC model
+    chains : int
+        The number of sampling chains running in parallel. Default is 2.
+    draws : int
+        The number of samples to draw from the approximated posterior. Default is 500.
+    transform_samples : bool
+        Whether to transform the samples back to the original parameter space. Default is True.
+    progressbar : bool
+        Whether to display a progress bar during computations. Default is True.
+    random_seed: int | np.random.Generator | None
+        Seed for the random number generator or a numpy Generator for reproducibility
+
+    Returns
+    -------
+    idata: az.InferenceData
+        An InferenceData object containing the approximated posterior samples.
+    """
+    model = pm.modelcontext(model)
+    compile_kwargs = {} if compile_kwargs is None else compile_kwargs
+    rng = np.random.default_rng(random_seed)
+
+    posterior_dist = stats.multivariate_normal(
+        mean=mu.data, cov=H_inv, allow_singular=True, seed=rng
+    )
+
+    posterior_draws = posterior_dist.rvs(size=(chains, draws))
+    if mu.data.shape == (1,):
+        posterior_draws = np.expand_dims(posterior_draws, -1)
+
+    if transform_samples:
+        constrained_rvs, unconstrained_vector = _unconstrained_vector_to_constrained_rvs(model)
+        batched_values = pt.tensor(
+            "batched_values",
+            shape=(chains, draws, *unconstrained_vector.type.shape),
+            dtype=unconstrained_vector.type.dtype,
+        )
+        batched_rvs = pytensor.graph.vectorize_graph(
+            constrained_rvs, replace={unconstrained_vector: batched_values}
+        )
+
+        f_constrain = pm.compile(inputs=[batched_values], outputs=batched_rvs, **compile_kwargs)
+        posterior_draws = f_constrain(posterior_draws)
+
+    else:
+        info = mu.point_map_info
+        flat_shapes = [size for _, _, size, _ in info]
+        slices = [
+            slice(sum(flat_shapes[:i]), sum(flat_shapes[: i + 1])) for i in range(len(flat_shapes))
+        ]
+
+        posterior_draws = [
+            posterior_draws[..., idx].reshape((chains, draws, *shape)).astype(dtype)
+            for idx, (name, shape, _, dtype) in zip(slices, info)
+        ]
+
+    idata = laplace_draws_to_inferencedata(posterior_draws, model)
+    idata = add_fit_to_inferencedata(idata, mu, H_inv)
+    idata = add_data_to_inferencedata(idata, progressbar, model, compile_kwargs)
+
+    return idata
+
+
+def fit_laplace(
+    optimize_method: minimize_method | Literal["basinhopping"] = "BFGS",
+    *,
+    model: pm.Model | None = None,
+    use_grad: bool | None = None,
+    use_hessp: bool | None = None,
+    use_hess: bool | None = None,
+    initvals: dict | None = None,
+    random_seed: int | np.random.Generator | None = None,
+    return_raw: bool = False,
+    jitter_rvs: list[pt.TensorVariable] | None = None,
+    progressbar: bool = True,
+    include_transformed: bool = True,
+    gradient_backend: GradientBackend = "pytensor",
+    chains: int = 2,
+    draws: int = 500,
+    on_bad_cov: Literal["warn", "error", "ignore"] = "ignore",
+    fit_in_unconstrained_space: bool = False,
+    zero_tol: float = 1e-8,
+    diag_jitter: float | None = 1e-8,
+    optimizer_kwargs: dict | None = None,
+    compile_kwargs: dict | None = None,
+) -> az.InferenceData:
+    """
+    Create a Laplace (quadratic) approximation for a posterior distribution.
+
+    This function generates a Laplace approximation for a given posterior distribution using a specified
+    number of draws. This is useful for obtaining a parametric approximation to the posterior distribution
+    that can be used for further analysis.
+
+    Parameters
+    ----------
+    model : pm.Model
+        The PyMC model to be fit. If None, the current model context is used.
+    method : str
+        The optimization method to use. Valid choices are: Nelder-Mead, Powell, CG, BFGS, L-BFGS-B, TNC, SLSQP,
+        trust-constr, dogleg, trust-ncg, trust-exact, trust-krylov, and basinhopping.
+
+        See scipy.optimize.minimize documentation for details.
+    use_grad : bool | None, optional
+        Whether to use gradients in the optimization. Defaults to None, which determines this automatically based on
+        the ``method``.
+    use_hessp : bool | None, optional
+        Whether to use Hessian-vector products in the optimization. Defaults to None, which determines this automatically based on
+        the ``method``.
+    use_hess : bool | None, optional
+        Whether to use the Hessian matrix in the optimization. Defaults to None, which determines this automatically based on
+        the ``method``.
+    initvals : None | dict, optional
+        Initial values for the model parameters, as str:ndarray key-value pairs. Paritial initialization is permitted.
+         If None, the model's default initial values are used.
+    random_seed : None | int | np.random.Generator, optional
+        Seed for the random number generator or a numpy Generator for reproducibility
+    return_raw: bool | False, optinal
+        Whether to also return the full output of `scipy.optimize.minimize`
+    jitter_rvs : list of TensorVariables, optional
+        Variables whose initial values should be jittered. If None, all variables are jittered.
+    progressbar : bool, optional
+        Whether to display a progress bar during optimization. Defaults to True.
+    fit_in_unconstrained_space: bool, default False
+        Whether to fit the Laplace approximation in the unconstrained parameter space. If True, samples will be drawn
+        from a mean and covariance matrix computed at a point in the **unconstrained** parameter space. Samples will
+        then be transformed back to the original parameter space. This will guarantee that the samples will respect
+        the domain of prior distributions (for exmaple, samples from a Beta distribution will be strictly between 0
+        and 1).
+
+        .. warning::
+            This argument should be considered highly experimental. It has not been verified if this method produces
+            valid draws from the posterior. **Use at your own risk**.
+
+    gradient_backend: str, default "pytensor"
+        The backend to use for gradient computations. Must be one of "pytensor" or "jax".
+    chains: int, default: 2
+        The number of chain dimensions to sample. Note that this is *not* the number of chains to run in parallel,
+        because the Laplace approximation is not an MCMC method. This argument exists to ensure that outputs are
+        compatible with the ArviZ library.
+    draws: int, default: 500
+        The number of samples to draw from the approximated posterior. Totals samples will be chains * draws.
+    on_bad_cov : str, one of 'ignore', 'warn', or 'error', default: 'ignore'
+        What to do when ``H_inv`` (inverse Hessian) is not positive semi-definite.
+        If 'ignore' or 'warn', the closest positive-semi-definite matrix to ``H_inv`` (in L1 norm) will be returned.
+        If 'error', an error will be raised.
+    zero_tol: float
+        Value below which an element of the Hessian matrix is counted as 0.
+        This is used to stabilize the computation of the inverse Hessian matrix. Default is 1e-8.
+    diag_jitter: float | None
+        A small value added to the diagonal of the inverse Hessian matrix to ensure it is positive semi-definite.
+        If None, no jitter is added. Default is 1e-8.
+    optimizer_kwargs
+        Additional keyword arguments to pass to the ``scipy.optimize`` function being used. Unless
+        ``method = "basinhopping"``, ``scipy.optimize.minimize`` will be used. For ``basinhopping``,
+        ``scipy.optimize.basinhopping`` will be used. See the documentation of these functions for details.
+    compile_kwargs: dict, optional
+        Additional keyword arguments to pass to pytensor.function.
+
+    Returns
+    -------
+    :class:`~arviz.InferenceData`
+        An InferenceData object containing the approximated posterior samples.
+
+    Examples
+    --------
+    >>> from pymc_extras.inference.laplace import fit_laplace
+    >>> import numpy as np
+    >>> import pymc as pm
+    >>> import arviz as az
+    >>> y = np.array([2642, 3503, 4358]*10)
+    >>> with pm.Model() as m:
+    >>>     logsigma = pm.Uniform("logsigma", 1, 100)
+    >>>     mu = pm.Uniform("mu", -10000, 10000)
+    >>>     yobs = pm.Normal("y", mu=mu, sigma=pm.math.exp(logsigma), observed=y)
+    >>>     idata = fit_laplace()
+
+    Notes
+    -----
+    This method of approximation may not be suitable for all types of posterior distributions,
+    especially those with significant skewness or multimodality.
+
+    See Also
+    --------
+    fit : Calling the inference function 'fit' like pmx.fit(method="laplace", model=m)
+          will forward the call to 'fit_laplace'.
+
+    """
+    compile_kwargs = {} if compile_kwargs is None else compile_kwargs
+    optimizer_kwargs = {} if optimizer_kwargs is None else optimizer_kwargs
+
+    optimized_point = find_MAP(
+        method=optimize_method,
+        model=model,
+        use_grad=use_grad,
+        use_hessp=use_hessp,
+        use_hess=use_hess,
+        initvals=initvals,
+        random_seed=random_seed,
+        return_raw=return_raw,
+        jitter_rvs=jitter_rvs,
+        progressbar=progressbar,
+        include_transformed=include_transformed,
+        gradient_backend=gradient_backend,
+        compile_kwargs=compile_kwargs,
+        **optimizer_kwargs,
+    )
+
+    mu, H_inv = fit_mvn_at_MAP(
+        optimized_point=optimized_point,
+        model=model,
+        on_bad_cov=on_bad_cov,
+        transform_samples=fit_in_unconstrained_space,
+        gradient_backend=gradient_backend,
+        zero_tol=zero_tol,
+        diag_jitter=diag_jitter,
+        compile_kwargs=compile_kwargs,
+    )
+
+    return sample_laplace_posterior(
+        mu=mu,
+        H_inv=H_inv,
+        model=model,
+        chains=chains,
+        draws=draws,
+        transform_samples=fit_in_unconstrained_space,
+        progressbar=progressbar,
+        random_seed=random_seed,
+        compile_kwargs=compile_kwargs,
+    )
diff --git a/pymc_extras/model/marginal/distributions.py b/pymc_extras/model/marginal/distributions.py
index 86aa5f02..159a81d4 100644
--- a/pymc_extras/model/marginal/distributions.py
+++ b/pymc_extras/model/marginal/distributions.py
@@ -3,10 +3,12 @@
 from collections.abc import Sequence
 
 import numpy as np
+import pytensor
 import pytensor.tensor as pt
 
 from pymc.distributions import Bernoulli, Categorical, DiscreteUniform
 from pymc.distributions.distribution import _support_point, support_point
+from pymc.distributions.multivariate import _precision_mv_normal_logp
 from pymc.logprob.abstract import MeasurableOp, _logprob
 from pymc.logprob.basic import conditional_logp, logp
 from pymc.pytensorf import constant_fold
@@ -19,6 +21,7 @@
 from pytensor.scan import map as scan_map
 from pytensor.scan import scan
 from pytensor.tensor import TensorVariable
+from pytensor.tensor.optimize import minimize
 from pytensor.tensor.random.type import RandomType
 
 from pymc_extras.distributions import DiscreteMarkovChain
@@ -132,6 +135,23 @@ class MarginalDiscreteMarkovChainRV(MarginalRV):
     """Base class for Marginalized Discrete Markov Chain RVs"""
 
 
+class MarginalLaplaceRV(MarginalRV):
+    """Base class for Marginalized Laplace-Approximated RVs"""
+
+    def __init__(
+        self,
+        *args,
+        Q: TensorVariable,
+        temp_kwargs: list,
+        minimizer_kwargs: dict | None = None,
+        **kwargs,
+    ) -> None:
+        self.temp_kwargs = temp_kwargs  # TODO REMOVE
+        self.Q = Q
+        self.minimizer_kwargs = minimizer_kwargs
+        super().__init__(*args, **kwargs)
+
+
 def get_domain_of_finite_discrete_rv(rv: TensorVariable) -> tuple[int, ...]:
     op = rv.owner.op
     dist_params = rv.owner.op.dist_params(rv.owner)
@@ -371,3 +391,59 @@ def step_alpha(logp_emission, log_alpha, log_P):
     warn_non_separable_logp(values)
     dummy_logps = (DUMMY_ZERO,) * (len(values) - 1)
     return joint_logp, *dummy_logps
+
+
+@_logprob.register(MarginalLaplaceRV)
+def laplace_marginal_rv_logp(op: MarginalLaplaceRV, values, *inputs, **kwargs):
+    # Clone the inner RV graph of the Marginalized RV
+    x, *inner_rvs = inline_ofg_outputs(op, inputs)
+
+    # Obtain the joint_logp graph of the inner RV graph
+    inner_rv_values = dict(zip(inner_rvs, values))
+
+    marginalized_vv = x.clone()
+    rv_values = inner_rv_values | {x: marginalized_vv}
+    logps_dict = conditional_logp(rv_values=rv_values, **kwargs)
+
+    # logp(y | x, params)
+    log_likelihood = pt.sum(
+        [logp_term.sum() for value, logp_term in logps_dict.items() if value is not marginalized_vv]
+    )
+
+    # logp = logp(y | x, params) + logp(x | params)
+    logp = pt.sum([pt.sum(logps_dict[k]) for k in logps_dict])
+
+    # Maximize log(p(x | y, params)) wrt x to find mode x0
+    minimizer_kwargs = (
+        op.minimizer_kwargs
+        if op.minimizer_kwargs is not None
+        else {"method": "L-BFGS-B", "optimizer_kwargs": {"tol": 1e-8}}
+    )
+
+    x0, _ = minimize(
+        objective=-logp,  # logp(x | y, params) = logp(y | x, params) + logp(x | params) + const (const omitted during minimization)
+        x=marginalized_vv,
+        **minimizer_kwargs,
+    )
+
+    # Set minimizer initialisation to be random
+    d = 3  # 10000 # TODO pull this from x.shape (or similar) somehow
+    rng = np.random.default_rng(12345)
+    x0 = pytensor.graph.replace.graph_replace(x0, {marginalized_vv: rng.random(d)})
+
+    # TODO USE CLOSED FORM SOLUTION FOR NOW
+    n, y_obs = op.temp_kwargs
+    mu_param = pytensor.graph.basic.get_var_by_name(x, "mu")[0]
+    x0 = (y_obs.sum(axis=0) - mu_param) / (n - 1)
+
+    # logp(x | y, params) using laplace approx evaluated at x0
+    hess = pytensor.gradient.hessian(
+        log_likelihood, marginalized_vv
+    )  # TODO check how stan makes this quicker
+    tau = op.Q - hess
+    mu = x0  # TODO double check with Theo
+    log_laplace_approx, _ = _precision_mv_normal_logp(x0, mu, tau)
+
+    # logp(y | params) = logp(y | x, params) + logp(x | params) - logp(x | y, params)
+    marginal_likelihood = logp - log_laplace_approx
+    return pytensor.graph.replace.graph_replace(marginal_likelihood, {marginalized_vv: x0})
diff --git a/pymc_extras/model/marginal/marginal_model.py b/pymc_extras/model/marginal/marginal_model.py
index b6ca25bf..6c486b32 100644
--- a/pymc_extras/model/marginal/marginal_model.py
+++ b/pymc_extras/model/marginal/marginal_model.py
@@ -9,6 +9,7 @@
 from arviz import InferenceData, dict_to_dataset
 from pymc.backends.arviz import coords_and_dims_for_inferencedata, dataset_to_point_list
 from pymc.distributions.discrete import Bernoulli, Categorical, DiscreteUniform
+from pymc.distributions.multivariate import MvNormal
 from pymc.distributions.transforms import Chain
 from pymc.logprob.transforms import IntervalTransform
 from pymc.model import Model
@@ -45,6 +46,7 @@
 from pymc_extras.model.marginal.distributions import (
     MarginalDiscreteMarkovChainRV,
     MarginalFiniteDiscreteRV,
+    MarginalLaplaceRV,
     MarginalRV,
     NonSeparableLogpWarning,
     get_domain_of_finite_discrete_rv,
@@ -144,7 +146,9 @@ def _unique(seq: Sequence) -> list:
     return [x for x in seq if not (x in seen or seen_add(x))]
 
 
-def marginalize(model: Model, rvs_to_marginalize: ModelRVs) -> MarginalModel:
+def marginalize(
+    model: Model, rvs_to_marginalize: ModelRVs, use_laplace: bool = False, **marginalize_kwargs
+) -> MarginalModel:
     """Marginalize a subset of variables in a PyMC model.
 
     This creates a class of `MarginalModel` from an existing `Model`, with the specified
@@ -158,6 +162,8 @@ def marginalize(model: Model, rvs_to_marginalize: ModelRVs) -> MarginalModel:
         PyMC model to marginalize. Original variables well be cloned.
     rvs_to_marginalize : Sequence[TensorVariable]
         Variables to marginalize in the returned model.
+    use_laplace : bool
+        Whether to use Laplace appoximations to marginalize out rvs_to_marginalize.
 
     Returns
     -------
@@ -186,7 +192,12 @@ def marginalize(model: Model, rvs_to_marginalize: ModelRVs) -> MarginalModel:
                 raise NotImplementedError(
                     "Marginalization for DiscreteMarkovChain with non-matrix transition probability is not supported"
                 )
-        elif not isinstance(rv_op, Bernoulli | Categorical | DiscreteUniform):
+        elif use_laplace and not isinstance(rv_op, MvNormal):
+            raise ValueError(
+                f"Marginalisation method set to Laplace but RV {rv_to_marginalize} is not instance of MvNormal. Has distribution {rv_to_marginalize.owner.op}"
+            )
+
+        elif not use_laplace and not isinstance(rv_op, Bernoulli | Categorical | DiscreteUniform):
             raise NotImplementedError(
                 f"Marginalization of RV with distribution {rv_to_marginalize.owner.op} is not supported"
             )
@@ -241,7 +252,9 @@ def marginalize(model: Model, rvs_to_marginalize: ModelRVs) -> MarginalModel:
         ]
         input_rvs = _unique((*marginalized_rv_input_rvs, *other_direct_rv_ancestors))
 
-        replace_finite_discrete_marginal_subgraph(fg, rv_to_marginalize, dependent_rvs, input_rvs)
+        replace_marginal_subgraph(
+            fg, rv_to_marginalize, dependent_rvs, input_rvs, use_laplace, **marginalize_kwargs
+        )
 
     return model_from_fgraph(fg, mutate_fgraph=True)
 
@@ -551,22 +564,32 @@ def remove_model_vars(vars):
     return fgraph.outputs
 
 
-def replace_finite_discrete_marginal_subgraph(
-    fgraph, rv_to_marginalize, dependent_rvs, input_rvs
+def replace_marginal_subgraph(
+    fgraph,
+    rv_to_marginalize,
+    dependent_rvs,
+    input_rvs,
+    use_laplace=False,
+    **marginalize_kwargs,
 ) -> None:
     # If the marginalized RV has multiple dimensions, check that graph between
     # marginalized RV and dependent RVs does not mix information from batch dimensions
     # (otherwise logp would require enumerating over all combinations of batch dimension values)
-    try:
-        dependent_rvs_dim_connections = subgraph_batch_dim_connection(
-            rv_to_marginalize, dependent_rvs
-        )
-    except (ValueError, NotImplementedError) as e:
-        # For the perspective of the user this is a NotImplementedError
-        raise NotImplementedError(
-            "The graph between the marginalized and dependent RVs cannot be marginalized efficiently. "
-            "You can try splitting the marginalized RV into separate components and marginalizing them separately."
-        ) from e
+    if not use_laplace:
+        try:
+            dependent_rvs_dim_connections = subgraph_batch_dim_connection(
+                rv_to_marginalize, dependent_rvs
+            )
+        except (ValueError, NotImplementedError) as e:
+            # For the perspective of the user this is a NotImplementedError
+            raise NotImplementedError(
+                "The graph between the marginalized and dependent RVs cannot be marginalized efficiently. "
+                "You can try splitting the marginalized RV into separate components and marginalizing them separately."
+            ) from e
+    else:
+        dependent_rvs_dim_connections = [
+            (None,),
+        ]
 
     output_rvs = [rv_to_marginalize, *dependent_rvs]
     rng_updates = collect_default_updates(output_rvs, inputs=input_rvs, must_be_shared=False)
@@ -581,6 +604,8 @@ def replace_finite_discrete_marginal_subgraph(
 
     if isinstance(inner_outputs[0].owner.op, DiscreteMarkovChain):
         marginalize_constructor = MarginalDiscreteMarkovChainRV
+    elif use_laplace:
+        marginalize_constructor = MarginalLaplaceRV
     else:
         marginalize_constructor = MarginalFiniteDiscreteRV
 
@@ -590,6 +615,7 @@ def replace_finite_discrete_marginal_subgraph(
         outputs=inner_outputs,
         dims_connections=dependent_rvs_dim_connections,
         dims=dims,
+        **marginalize_kwargs,
     )
 
     new_outputs = marginalization_op(*inputs)
diff --git a/tests/inference/inla/test_inla.py b/tests/inference/inla/test_inla.py
new file mode 100644
index 00000000..8a504889
--- /dev/null
+++ b/tests/inference/inla/test_inla.py
@@ -0,0 +1,106 @@
+#   Copyright 2024 The PyMC Developers
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+
+import numpy as np
+import pymc as pm
+import pytest
+
+import pymc_extras as pmx
+
+
+@pytest.fixture(scope="session")
+def rng():
+    seed = 12345
+    return np.random.default_rng(seed)
+
+
+@pytest.mark.filterwarnings("ignore:Currently only valid for a nested normal model. WIP.")
+def test_non_gaussian_latent(rng):
+    """
+    INLA should raise an error if trying to use a non-Gaussian latent
+    """
+    n = 10000
+
+    mu_true = rng.random()
+    tau = 1
+    y_obs = rng.normal(loc=mu_true, scale=1 / tau, size=n)
+
+    with pm.Model() as model:
+        lam = pm.HalfNormal("lam", tau=tau)
+        x = pm.Exponential("x", lam=lam)
+        y = pm.Normal("y", mu=x, tau=tau, observed=y_obs)
+
+        with pytest.raises(ValueError):
+            pmx.fit(method="INLA", x=x)
+
+
+@pytest.mark.filterwarnings("ignore:Currently only valid for a nested normal model. WIP.")
+def test_non_precision_MvNormal(rng):
+    """
+    INLA should raise an error if trying to use a latent not in precision form
+    """
+    n = 10000
+    d = 3
+
+    mu_mu = np.zeros((d,))
+    mu_true = rng.random(d)
+    tau = np.identity(d)
+    cov = np.linalg.inv(tau)
+    y_obs = rng.multivariate_normal(mean=mu_true, cov=cov, size=n)
+
+    with pm.Model() as model:
+        mu = pm.MvNormal("mu", mu=mu_mu, tau=tau)
+        x = pm.MvNormal("x", mu=mu, cov=cov)
+        y = pm.MvNormal("y", mu=x, tau=tau, observed=y_obs)
+
+        with pytest.raises(ValueError):
+            pmx.fit(method="INLA", x=x)
+
+
+@pytest.mark.filterwarnings("ignore:Currently only valid for a nested normal model. WIP.")
+def test_3_layer_normal(rng):
+    """
+    Test INLA against a simple toy problem:
+
+    mu ~ N(mu_mu, I)
+    x ~ N(mu, I)
+    y ~ N(x, I)
+
+    The mean of the posterior should be the midpoint between mu_mu and mu_true
+    """
+    n = 10000
+    d = 3
+
+    mu_mu = 10 * rng.random(d)
+    mu_true = rng.random(d)
+    tau = np.identity(d)
+    cov = np.linalg.inv(tau)
+    y_obs = rng.multivariate_normal(mean=mu_true, cov=cov, size=n)
+
+    with pm.Model() as model:
+        mu = pm.MvNormal("mu", mu=mu_mu, tau=tau)
+        x = pm.MvNormal("x", mu=mu, tau=tau)
+        y = pm.MvNormal("y", mu=x, tau=tau, observed=y_obs)
+
+        idata = pmx.fit(
+            method="INLA",
+            x=x,
+            temp_kwargs=[n, y_obs],  # TODO REMOVE LATER - DEBUGGING TOOL
+            return_latent_posteriors=False,
+        )
+
+        posterior_mean_true = (mu_mu + mu_true) / 2
+        posterior_mean_inla = idata.posterior.mu.mean(axis=(0, 1))
+        np.testing.assert_allclose(posterior_mean_true, posterior_mean_inla, atol=0.1)
diff --git a/tests/inference/laplace_approx/test_laplace.py b/tests/inference/laplace_approx/test_laplace.py
index 6196673b..086ad101 100644
--- a/tests/inference/laplace_approx/test_laplace.py
+++ b/tests/inference/laplace_approx/test_laplace.py
@@ -22,7 +22,6 @@
 from pymc_extras.inference.laplace_approx.find_map import GradientBackend
 from pymc_extras.inference.laplace_approx.laplace import (
     fit_laplace,
-    get_conditional_gaussian_approximation,
 )
 
 
@@ -321,84 +320,4 @@ def test_laplace_scalar_basinhopping(optimizer_method):
         idata_laplace.posterior.p.mean(dim=["chain", "draw"]), data.mean(), atol=0.1
     )
 
-
-def test_get_conditional_gaussian_approximation():
-    """
-    Consider the trivial case of:
-
-    y | x ~ N(x, cov_param)
-    x | param ~ N(mu_param, Q^-1)
-
-    cov_param ~ N(cov_mu, cov_cov)
-    mu_param ~ N(mu_mu, mu_cov)
-    Q ~ N(Q_mu, Q_cov)
-
-    This has an analytic solution at the mode which we can compare against.
-    """
-    rng = np.random.default_rng(12345)
-    n = 10000
-    d = 10
-
-    # Initialise arrays
-    mu_true = rng.random(d)
-    cov_true = np.diag(rng.random(d))
-    Q_val = np.diag(rng.random(d))
-    cov_param_val = np.diag(rng.random(d))
-
-    x_val = rng.random(d)
-    mu_val = rng.random(d)
-
-    mu_mu = rng.random(d)
-    mu_cov = np.diag(np.ones(d))
-    cov_mu = rng.random(d**2)
-    cov_cov = np.diag(np.ones(d**2))
-    Q_mu = rng.random(d**2)
-    Q_cov = np.diag(np.ones(d**2))
-
-    with pm.Model() as model:
-        y_obs = rng.multivariate_normal(mean=mu_true, cov=cov_true, size=n)
-
-        mu_param = pm.MvNormal("mu_param", mu=mu_mu, cov=mu_cov)
-        cov_param = pm.MvNormal("cov_param", mu=cov_mu, cov=cov_cov)
-        Q = pm.MvNormal("Q", mu=Q_mu, cov=Q_cov)
-
-        # Pytensor currently doesn't support autograd for pt inverses, so we use a numeric Q instead
-        x = pm.MvNormal("x", mu=mu_param, cov=np.linalg.inv(Q_val))
-
-        y = pm.MvNormal(
-            "y",
-            mu=x,
-            cov=cov_param.reshape((d, d)),
-            observed=y_obs,
-        )
-
-        # logp(x | y, params)
-        cga = get_conditional_gaussian_approximation(
-            x=model.rvs_to_values[x],
-            Q=Q.reshape((d, d)),
-            mu=mu_param,
-            optimizer_kwargs={"tol": 1e-25},
-        )
-
-    x0, log_x_posterior = cga(
-        x=x_val, mu_param=mu_val, cov_param=cov_param_val.flatten(), Q=Q_val.flatten()
-    )
-
-    # Get analytic values of the mode and Laplace-approximated log posterior
-    cov_param_inv = np.linalg.inv(cov_param_val)
-
-    x0_true = np.linalg.inv(n * cov_param_inv + 2 * Q_val) @ (
-        cov_param_inv @ y_obs.sum(axis=0) + 2 * Q_val @ mu_val
-    )
-
-    jac_true = cov_param_inv @ (y_obs - x0_true).sum(axis=0) - Q_val @ (x0_true - mu_val)
-    hess_true = -n * cov_param_inv - Q_val
-
-    log_x_posterior_laplace_true = (
-        -0.5 * x_val.T @ (-hess_true + Q_val) @ x_val
-        + x_val.T @ (Q_val @ mu_val + jac_true - hess_true @ x0_true)
-        + 0.5 * np.log(np.linalg.det(Q_val))
-    )
-
-    np.testing.assert_allclose(x0, x0_true, atol=0.1, rtol=0.1)
-    np.testing.assert_allclose(log_x_posterior, log_x_posterior_laplace_true, atol=0.1, rtol=0.1)
+    np.testing.assert_allclose(idata_laplace.fit.mean_vector.values.item(), data.mean(), atol=0.1)