examples/samplers/sampling_compound_step.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-18T15:27:28.707896Z",
     "start_time": "2018-06-18T15:27:28.702766Z"
    }
   },
   "source": [
    "# Compound Steps in Sampling\n",
    "This notebook explains how the compound steps work in `pymc.sample` function when sampling multiple random variables. We are going to answer the following questions associated with compound steps:\n",
    "\n",
    "- How do compound steps work?\n",
    "- What happens when PyMC assigns step methods by default?\n",
    "- How to specify the step methods? What is the order to apply the step methods at each iteration? Is there a way to specify the order of the step methods? \n",
    "- What are the issues with mixing discrete and continuous samplers, especially with HMC/NUTS?\n",
    "- What happens to sample statistics that occur in multiple step methods?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-28T21:53:54.050085Z",
     "start_time": "2018-07-28T21:53:52.045480Z"
    },
    "execution": {
     "iopub.execute_input": "2022-01-09T19:27:05.186598Z",
     "iopub.status.busy": "2022-01-09T19:27:05.185597Z",
     "iopub.status.idle": "2022-01-09T19:27:09.141640Z",
     "shell.execute_reply": "2022-01-09T19:27:09.140637Z"
    }
   },
   "outputs": [],
   "source": [
    "import arviz as az\n",
    "import numpy as np\n",
    "import pymc as pm\n",
    "import pytensor\n",
    "import xarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-09T19:27:09.147639Z",
     "iopub.status.busy": "2022-01-09T19:27:09.146639Z",
     "iopub.status.idle": "2022-01-09T19:27:09.156640Z",
     "shell.execute_reply": "2022-01-09T19:27:09.156640Z"
    }
   },
   "outputs": [],
   "source": [
    "az.style.use(\"arviz-darkgrid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compound steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When sampling a model with multiple free random variables, compound steps are needed in the `pm.sample` function. When compound steps are involved, the function takes a list of `step` to generate a list of `methods` for different random variables. For example in the following code:\n",
    "```python\n",
    "with pm.Model() as m:\n",
    "    rv1 = ... # random variable 1 (continuous)\n",
    "    rv2 = ... # random variable 2 (continuous)\n",
    "    rv3 = ... # random variable 3 (categorical)\n",
    "    #...\n",
    "    step1 = pm.Metropolis([rv1, rv2])\n",
    "    step2 = pm.CategoricalGibbsMetropolis([rv3])\n",
    "    trace = pm.sample(..., step=[step1, step2])\n",
    "```\n",
    "The compound step now contains a list of `methods`. At each sampling step, it iterates over these methods, taking a `point` as input. In each step a new `point` is proposed as an output, if rejected by the Metropolis-Hastings criteria the original input `point` sticks around as the output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compound steps by default\n",
    "To conduct Markov chain Monte Carlo (MCMC) sampling to generate posterior samples in PyMC, we specify a step method object that corresponds to a particular MCMC algorithm, such as Metropolis, Slice sampling, or the No-U-Turn Sampler (NUTS). PyMC’s step_methods can be assigned manually, or assigned automatically by PyMC. Auto-assignment is based on the attributes of each variable in the model. In general:\n",
    "\n",
    "- Binary variables will be assigned to BinaryMetropolis\n",
    "- Discrete variables will be assigned to Metropolis\n",
    "- Continuous variables will be assigned to NUTS\n",
    "\n",
    "When we call `pm.sample(return_inferencedata=False)`, `PyMC` assigns the best step method to each of the free random variables. Take the following example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-28T21:54:23.727052Z",
     "start_time": "2018-07-28T21:53:56.768369Z"
    },
    "execution": {
     "iopub.execute_input": "2022-01-09T19:27:09.164638Z",
     "iopub.status.busy": "2022-01-09T19:27:09.163641Z",
     "iopub.status.idle": "2022-01-09T19:28:11.250420Z",
     "shell.execute_reply": "2022-01-09T19:28:11.248424Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "CompoundStep\n",
      ">NUTS: [p]\n",
      ">BinaryGibbsMetropolis: [ni]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='44000' class='' max='44000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [44000/44000 00:21<00:00 Sampling 4 chains, 0 divergences]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling 4 chains for 1_000 tune and 10_000 draw iterations (4_000 + 40_000 draws total) took 43 seconds.\n"
     ]
    }
   ],
   "source": [
    "n_ = pytensor.shared(np.asarray([10, 15]))\n",
    "with pm.Model() as m:\n",
    "    p = pm.Beta(\"p\", 1.0, 1.0)\n",
    "    ni = pm.Bernoulli(\"ni\", 0.5)\n",
    "    k = pm.Binomial(\"k\", p=p, n=n_[ni], observed=4)\n",
    "    trace = pm.sample(10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two free parameters in the model we would like to sample from, a continuous variable `p_logodds__` and a binary variable `ni`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-28T21:56:05.311321Z",
     "start_time": "2018-07-28T21:56:05.302743Z"
    },
    "execution": {
     "iopub.execute_input": "2022-01-09T19:28:11.257430Z",
     "iopub.status.busy": "2022-01-09T19:28:11.255422Z",
     "iopub.status.idle": "2022-01-09T19:28:11.263424Z",
     "shell.execute_reply": "2022-01-09T19:28:11.265424Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[p, ni]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.free_RVs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we call `pm.sample(return_inferencedata=False)`, `PyMC` assigns the best step method to each of them. For example, `NUTS` was assigned to `p_logodds__` and `BinaryGibbsMetropolis` was assigned to `ni`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specify compound steps\n",
    "Auto-assignment can be overridden for any subset of variables by specifying them manually prior to sampling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-09T19:28:11.276422Z",
     "iopub.status.busy": "2022-01-09T19:28:11.275418Z",
     "iopub.status.idle": "2022-01-09T19:28:59.314718Z",
     "shell.execute_reply": "2022-01-09T19:28:59.315718Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "CompoundStep\n",
      ">Metropolis: [p]\n",
      ">BinaryMetropolis: [ni]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='44000' class='' max='44000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [44000/44000 00:18<00:00 Sampling 4 chains, 0 divergences]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling 4 chains for 1_000 tune and 10_000 draw iterations (4_000 + 40_000 draws total) took 38 seconds.\n",
      "The number of effective samples is smaller than 25% for some parameters.\n"
     ]
    }
   ],
   "source": [
    "with m:\n",
    "    step1 = pm.Metropolis([p])\n",
    "    step2 = pm.BinaryMetropolis([ni])\n",
    "    trace = pm.sample(\n",
    "        10000,\n",
    "        step=[step1, step2],\n",
    "        idata_kwargs={\n",
    "            \"dims\": {\"accept\": [\"step\"]},\n",
    "            \"coords\": {\"step\": [\"Metropolis\", \"BinaryMetropolis\"]},\n",
    "        },\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-28T21:56:09.259368Z",
     "start_time": "2018-07-28T21:56:09.253057Z"
    },
    "execution": {
     "iopub.execute_input": "2022-01-09T19:28:59.325720Z",
     "iopub.status.busy": "2022-01-09T19:28:59.324718Z",
     "iopub.status.idle": "2022-01-09T19:28:59.346719Z",
     "shell.execute_reply": "2022-01-09T19:28:59.346719Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "e:\\source\\repos\\pymc3-v4\\pymc\\model.py:976: FutureWarning: `Model.test_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'p_logodds__': array(0.), 'ni': array(1, dtype=int64)}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point = m.test_point\n",
    "point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then pass the `point` to the first step method `pm.Metropolis` for random variable `p`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-28T21:56:10.554828Z",
     "start_time": "2018-07-28T21:56:10.547243Z"
    },
    "execution": {
     "iopub.execute_input": "2022-01-09T19:28:59.352718Z",
     "iopub.status.busy": "2022-01-09T19:28:59.351718Z",
     "iopub.status.idle": "2022-01-09T19:28:59.362720Z",
     "shell.execute_reply": "2022-01-09T19:28:59.363721Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'p_logodds__': array(0.52418058), 'ni': array(1, dtype=int64)},\n",
       " [{'tune': True,\n",
       "   'scaling': array([1.]),\n",
       "   'accept': 0.08964089546197954,\n",
       "   'accepted': True}])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point, state = step1.step(point=point)\n",
    "point, state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the value of  `ni` does not change, but `p_logodds__` is updated.\n",
    "\n",
    "And similarly, you can pass the updated `point` to `step2` and get a sample for `ni`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-28T21:56:11.698858Z",
     "start_time": "2018-07-28T21:56:11.691170Z"
    },
    "execution": {
     "iopub.execute_input": "2022-01-09T19:28:59.370235Z",
     "iopub.status.busy": "2022-01-09T19:28:59.369236Z",
     "iopub.status.idle": "2022-01-09T19:28:59.378237Z",
     "shell.execute_reply": "2022-01-09T19:28:59.378237Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'p_logodds__': array(0.52418058), 'ni': array(0, dtype=int64)},\n",
       " [{'tune': True, 'accept': 21.632194762798157, 'p_jump': 0.5}])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point = step2.step(point=point)\n",
    "point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compound step works exactly like this by iterating all the steps within the list. In effect, it is a metropolis hastings within gibbs sampling. \n",
    "\n",
    "Moreover, `pm.CompoundStep` is called internally by `pm.sample(return_inferencedata=False)`. We can make them explicit as below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-28T21:56:12.982233Z",
     "start_time": "2018-07-28T21:56:12.976999Z"
    },
    "execution": {
     "iopub.execute_input": "2022-01-09T19:28:59.389237Z",
     "iopub.status.busy": "2022-01-09T19:28:59.388236Z",
     "iopub.status.idle": "2022-01-09T19:29:41.129759Z",
     "shell.execute_reply": "2022-01-09T19:29:41.129759Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "CompoundStep\n",
      ">Metropolis: [p]\n",
      ">BinaryMetropolis: [ni]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='44000' class='' max='44000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [44000/44000 00:17<00:00 Sampling 4 chains, 0 divergences]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling 4 chains for 1_000 tune and 10_000 draw iterations (4_000 + 40_000 draws total) took 38 seconds.\n",
      "The number of effective samples is smaller than 25% for some parameters.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<pymc.step_methods.metropolis.Metropolis at 0x215573b6cd0>,\n",
       " <pymc.step_methods.metropolis.BinaryMetropolis at 0x21557af7e20>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with m:\n",
    "    comp_step1 = pm.CompoundStep([step1, step2])\n",
    "    trace1 = pm.sample(10000, comp_step1)\n",
    "comp_step1.methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-09T19:29:41.134757Z",
     "iopub.status.busy": "2022-01-09T19:29:41.133758Z",
     "iopub.status.idle": "2022-01-09T19:29:41.146763Z",
     "shell.execute_reply": "2022-01-09T19:29:41.147762Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['p_jump', 'scaling', 'accepted', 'accept']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# These are the Sample Stats for Compound Step based sampling\n",
    "list(trace1.sample_stats.data_vars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: In compound step method, a sample stats variable maybe present in both step methods, like `accept` in every chain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-09T19:29:41.153764Z",
     "iopub.status.busy": "2022-01-09T19:29:41.152759Z",
     "iopub.status.idle": "2022-01-09T19:29:41.159756Z",
     "shell.execute_reply": "2022-01-09T19:29:41.160760Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5.05880713e-02, 1.00000000e+00],\n",
       "       [1.00656794e+00, 8.23345217e-01],\n",
       "       [6.44911199e-03, 1.00000000e+00],\n",
       "       ...,\n",
       "       [1.32225607e-06, 1.00000000e+00],\n",
       "       [7.07386719e-02, 1.00000000e+00],\n",
       "       [4.94538644e-02, 1.00000000e+00]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace1.sample_stats[\"accept\"].sel(chain=1).values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Order of step methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When in the default setting, the parameter update order follows the same order of the random variables, and it is assigned automatically. But if you specify the steps, you can change the order of the methods in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-28T21:56:14.969080Z",
     "start_time": "2018-07-28T21:56:14.963094Z"
    },
    "execution": {
     "iopub.execute_input": "2022-01-09T19:29:41.170757Z",
     "iopub.status.busy": "2022-01-09T19:29:41.169755Z",
     "iopub.status.idle": "2022-01-09T19:30:24.132625Z",
     "shell.execute_reply": "2022-01-09T19:30:24.133626Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "CompoundStep\n",
      ">BinaryMetropolis: [ni]\n",
      ">Metropolis: [p]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='44000' class='' max='44000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [44000/44000 00:19<00:00 Sampling 4 chains, 0 divergences]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling 4 chains for 1_000 tune and 10_000 draw iterations (4_000 + 40_000 draws total) took 39 seconds.\n",
      "The number of effective samples is smaller than 25% for some parameters.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<pymc.step_methods.metropolis.BinaryMetropolis at 0x21557af7e20>,\n",
       " <pymc.step_methods.metropolis.Metropolis at 0x215573b6cd0>]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with m:\n",
    "    comp_step2 = pm.CompoundStep([step2, step1])\n",
    "    trace2 = pm.sample(\n",
    "        10000,\n",
    "        comp_step2,\n",
    "    )\n",
    "comp_step2.methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the sampling process, it always follows the same step order in each sample in the Gibbs-like fashion. More precisely, at each update, it iterates over the list of `methods` where the accept/reject is based on comparing the acceptance rate with $p \\sim \\text{Uniform}(0, 1)$ (by checking whether $\\log p < \\log p_{\\text {updated}} - \\log p_{\\text {current}}$)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each step method gets its own `accept`, notice how the plots are reversed in when step order is reverted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-09T19:30:24.138626Z",
     "iopub.status.busy": "2022-01-09T19:30:24.137625Z",
     "iopub.status.idle": "2022-01-09T19:30:24.451625Z",
     "shell.execute_reply": "2022-01-09T19:30:24.451625Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABoMAAAIwCAYAAABN6RLXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB6mUlEQVR4nO3deZhkdXk37uf03j1rzzALzIAIMrIr27CIENQQQXkVo4kLIvIzuMRoTIxGoyS+eeOSuGPcEwmoCaAioqgEFxBlUUBlR0bZhplhYHrW3rvP749Tp7p7pmeme3qprlP3fV11ndrr293V3XXqU8/zJGmapgEAAAAAAEAh1VV6AQAAAAAAAEwdYRAAAAAAAECBCYMAAAAAAAAKTBgEAAAAAABQYMIgAAAAAACAAhMGAQAAAAAAFJgwCAAAAAAAoMCEQQAAAAAAAAUmDAIAAAAAACgwYRAAAAAAAECBCYMAqEnPfOYz45nPfGallwEAADDl7P8AIAwCAAAAAAAoMGEQAAAAAABAgSVpmqaVXgQA0+u3v/1t/OAHP4hbb7011qxZE5s2bYq5c+fGkUceGeeee26cdNJJo97uD3/4Q/zXf/1X3HTTTbF27dqor6+PpUuXxsqVK+PVr351rFixYsT1N23aFJdeemn8+Mc/jocffjj6+vpi0aJFcfjhh8fLXvayOPXUU0dcv7+/P6688sr4zne+E/fff390dnbG4sWL47nPfW686U1vir333nvE9W+55ZY499xzY+XKlfHFL34xPve5z8X3v//9WLt2bcybNy9OOeWUePvb3x5Lliwp3+aiiy6Kz3zmMzv93vzoRz+K5cuXj/dbCgAAzFD2f+z/ACAMAqhJ5513Xtxyyy3xjGc8I/bee+9obW2NRx99NO6+++6IiHjve98br3vd60bc5uqrr473vve90dvbG/vss08cccQRMTg4GI8++mjcf//98Zd/+ZfxV3/1V+Xr33fffXHBBRfEunXrYs6cOXH00UfHrFmzYs2aNXHvvffGkUceGZdeemn5+lu3bo03v/nNceutt0ZbW1scfvjh0d7eHg888ED84Q9/iPnz58dXvvKVOPTQQ8u3yXeGjjrqqEjTNO6///5YuXJltLa2xm233Rbr16+PRYsWxVe/+tXYf//9IyLiuuuui+uuuy6uvPLKiIg4++yzR3yd73rXu2LBggWT+v0GAAAqx/6P/R8AhEEANen666+PQw45JBYvXjzi/DvuuCPe8IY3RE9PT/zoRz8qf6Lsrrvuile+8pXR398f//AP/xCvec1roq5uqNPo6tWro6OjIw4//PCIiOjs7Iwzzzwz1qxZEy996UvjwgsvjFmzZpWvv2XLlrjzzjtHfALvb//2b+O73/1unHbaafEv//IvsXDhwvJlF198cXzoQx+K/fffP6655pqor6+PiKGdoYiIpz3taXHxxRfHPvvsExERPT098Xd/93fxwx/+MJ797GfHZZddNuJrzYen3n///RP7ZgIAADOa/R/7PwCYGQRQk0499dQddoQiIo466qh4zWteE319fXHdddeVz//c5z4XfX19cc4558RrX/vaETtCERHLli0r7whFRFxxxRWxZs2aOOSQQ+KDH/zgiB2hiIg5c+aM2BFatWpVfO9734vFixfHRz/60RE7QhHZJ/lOPfXUeOihh+KGG24Y9Wt617veVd4Riohobm6Of/zHf4zW1tb49a9/HbfffvsYvjMAAEDR2P8BgIiGSi8AgMro6OiI66+/Ph544IHYvHlz9Pf3R0TEQw89FBFZf+yIiIGBgfjFL34RERF/9md/Nqb7/tnPfhYRES9/+cvLn2Lbleuvvz7SNI1TTjklZs+ePep1Vq5cGddff33ccccdcdppp424bO7cufH85z9/h9ssXLgwnvvc58a1114bt956axx99NFjWj8AAFAs9n8AqHXCIIAadPnll8eHPvSh6Ozs3Ol1tm3bFhERGzduLF/v6U9/+pju//HHH4+IiAMOOGBM13/00UcjIuIb3/hGfOMb39jldTds2LDDecuWLYskSUa9fj4Mde3atWNaCwAAUCz2fwBAGARQc+6666648MILo76+Pt75znfG8573vPIQ1SRJ4rLLLosLL7wwpnOk3ODgYEREHHLIIXHwwQfv8rrPetaz9ugxjMgDAIDaY/8HADLCIIAa84Mf/CDSNI1zzjkn/uIv/mKHy/M2Cbn58+dHa2trdHV1xR/+8IdYsWLFbh9j7733jlWrVsXvf//7Eb2xd3X9iIijjz46LrzwwrF9IcOsXr16t5ctXbp03PcLAABUN/s/AJCp2/1VACiSTZs2RUSMGDaa6+npiWuvvXbEefX19eUdmssvv3xMj/Hc5z43IiK++c1vxsDAwG6vf8opp0RExI9//OPo6ekZ02MMt3nz5vjxj3+8w/kbNmwo9+9euXLliMsaGxsjIsq9wgEAgOKx/5Ox/wOAMAigxhx44IEREfHtb387tm7dWj6/p6cn/umf/ikee+yxHW7zpje9KRoaGuJrX/tafO1rX9uh5cDq1avjrrvuKp9+xSteEUuXLo177rkn3ve+9+3Qm3vr1q3loawREYceemj8yZ/8SaxZsybe+ta3jrqGzs7O+M53vhNPPvnkqF/XRz7ykRF9sXt7e+MDH/hAdHZ2xpFHHhnHHHPMiOsvWbIkIiIefPDBUe8PAACofvZ/MvZ/AEhSTUQBasrmzZvjpS99aaxevTrmz58fxx57bNTX18evfvWr6O7ujj/90z+NSy65JM4+++z48Ic/XL7dt7/97Xjf+94XfX19sWzZsjj88MMjTdN49NFH47777ou//Mu/jL/6q78qX/+ee+6JCy64INavXx9z586No48+Otra2mLNmjVx7733xpFHHhmXXnpp+fpbt26Nt771rXHTTTdFY2NjHHzwwbF8+fJI0zRWr14d9913X/T19cU111xT3qG75ZZb4txzz42jjjoqBgcH44EHHogTTjghWlpa4rbbbosnnngiFi5cGF/96ld3GOb6kY98JP7zP/8z2tvb44QTTohZs2ZFRMQ73/nOaG9vn8ofAQAAME3s/2Ts/wAgDAKoQRs2bIiLLroobrzxxli7dm3Mnz8/TjjhhHjrW98at912W7znPe/ZYWcoIvsU2Ve+8pW4+eab44knnojm5uZYsmRJnHDCCfGqV70qnvGMZ+zwOJdcckn86Ec/isceeywGBwdj0aJFccQRR8TLXvaycjuF3ODgYFxzzTXxne98J+6+++7YtGlTzJo1KxYvXhyHH354PP/5z49TTz213OIg3xlauXJlfOELX4jPfOYz8cMf/jDWrVsX8+bNi1NOOSXe9ra3lXtyD9fT0xOf/vSn43//93/j8ccfj76+voiI+NGPfhTLly+fzG83AABQQfZ/7P8AIAwCoIoN3xka/ik7AACAorH/A8BEmBkEAAAAAABQYMIgAAAAAACAAhMGAQAAAAAAFJiZQQAAAAAAAAWmMggAAAAAAKDAhEEAAAAAAAAF1lDpBQBQe77//e/H17/+9bjvvvuir68v9ttvvzjrrLPivPPOi8bGxkovDwAAYMJ+//vfx89//vO4++674+67745Vq1bFwMBAvP3tb4+3vOUtlV4eADVGGATAtPqXf/mXuOSSS6KhoSFOOOGEaGtri5tvvjk++tGPxk9+8pP4z//8z2hpaan0MgEAACbkv//7v+OSSy6p9DIAICKEQQBMo+uuuy4uueSSaGtri69+9atx2GGHRUTEhg0b4nWve13cdttt8alPfSre/e53V3ilAAAAE7NixYo4//zz49BDD41DDz00vvCFL8RVV11V6WUBUKOEQQBMm89//vMREXHBBReUg6CIiAULFsQ//uM/xmte85r46le/Gm95y1tizpw5lVomAADAhL3iFa8YcbquzuhuACrHfyEApsW6devizjvvjIiIF7/4xTtcfuyxx8bee+8dvb29cf3110/38gAAAACgsIRBAEyLe+65JyIi5s+fH/vuu++o1zn88MNHXBcAAAAAmDhhEADT4rHHHouIiL333nun11m6dOmI6wIAAAAAEycMAmBabNu2LSIiWltbd3qdWbNmjbguAAAAADBxwiAAAAAAAIACEwYBMC3yqp+urq6dXievCMqvCwAAAABMnDAIgGmxbNmyiIhYs2bNTq+zdu3aEdcFAAAAACZOGATAtDj00EMjImLjxo3x6KOPjnqdu+66KyIiDjvssGlbFwAAAAAUnTAIgGmxdOnSOOKIIyIi4rvf/e4Ol//qV7+KNWvWRFNTU5x66qnTvTwAAAAAKCxhEADT5k1velNERHzxi1+Mu+++u3x+R0dHfOADH4iIiHPOOSfmzJlTkfUBAAAAQBElaZqmlV4EALXj//2//xeXXnppNDY2xgknnBBtbW1x0003xebNm+Poo4+Or3zlK9HS0lLpZQIAAEzI3XffXf7QW0TEI488Eh0dHbF06dJYsmRJ+fzPfOYzsXjx4kosEYAa0lDpBQBQW973vvfF0UcfHV//+tfjjjvuiP7+/thvv/3iL/7iL+K8886LpqamSi8RAABgwrZu3Rq/+c1vdjh/7dq1sXbt2vLp3t7e6VwWADVKZRAAAAAAAECBmRkEAAAAAABQYMIgAAAAAACAAhMGAQAAAAAAFJgwCAAAAAAAoMAaxnrFjo6OqVzHuM2bNy82bdpU6WXAHvH8pZp5/lLNPH+pZp6/49Pe3j6h29v/YSz8XGYmP5eZyc9l5vKzmZn8XGYmP5eZyc9lbPs/VVsZVFdXtUsHz1+qmucv1czzl2rm+Vvb/PxnJj+XmcnPZWbyc5m5/GxmJj+XmcnPZWbycxkb3yUAAAAAAIACEwYBAAAAAAAUmDAIAAAAAACgwIRBAAAAAAAABSYMAgAAAAAAKDBhEAAAAAAAQIEJgwAAAAAAAApMGAQAAAAAAFBgwiAAAAAAAIACEwYBAAAAAAAUmDAIAAAAAACgwIRBAAAAAAAABSYMAgAAAAAAKDBhEAAAAAAAQIEJgwAAAAAAAApMGAQAAAAAAFBgwiAAAAAAAIACq9owKE3TSNO00ssAAAAAAACY0RoqvYA9kaZpnPHijdHbm8YV/5NGXV3VZloAAAAAMO3SNI0vfjmNx1ZvjnnzBuNNf5HE7NlJpZcFwBSpyjCouzvi0ccGIyLiFzdFnPycCi8IAAAAAKrIQw9HXPq1iIi+iIg49OCIM8+o6JIAmEJVX1LznasrvQIAAAAAqC4bNow8/dSG0a8HQDFUfRh00y0Ra9eZHQQAAAAAY7Vx48jTHR3eXwMosqoPg9I04vs/qPQqAAAAAKB6dGwceXr7cAiAYqn6MCgiYtUqn1wAAAAAgLHauDF7P621pXR6UwUXA8CUK0QY9NjqSq8AAAAAAKpHXgl04IH1I04DUEyFCINWr45IU9VBAAAAADAWQ2FQw4jTABRT1YdBSRLR1R3x1FOVXgkAAAAAVIe8LdyBBwxVBvmwNUBxVX0YtGRJttUqDgAAAADGplwZVAqDevsiuroqtx4AplbVh0HL9sm2jz1W2XUAAAAAQLXIw6B99qmL5ubseMfGSq0GgKlWnDBotTJWAAAAANidgYE0Nm3Ojre318X8+dlxc4MAiqv6w6Bl2VZlEAAAAADs3uYtEfl4oPb5Scyflx0XBgEUV/WHQeXKoMquAwAAAACqQUdHtp07N6KhIRmqDNpUsSUBMMWqPgzaZ1gYlKZaxQEAAADAruQVQHlFkDZxAMVX9WHQ4sXZtrs7YsvWyq4FAAAAAGa6vAIoD4HaS9uNG33QGqCoqj4Mam5KYtas7PjGjsquBQAAAABmunJl0Px8m4w4H4DiqfowKCKivT3bbhAGAQAAAMAu7RgGlc43MwigsAoRBi0QBgEAAADAmOTt4LafGdThvTWAwipEGJRXBnVsqOw6AAAAAGCm27Yt286enbWHmzM7O711W4UWBMCUK1QYtKHDkDsAAAAA2JWu7mzb1pptW0vb7u7KrAeAqVeIMGhBe/Ypho6NlV0HAAAAAMx0eejTUgqBWlqybVdXZdYDwNQrSBiUbbWJAwAAAIBdy0Of1paR2+6uiDTVeQegiAoRBrUvyLYbDLkDAAAAgF3Kw6C8IihvEzcwGNHXV5k1ATC1ihEGzc+2wiAAAAAA2LW8TVzrdm3ihl8GQLEUIgzK28RtFAYBAAAAwC515WFQKQRqaEiisTE73mluEEAhFSMMKrWJ6+qO6OrS1xQAAAAAdiav/mlpHTovrw5SGQRQTIUIg1pbI5qbs+NaxQEAAADA6NI0Lc8Mah3WHi5vGdetMgigkAoRBiVJUp4b1CEMAgAAAIBR9fZGDA5mx1uHVQblwVCXyiCAQipEGBQR0V5qFbdhQ2XXAQAAAAAz1fA2cC0tOx7XJg6gmAoTBi1oz7YdGyu6DAAAAACYsfLKn6bGiPr6pHx+XiXUqU0cQCEVJgzSJg4AAAAAdi2fF9TSOvL88swglUEAhVSYMGjOnGy7ZWta2YUAAAAAwAyVhz2t24VB5TZxKoMACqlAYVBW1rplS4UXAgAAAAAzVF4Z1Noy8vz8dJfKIIBCKkwYNDevDBIGAQAAAMCoym3itguD8tNdXbruABRRYcKgOcIgAAAAANilvE3cDmGQmUEAhSYMAgAAAIAakbeBa9tuZlBbazLicgCKpTBhkDZxAAAAALBr5cqg7cKgvFKou2t61wPA9ChMGKQyCAAAAAB2bfczg6Z3PQBMj8KFQV3dEX19Bt0BAAAAwPa6urL3zVq3C4Py09rEARRTYcKgWbMikqy1qeogAAAAABhF3iaudbs2cfnpbmEQQCEVJgyqr09i1qzsuDAIAAAAAHaUV/60tCQjzs/DIJVBAMVUmDAoYqhV3GZhEAAAAADsIJ8JtH1lkJlBAMVWqDBobikMUhkEAAAAADvqLlcGjTw/P90tDAIopEKFQXOEQQAAAACwUzurDGrTJg6g0IoZBm2t7DoAAAAAYCYqh0E7qwzqjkjTdHoXBcCUK1QYlLeJ27y5susAAAAAgJloZ23i8kqhNI3o6ZneNQEw9QoVBg21ifPpBQAAAADYXt4Gbvs2cc3NO14HgOIoWBiURIQ2cQAAAAAwmu6dhEH19Uk0NZWu0zW9awJg6hUqDNImDgAAAAB2Lp8ZtH2buIiItlJApDIIoHgKFQYNtYmr7DoAAAAAYKYZHEyHKoNGCYPygKhLZRBA4RQzDNImDgAAAABG6OkZOj5aZVBLqTKoW2UQQOEUKgzK28Rt0SYOAAAAAEYYHgY1N+94eUvpPGEQQPEUKgyaNTvbbt1W2XUAAAAAwEzT15dt6+sj6uuTHS7PA6Le3mlcFADTolBh0OxZ2banJ6K/P63sYgAAAABgBslDnqam0S/PzxcGARRPocKgtrah49tUBwEAAABAWW+pMqipcfTLhUEAxVWoMKihISkPv9vWWdm1AAAAAMBMsrvKoLxNXI8wCKBwChUGRUTMKlUHbdta2XUAAAAAwEySzwxq1CYOoOYULwwqzQ1SGQQAAAAAQ8wMAqhdhQ2DtpoZBAAAAABl5TBoJzODmkthUE9POj0LAmDaFDYM0iYOAAAAAIbkYVDjTsIglUEAxVXcMEibOAAAAAAoy2cG7a5NXI8wCKBwihsGaRMHAAAAAGW7qwxqbk6y6/VM04IAmDaFC4Nml8MgvU0BAAAAINdbqgxqVhkEUHMKFwbllUFbVQYBAAAAQFneJq5xN2GQmUEAxVPAMCgrZ+0UBgEAAABAWR7y7GxmUHNztu3RJg6gcIoXBrVlW5VBAAAAADBkdzODVAYBFFfxwqDZ2XabMAgAAAAAynp7sxnbO5sZ1CwMAiis4oVBpcogYRAAAAAADCnPDNpJZVC5TZwwCKBwihcGzcq2wiAAAAAAGLK7mUHaxAEUV3HDoM7KrgMAAAAAZpLecmVQMurlwiCA4ipcGDQ7D4O2RqRpWtnFAAAAAMAMsbvKoHxmUE/P9KwHgOlTuDAorwwaGPSPCwAAAABy+cwgbeIAak/hwqDW1oi60le11dwgAAAAAIgIM4MAalnhwqAkSaKtLTu+bWtl1wIAAAAAM0Ue8jQ2jn55c3O27e+PGBgwfgGgSAoXBkUMtYrb1lnZdQAAAADATDHWyqDh1wWgGAoZBs3OwyBt4gAAAAAgIobNDNpJZZAwCKC4ChkGldvECYMAAAAAICJ2XxlUX59EQ8PI6wJQDIUMg/I2cVuFQQAAAAAQEUOVQTubGRQxFBT19Ez9egCYPoUMg/LKoK6uyq4DAAAAAGaKnt1UBg2/TGUQQLEUMwxqzbadnZVdBwAAAADMFOWZQcIggJpTzDCoVBnU2ZlWdiEAAAAAMEPkAc+u2sQ1N2fbHmEQQKEUOwzSJg4AAAAAIiKiT5s4gJpVyDCotTWJCG3iAAAAACDXm7eJ20VlUB4GqQwCKJZChkF5ZVCXyiAAAAAAiIGBNAYGsuO7qgxqzsOgnqlfEwDTp5hhUGu2VRkEAAAAABF9fUPHdzUzSJs4gGIqZhiUzwwSBgEAAADAiHBnLJVBwiCAYil2GKRNHAAAAACU5wXV1UU0NCQ7vV5Tc7bVJg6gWIodBqkMAgAAAIBypc+uqoIiVAYBFFUhw6DW0sygLpVBAAAAABB9pXBnV/OCIswMAiiqQoZBbaUwqLMzIk3Tyi4GAAAAACpszJVB5TZx3lMDKJJihkGlNnEDAz7FAAAAAAD5zKAmlUEANamQYVDeJi4iolOrOAAAAABq3Fgrg5qakhHXB6AYChkG1dcn0dKSHe/srOxaAAAAAKDS+kqVQbubGVRuEycMAiiUQoZBEUPVQV0qgwAAAACocWOvDBp5fQCKobBhUFspDFIZBAAAAECtK88MEgYB1KTihkFt2VYYBAAAAECtG2tlUHPp8p6eqV0PANOr+GGQNnEAAAAA1Li+Uhi0u5lBjaUwKJ8xBEAxFD8MUhkEAAAAQI3rHWMY1NQ48voAFENxw6DSzKAulUEAAAAA1Lh8ZlDzbtrENQqDAAqpsGFQaykMUhkEAAAAQK0ba2VQfrk2cQDFUtgwaKhNXFrZhQAAAABAhfX1Ze+RNe2mMii/vFcYBFAoxQ+DtIkDAAAAoMbl4U7jGMMglUEAxVLgMCiJCG3iAAAAACBvE7e7yqBymzgzgwAKpbhhkJlBAAAAABARQ+FOU2Oyy+s1lcKgXmEQQKEUNwwqtYnr0iYOAAAAgBo31sogM4MAiqmwYVCryiAAAAAAiIhhM4Mad329/PKBgYjBwXRqFwXAtClsGJRXBnWqDAIAAACgxo23Migiok91EEBhFD8MUhkEAAAAQI3Lg52mMVYGRZgbBFAkxQ2DtIkDAAAAgIgYe2VQQ8OOtwGg+hU3DCpVBnV1RaSp/qYAAAAA1K68MqhxN2FQkiTlwEibOIDiKHwYNDDgUwwAAAAA1LaeMVYGRQy1kusVBgEURmHDoJaWoeOdXZVbBwAAAABUWl8eBu1mZlDEUPWQyiCA4ihsGFRfn5QDIXODAAAAAKhlY50ZFBHRmFcG6bYDUBiFDYMiItpas60wCAAAAIBaVp4ZNIbKoDwwEgYBFEexw6DS3KAubeIAAAAAqGHjqQzKW8lpEwdQHDURBqkMAgAAAKCW9ZaCnTHNDBIGARRObYRBKoMAAAAAqGHjqgzK28QJgwAKo9BhUKuZQQAAAADUuMHBNPr7s+ONYwiD8sogM4MAiqPQYVCbMAgAAACAGje83dtY2sTllUF9wiCAwih2GFRqE9elTRwAAAAANWp4hc9Y2sSVK4O0iQMojJoIgzo708ouBAAAAAAqZHhlUEPD7q+fVw/1CYMACqM2wiCVQQAAAADUqLwyqKkpIkmS3V4/nyskDAIojkKHQa2t2T83M4MAAAAAqFV5u7exzAuKGNYmzswggMIodBjU1ppthUEAAAAA1KrhlUFj0dyU387oBYCiKHYYVJ4ZVNl1AAAAAECl5O3eGscYBjWaGQRQODURBnWZGQQAAABAjRpvZZAwCKB4aiIM6hQGAQAAAFCjymHQGGcGNTVlc7h7zAwCKIxih0FmBgEAAABQ48ZbGZRfT2UQQHEUOgxqFQYBAAAAUOPKM4PGWBlUbhOnMgigMAodBpVnBnVGpGla2cUAAAAAQAXs6cygXpVBAIVRE2HQwODQPz0AAAAAqCV5qDPmmUF5ZZAwCKAwCh0G5W3iIiI6uyq3DgAAAAColHFXBjWNvB0A1a/QYVBdXRKtLdlxc4MAAAAAqEXlmUFjDIPy0EhlEEBxFDoMihhqFScMAgAAAKAWjbcyKG8TpzIIoDgKHwblreKEQQAAAADUot7eNCIiGsc4M6jRzCCAwil8GFSuDDIzCAAAAIAalFf4NI91ZpDKIIDCqZkwqEsYBAAAAEANKs8MGmNlUN5OrldlEEBhFD8M0iYOAAAAgBqWV/iMNwzSJg6gOAofBuUzg1QGAQAAAFCL8gqfpqZkTNcvzwzSJg6gMAofBpVnBqkMAgAAAKAG9ZXDoLFdvymfGaQyCKAwaiYM6upKK7sQAAAAAKiAvE3cWMOgvDKotzciTb2nBlAEhQ+DWs0MAgAAAKCG9e3hzKCIiP7+yV8PANOv8GFQW1vWC7XTzCAAAAAAalDPOCuDhl+vT6s4gEIofBiUVwZ1CYMAAAAAqEHlmUFjrAwaXkGUt5gDoLoVPgxq0yYOAAAAgBo23plBdXVJ1Ndnx1UGARRD8cOgtmwrDAIAAACgFuWBzlhnBkUMVRGpDAIohsKHQdrEAQAAAFDLxjszaPh1e1UGARRC4cMglUEAAAAA1LLyzKBxhEGNTSNvC0B1q50wSGUQAAAAADVovDODIoZaymkTB1AMhQ+DtIkDAAAAoJb1lQIdM4MAalfhw6C2UhjU1xfR15dWdjEAAAAAMM0mUhmkTRxAMRQ+DMorgyJUBwEAAABQW9I0jd58ZtB4KoPMDAIolMKHQQ0NSfmfV2dnZdcCAAAAANNpeJgznsqg/Lq9wiCAQih8GBQR0daWbYVBAAAAANSS4WHQeGYGldvEmRkEUAg1EQblreI6tYkDAAAAoIb0Dgtz9mRmUK8wCKAQaiIMyiuDzAwCAAAAoJbkbd4aGyOSJBnz7bSJAyiW2giD8sogbeIAAAAAqCF5Zc94WsRFRDTlbeKEQQCFUBNhkDZxAAAAANSifObPeFrERUQ0lq4vDAIohpoIg/I2cSqDAAAAAKgleZu3pnFWBg3NDEond0EAVIQwCAAAAAAKqncPK4OaymHQ5K4HgMqojTCo1Cauq8snGQAAAACoHXmbt3HPDNImDqBQaiIMas0rg8wMAgAAAKCG7GllULlNnDAIoBBqIgxqa00iIqJLGAQAAABADSnPDBpvm7im7P00lUEAxVAjYVC2NTMIAAAAgFoy4cogM4MACqE2wqC8TZwwCAAAAIAa0lcKc/Z4ZpAwCKAQaiIMai1VBmkTBwAAAEAt2dPKoCYzgwAKpSbCIJVBAAAAANSiPMwZb2VQfn0zgwCKobbCIJVBAAAAANSQvDKoebwzg/I2ccIggEKoiTBImzgAAAAAalHfHlYG5W3ieswMAiiEmgiD2kphkDZxAAAAANSS3t40IvZgZlBeGSQMAiiE2giDSm3ienoiBgbSyi4GAAAAAKZJeWbQeNvEmRkEUCg1EQblbeIitIoDAAAAoHbs8cygUhjUKwwCKISaCIOampJoaMiOaxUHAAAAQK3I27w1Nibjul25TZwwCKAQaiIMihiqDlIZBAAAAECtyCuDxjszqFwZZGYQQCHUTBiUzw3qFAYBAAAAUCPKM4Max3e7cmWQMAigEGonDCpVBmkTBwAAAECtKFcGjTcMMjMIoFBqJgzSJg4AAACAWpPP/NnTNnEDAxEDA+nkLgqAaVczYVC5TZzKIAAAAABqRB4GNY4zDBoeHvWpDgKoesIgAAAAACionrxN3ATCIK3iAKpfzYRBeZu4Tm3iAAAAAKgRfXs4M6i+PiJJRt4HANWrZsKgvDKoq0uPUwAAAABqQ+8eVgYlSVKeG6RNHED1q50wSGUQAAAAADWmPDNonJVBEUPVRNrEAVS/mgmDWluzulYzgwAAAACoFXtaGRQR0dg08j4AqF41EwblbeKEQQAAAADUiryqZ7wzgyKGAiRt4gCqX+2EQaU2cV3axAEAAABQIyZUGZS3iVMZBFD1aiYMalUZBAAAAEANSdN0aGbQHoRBeTWRyiCA6lczYVC5TZzKIAAAAABqwMBAxOBgdlxlEEBtq50wSJs4AAAAAGrI8BDHzCCA2lZzYZA2cQAAAADUguFhUOMEwqBeYRBA1audMMjMIAAAAABqSF7RU18fUV+fjPv2eYDUp00cQNWrmTCotVQZ1N0dMTiYVnYxAAAAADDF8sqgPZkXFDFsZpDKIICqVzNhUF4ZlKZZIAQAAAAARZaHOHsyL2j47XpVBgFUvZoJg5qbI+pKX21XV2XXAgAAAABTbaKVQfnt+lQGAVS9mgmDkiQpt4rrFAYBAAAAUHB5iNO4p23ihEEAhVEzYVBERFseBnVWdh0AAAAAMNXKlUETbhNn/jZAtaupMGjWrGy7bVtl1wEAAAAAU22ibeIaS2GQyiCA6ldTYVBbW7bVJg4AAACAoiu3idvDyqDGcmXQ5KwHgMqpzTBIZRAAAAAABTfRyqCmpiS7H5VBAFWvpsKgcps4M4MAAAAAKLjeCVYG5SGSNnEA1a+mwqC21mxrZhAAAAAARZdXBjVPdGaQNnEAVa+mwqC8MqizM63sQgAAAABgipVnBk0wDDIzCKD61VQYVJ4ZpE0cAAAAAAU30ZlBeUWRmUEA1a/GwqBs6J02cQAAAAAUXR4G7enMoHKbOGEQQNWrqTCo3Cauq7LrAAAAAICp1tubjUrY45lBpdsJgwCqX22FQaU2cSqDAAAAACi68sygPawMajIzCKAwaioMymcGbTMzCAAAAICCm+jMoEZhEEBh1GQY1CUMAgAAAKDgesuVQcke3b5JmziAwqipMCifGaRNHAAAAABFN9HKoHKbOGEQQNWrqTBImzgAAAAAakVe0bPHbeJUBgEURk2FQbPyNnFdEYODaWUXAwAAAABTaLJmBvWZGQRQ9WoqDMorg9I0oru7smsBAAAAgKmUh0F5qDNe5TZxwiCAqldTYVBzc0R96Ss2NwgAAACAIpvwzKDS7Xr7ItJUlx2AalZTYVCSJNE2KzveaW4QAAAAAAVWnhm0h5VBwyuK+vsnvh4AKqemwqCIoVZx24RBAAAAABTYZFUGRQwFSwBUp5oLg2blYZA2cQAAAAAUWB7g7OnMoOG36zE3CKCq1V4YlLeJ66rsOgAAAABgKvXmbeL2sDKori6JhobseJ8wCKCq1VwY1NqabTtVBgEAAABQYBNtExcxVB2kTRxAdau5MCivDDIzCAAAAIAiy6t59rRNXEREU+m2vcIggKpWe2FQaWZQpzAIAAAAgAKblMqg0m1VBgFUt5oLg9pKYdC2bWllFwIAAAAAU6g8M2gClUF5VVGvmUEAVa3mwiBt4gAAAAAouoGBNAYGsuMTqQxqLt1WGARQ3WouDGprSyIionNbhRcCAAAAAFNkeFu3icwMym+rTRxAdau5MCivDNoqDAIAAACgoIZX8kxoZpAwCKAQajYM2iYMAgAAAKCg8nlBdXURDQ3JHt9PHiT1CoMAqlrNhUGzVQYBAAAAUHB5ZdBEqoIihiqDzAwCqG41FwaVK4O2VnYdAAAAADBV+krhzUTmBUUMhUl9wiCAqlZzYdDs2dlWZRAAAAAARTXplUHaxAFUtdoLg0qVQZ2dEWmaVnYxAAAAADAF8vCmaaKVQaXb9wmDAKpazYVBeZu4wcGIrq7KrgUAAAAApsKkVQY1jbw/AKpTzYVBLS0R9aWveptWcQAAAAAUUF7JM2kzg/p02AGoZjUXBiVJErPMDQIAAACgwCarMihvE6cyCKC61VwYFDHUKk5lEAAAAABFVJ4ZNNE2cWYGARRCTYZBs0th0NatlV0HAAAAAEyFSZsZlFcGCYMAqlpNhkEqgwAAAAAosr5SGDTxmUFJRGgTB1DtajIMmm1mEAAAAAAFllfyTDwMyrbaxAFUt5oMg1QGAQAAAFBkeSVP82TNDFIZBFDVajIMGpoZlFZ2IQAAAAAwBfomqzLIzCCAQqjJMEhlEAAAAABF1tubfQi6aZIqg8wMAqhuNRkGzZ6dDb4zMwgAAACAIirPDJpoGGRmEEAh1GQYpDIIAAAAgCLLK3kmWhmU316bOIDqVpNh0NDMoMquAwAAAACmQl8eBjUmE7qffGZQnzZxAFWtJsMglUEAAAAAFNlkVQblM4O0iQOobjUZBs2enW23dVZ2HQAAAAAwFcozgxondj/57XtVBgFUtZoMg8qVQdrEAQAAAFBAk1UZ1GxmEEAh1GYY1JZtt26LSNO0sosBAAAAgEmWt3VrmmhlUNPI+wOgOtVkGJS3iRsYiOjpqexaAAAAAGCyTfrMIG3iAKpaTYZBra0R9aWvfKtWcQAAAAAUTF7J0zjBMCivLNImDqC61WQYlCRJuTpo85bKrgUAAAAAJlvPJFcGDQxEDAwYtwBQrWoyDIqImDMn224RBgEAAABQMHlbt4nODBoeJpkbBFC9ajYMyiuDtIkDAAAAoGjymUGNkxgGaRUHUL1qNgwqVwYJgwAAAAAomDwMam6e2P3U10fU1Y28TwCqjzBImzgAAAAACqZ3kmYGJUlSvg9hEED1qt0wqNQmThgEAAAAQNFMVhg0/D6EQQDVq2bDoKGZQWllFwIAAAAAkyhN0+iZpDZxERHNwiCAqlezYdCcOUlEqAwCAAAAoFgGBiIGB7Pjk1kZ1NMz8fsCoDJqOAzKtlu2VnYdAAAAADCZhlfwNGsTB0AIg1QGAQAAAFAowyt4JqMyKG81JwwCqF61GwaVZwZVdh0AAAAAMJnyeUFNjRFJkkz4/rSJA6h+NR8GqQwCAAAAoEjyCp6m5sm5P23iAKpf7YZB2sQBAAAAUEB5Bc9kzAuK0CYOoAhqNgyaXaoM6uqO6O9PK7sYAAAAAJgk5cqgSQqDtIkDqH41HwZFRGwxNwgAAACAgsjDoOZJbhPXozIIoGrVbBhUX5/ErFnZca3iAAAAACiKvIJnsiuDtIkDqF41GwZFRMwpVQcJgwAAAAAoisluE5dXGPX0GrUAUK1qOgyaLQwCAAAAoGCmqk2cyiCA6lXTYdCcOdl2q5lBAAAAABREz2RXBgmDAKqeMCgitgiDAAAAACiIyW4T19SURMTQLCIAqo8wKLSJAwAAAKA4ym3iVAYBUFLbYVBpZtDmzYbfAQAAAFAMeQXP5FUGZVthEED1qukwaN68rMR18+YKLwQAAAAAJklvb/bB50mbGdScbbWJA6heNR0GzZ2bbTcJgwAAAAAoiHKbuObJuT+VQQDVr6bDoPnzsq3KIAAAAACKQps4ALZX02FQuTJoU2XXAQAAAACTJQ9tmpqSSbk/beIAql9Nh0HzhEEAAAAAFIw2cQBsr7bDoFKbuC1bIwYH08ouBgAAAAAmgTZxAGyvpsOgvE3c4GDE1q2VXQsAAAAATIahNnGTc3/lNnHCIICqVdNhUGNjEm1t2fFNmyu7FgAAAACYDD3axAGwnZoOgyLMDQIAAACgWCa7MkgYBFD9hEGluUHCIAAAAACKoGey28SV7qevL2JgwNxtgGpU82FQPjdoszZxAAAAABRAXsHTPMmVQRFZIARA9an5MKhcGSQMAgAAAKAAenqy7WS3iYvQKg6gWgmDyjODlLgCAAAAUP0muzKooSGJ+vrseB40AVBdhEHzkohQGQQAAABAMeSBTXPz5N1nXh2kMgigOtV8GFSeGbSpsusAAAAAgMmQBzaT1SYuYqjKqEcYBFCVaj4MKreJUxkEAAAAQJVL03RKwqCmUpWRyiCA6iQMmpdtN6kMAgAAAKDKDQ9rpqJNnJlBANVJGJSHQSqDAAAAAKhyw8OgqWgTpzIIoDrVfBhUnhm0OSujBQAAAIBqlYc1SRLR0DB596tNHEB1q/kwqH1+tu3ri9i6taJLAQAAAIAJ6SmFNc3NEUmSTNr95pVBPcIggKpU82FQc3MSs2Zlxzs2VnQpAAAAADAheeXOZLaIG35/KoMAqlPNh0ERQ9VBHR0VXQYAAAAATIgwCIDRCIMior09227YUNl1AAAAAMBE9PRk2+ZJDoPKbeJ6Jvd+AZgewqCIWLAg22oTBwAAAEA1UxkEwGiEQTG8TVxa0XUAAAAAwEQIgwAYjTAohtrEmRkEAAAAQDXL27hNdhjU3Jzfvw9TA1QjYVBEtLcnERGxQRgEAAAAQBXrLoVBra2Te79DYdDk3i8A00MYFBELVAYBAAAAUADd3dk2D28mS3Nz9mHqbmEQQFUSBoU2cQAAAAAUQ16509Iyufeb319P9+TeLwDTQxgUQ2GQNnEAAAAAVLO8MqhlkiuD8jBIZRBAdRIGxVCbuM5OQ/AAAAAAqF7dpfe2mqeoMqhbZRBAVRIGRcSsWRGNjdlxreIAAAAAqFZ5G7fWyQ6DSpVGPSqDAKqSMCgikiTRKg4AAACAqpe3cWtuTib1fptVBgFUNWFQSfv8bKsyCAAAAIBqlVcGtagMAmAYYVDJggXZVhgEAAAAQLXqysOg5sm9XzODAKqbMKgkD4OefKqy6wAAAACAPZWHNc2TXBnU3Dzy/gGoLsKgkkV7Zdsnn0wruxAAAAAA2EN5G7cpqwzSJg6gKgmDSvbaKxuqt/7JCi8EAAAAAPZQ9xTPDOrujkhTH6YGqDbCoJK8MkgYBAAAAEC1yiuDmqeoMigiord3cu8bgKknDCpZtCjbPiUMAgAAAKBKTVVlUFPTjo8BQPUQBpXstTDbbuiI6O9X6goAAABA9emeoplBDQ1JNDaOfAwAqocwqGT+/IiGhog0jXhqQ6VXAwAAAADj11Oq2mme5MqgiKHWcz0qgwCqjjCopK4uiYWl6qD16yu7FgAAAAAYrzRNp6wyKGKo9ZzKIIDqIwwaZtFe2fZJc4MAAAAAqDK9vVnXm4jJnxkUMRQwmRkEUH2EQcPslYdBT1V2HQAAAAAwXj3DKnaap6AyKG8916MyCKDqCIOGySuD1q9PK7sQAAAAABinvGKnoSGioSGZ9PtXGQRQvYRBwyxalP2T1CYOAAAAgGozlfOCIswMAqhmwqBh8jZx64VBAAAAAFSZnlLFTvMUzAuKGGo916MyCKDqCIOG2WththUGAQAAAFBtVAYBsDPCoGGWLs2269ZFpKm5QQAAAABUj3yWT8sUVQaZGQRQvYRBwyxeFFFXF9HbG7FhQ6VXAwAAAABj15NXBk1Vm7iW/HF8iBqg2giDhmloSGLxouz4mrWVXQsAAAAAjEeXyiAAdkIYtJ28VZwwCAAAAIBq0lMKaZrNDAJgO8Kg7eydh0FrKrsOAAAAABiP7qluE9ecRMRQ6ARA9RAGbWfvvbN/amvW6n0KAAAAQPXI27e1qAwCYDvCoO2oDAIAAACgGvX0ZB9ubjYzCIDtCIO2s/fe2XatmUEAAAAAVJGprgzKQ6YelUEAVUcYtJ2lpcqgtesiBga0igMAAACgOkz1zCCVQQDVSxi0nUV7RdTXR/T3Rzz1VKVXAwAAAABj01MKaZqbkym5fzODAKqXMGg79fVJLFmSHV+jVRwAAAAAVWKqK4OaS5VBPSqDAKqOMGgU+5TmBj22urLrAAAAAICxmuqZQSqDAKqXMGgU++2bbR95xMwgAAAAAKpDTymkaTYzCIDtCING8bT9sr6qjzxa4YUAAAAAwBh1dWXbqaoMykMmYRBA9REGjWK//bLtI49Udh0AAAAAMFadpTCorW1q7r+1Ndv290f09emoA1BNhEGjyMOg1Y9H9Pf7xwYAAADAzNfZmW2nKgxqax06nlchAVAdhEGjWLRXRGtL9imHx9dUejUAAAAAsHvlMKh119fbUw0NSTQ1jnwsAKqDMGgUdXVJ7LtvdlyrOAAAAABmujRNo2uKK4OG37cwCKC6CIN2ojw36NHKrgMAAAAAdqe3N2JgMDveOkWVQRERrXkYpE0cQFURBu3E0/ZLIiLi4UfMDAIAAABgZhsezkxlGJS3oFMZBFBdhEE7kVcGPfRQRZcBAAAAALuVhzMtLRH19cmUPU7eJq5LZRBAVREG7cSBB2Tb3/8+YmBAdRAAAAAAM1ceBrVNYVVQxFDVkcoggOoiDNqJfZdHNDdHdHVHrF5d6dUAAAAAwM6Vw6C2qX2c/P6FQQDVRRi0E/X1Sbk66IHfVXYtAAAAALAredu2qZwXFDFsZpA2cQBVRRi0CysOyrYPPKhNHAAAAAAzVx7OTFtlUJf3ywCqiTBoFw46KBu29+CDFV4IAAAAAOzCdLWJay3df5c2cQBVRRi0Cwc9I9s+8LuINPVpBwAAAABmpnIYNOVt4pIRjwdAdRAG7cKBB0TU10Vs3Bjx5JOVXg0AAAAAjG66KoPKM4OEQQBVRRi0C83NSey/f3b8nnsruhQAAAAA2Kmu0gyf1qmuDCrPDJraxwFgcgmDduOIw7Ptb+/SJg4AAACAmSkPZ6a8MiifGSQMAqgqwqDdOPKIrA/qb++s8EIAAAAAYCeG2sQlU/o45cogbeIAqoowaDeOPCLbPvDAULktAAAAAMwk5TBoitvEtZoZBFCVhEG7sWRJxOJFEQMDEffeV+nVAAAAAMCO8nBmymcGle5fmziA6iIM2o0kSeKIUnWQVnEAAAAAzERd0zwzSGUQQHURBo1BPjfottu1iQMAAABg5umc5jCoty+iv997ZQDVQhg0BieszLa/vTNi61b/5AAAAACYWcozg6Y4DBrehk51EED1EAaNwbJlSey3bzY36NZfVXo1AAAAADBSOQya4plBjY1JNDaWHtPcIICqIQwaoxNPzLY33aQyCAAAAICZI03T6CqFQa1THAZFDAVOKoMAqocwaIyec2I2N+imWyIGBwVCAAAAAMwMvb0RA4PZ8aluEzf8MYRBANVDGDRGRx4RMWtWxMaNEffeV+nVAAAAAEBmeLu26agMyh+jS5s4gKohDBqjhoYkVh6XHf+FVnEAAAAAzBB5hU5LS0R9fTLlj1euDBIGAVQNYdA4nHRCqVXczRVeCAAAAACUdE7jvKAIbeIAqpEwaBxOOD4iSSIe+F3E+vWqgwAAAACovDyUmTUN84IihkInYRBA9RAGjUN7exKHHJwdv+mWyq4FAAAAACIitmzJtnPmTs/jzZqVbbdtm57HA2DihEHj9JyTslZxP/qxyiAAAAAAKm/z5mw7Z/b0PN6cOdl2yxbvjwFUC2HQOP3JH2et4m67PWLNGv/wAAAAAKisLVuzbR7STLW5c7IPS2/eMj2PB8DECYPGaenSJI4+Kjt+zQ+EQQAAAABUVl6hM11h0FBl0PQ8HgATJwzaAy86M/v0wzU/iOjrEwgBAAAAUDl5KDNXGATATgiD9sCpz41ob49Yty7isisqvRoAAAAAalnerm1OqX3bVMtnEwmDAKqHMGgPNDcn8ZY3Zf9cL74kjbXrVAcBAAAAUBlbymHQ9DxeuTJo6/Q8HgATJwzaQy88PeJZR0Z0d0d86CNpDA4KhAAAAACYftMdBs2dO/JxAZj5hEF7KEmSePffJdHSEnHb7RGXf6PSKwIAAACgFm2e7plBpTZxnZ0R/f0+IA1QDYRBE7Dfvkm89S1Zu7jPfzGNu+72zw8AAACA6TXdlUGzZw97bK3iAKqCMGiCXnJWxGl/FNHfH/G+f0zjyScFQgAAAABMjzRNpz0MamhIoq0tO65VHEB1EAZNUJIk8Z53JbH//hFPPhnxt+9KY/MWgRAAAAAAU6+rK2JgIDs+XW3iIoaCJ2EQQHUQBk2CtrYkPvLBJBYuiFj1+4h3vyeN7m6BEAAAAABTK58X1NAQ0dIyfY+bzw0SBgFUB2HQJFm2TxIf+7ckZs+OuPOuiPf/Uxq9vQIhAAAAAKbO8BZxSZJM2+POnVt6fDODAKqCMGgSPePAJP71Q0k0N0fcdHPEu96TRmenQAgAAACAqVEOg2ZP7+PmbeI2b57exwVgzwiDJtmRRyTx4X9JorUl4le3Rbz1r9PYsEEgBAAAAMDkyytz8kqd6aJNHEB1EQZNgeOOTeKiTyYxf17EAw9EvOmtaaz6vUAIAAAAgMm1pVSZk1fqTJf88bZs9Z4XQDUQBk2Rgw9O4nP/nsTee0c8/njEBW9O44fX+ucIAAAAwOTZXLE2cdl8IpVBANVBGDSF9l2exJc+l8TK4yJ6eiL++YNp/NvHBqOrSygEAAAAwMTllTnTXRk0N68MEgYBVAVh0BSbPz+Jf/twEq9/XXb6qqsjzj0/jdvvEAgBAAAAMDF5GDPtM4OEQQBVRRg0Derrk/j/Xl8Xn/hoEkuWRKxZE/G2d6TxkY8ORsdGoRAAAAAAe6Y8M2h2Mq2PKwwCqC7CoGl03LFJXPqVJF76kuz01d+NeNVr0vjvy9Lo6xMKAQAAADA+Gzqy7fz26X3cvE3c5s3T+7gA7Blh0DRra0vine+oi3//dBIrDorYui3i3z+XxqvOSeOqq4VCAAAAAIzdhg3Zdq+F0/u4efjUsTEiTb2fBTDTCYMq5FlHJvGlzyfxnncnsXBBxNp1Ef/2sTT+/DVpXP6NNLZu9U8UAAAAgF176qlsu3DB9D7uglIY1N+vOgigGgiDKqi+PokXnZHEZV9P4m1/mYVCTzwR8enPpHH2y9P46McH4/e/FwoBAAAAsKOenjS2bsuOL5jmMKipKYm5c7PjT22Y3scGYPyEQTNAS0sSf/aKJC7/7yT+9h1J7L9/RFd3xLe/E3Hu+Wm89e2D8d3vqRYCAAAAYEgewjQ1RcyePf2Pn1cj5dVJAMxcDZVeAEOam5M4+yURL/0/EXf8OuKbV6Zx440Rv/5NxK9/k8bHPxnxnOek8SenJ3H8cRGNjUmllwwAAABAhQxvEZck0/8+0YIFEX94aGhuEQAzlzBoBkqSJI4+KuLoo5JY90Qa1/5vxA//N42HHor4yU8jfvLTNGbPjjjl5DROOy2JY48WDAEAAADUmjyEWbiwMo9frgwSBgHMeMKgGW7J4iRe+5qIc14d8bsHI354bRrX/Tj75Mc1P4i45gdpzJkTccpz03jeHyVxzNERDQ2CIQAAAICie7JUGTTd84JyeQj11IY0IrwfBTCTCYOqRJIkseKgiBUHJfGWN6Vx510RP/5JGj+9PmJDR8T3ron43jVpzJsbccopWTB01LMFQ8DkGBhIY/36iC1bIubM6Y+kLo1Fe0XU1fkbAwAAUCkbNmTzpStVGbRgQRIRqTZxAFVAGFSF6uuTePazIp79rCTe/ldp/Oa3ET/+aRYMbdwYcfV3I67+bhrz50Wcekoaz39eEs86MrsdwFikaRoPror46fVp3HZ7xAMPRPT25ZduioiI1taIQw9J46QTk3j+8yL2WuhvDAAAwHQamhlUmf2xPIQSBgHMfMKgKldfPzRf6K//Ko1f/yYLhq6/PmLjpoirro646uo02tsj/ujUrGLoyCMEQ8DoBgbSuOFnEV+/LI177x15WWNjxNw5EUldEh0daXR1Rdx2e8Rtt6fx2c9HnPZHaZx/XhL77evvCwAAwHQozwyqVJu4fGbQU5V5fADGThhUIA0NSRx7TMSxxyTxN29P445fZ63krv9ZREdHxJXfjrjy22ksXFAKhk5L4ojDtXkCIrq707jmBxGXXZ7G6sez85oaI44/PuLk5yTxrCMi9t47C5Lb29tj/foN8cgjEb+6Pfs7c9fdEdf9KOInP0njzDPSOO91SSxZ7G8LAADAVHoyD4Mq1iYu2z6lMghgxhMGFVRDQxLHHRtx3LFJ/O07sjZPP/5pGtffkP2D/uaVEd+8Mo299oo4rRQMHXaoYAhqTcfGNL51ZRpXfjurJoyImDs34k/PjnjZS5Nobx/9b0JDQxIHHBBxwAERf/byJB74XRr/eXEaN/484urvRVz3ozT+4g3Z/ahEBAAAmBp5ZdCCSlUGlUKoLVsienvTaGqy/wcwUwmDakBDQxLHr4w4fmUS73xHGr+6Lfsk/89ujHjyyYgrvhlxxTezYOiYo9M49ugkjj46fKofCuzhh9O44ptZNVBvb3be3ntHvPIVSZx5RkRr6/h+/1cclMSH/yWJu+5O498/l8add0V8+jNpXPejiL//u4gDDvD3BAAAYDINDKTRUQqD9qpQZdCc2VlXid6+LJhaurQy6wBg94RBNaaxMYkTT4g48YQkenvT+OWvsoqhPBj64bURP7w2jYiI5cvSOPjgiGccmMQzDow46BkRCw2Ih6rV35/GLbdGXHlVGjffMnT+wc+MeNUrkzj1uVl4PBGHH5bEv386qw767OfTuOfeiNf/RRrnvDqN17028SkxAACASbJpU8TAYESSRMyfX5k1JEkSCxaksXZd1olGGAQwcwmDalhTUxLPOSniOScl0dOTfZL/tjvSuO22iPvuj3hsdXa47kdp+TazZ6WxdGnE3ksjlizNqocWtGflyPPnR7S3R8yfN/E3lIHJ0d+fxt33RPz0+jT+90cRGzdm5ydJxMknRbzi5Ukc9ezsBfxkqatL4iVnRZx0QsTHP5nGz34e8V+XZmt4999FHHmEvw8AAAAT9fiabLtor8q+D7NgQWRh0FMVWwIAYyAMIiIimpuTOPaYiGOPSSLeELF1axp33h3x4IMRDz6YxoOrIh59LGLrtogHV2WHTDrq/c2bm0Z7e8S8edn8kXlzI+bOi5g3N8mOz93usrkCJJgM/f1pPPhgxF33RPz6N2n86lfZ722uvT3i9BdEnP2SJJYvn9rfuUWLkvjg/4u4/oYsFHr4kYi/fFsaZ78kjTddkERbm995AACAPfXY6my7fHll17F0acQ990asWVvZdQCwa8IgRjV7dhInHh9x4vEREdkbtt3daaxZG7F2bfaJjzVr03jiiYiOjtJhY1aiPDgYsWlzdtjR6OFRRMSsWemIcGj+vIjFiyOWLk1i6ZLsxcXSJREtLd5Ahr6+NB5bHfHwwxEPPRzx0MNpPPRQxCOPDs0Ays2bG3H8yog/fkESxx07vcFrkiTxR6dGHH10xL9/Lo3vXRPxrW9H3PiLNP76ryKee/LkViUBAADUitWrS23+KxwGLVuWbR9bnUb+HhIAM48wiDFraUni6ftHPH3//Jwd/8EPDKSxeXMWDm3oyAKhzZuzkGjz5nS709nlW7dGpGnEtm3ZYc2a7e91ZIA0f36ahUNLSq3qFiWxaFEWHC1elJUn19d78UF16+pKY90TQ+HrunVZD+a1ayPWrYt48qkseB3NnDkRhx0acdihSaw8LpsJVOnfiblzknjPu5J4wfPS+NePpbFmTcR735/GMUdHvO2tEQce4HcWAABgPB59LNsuX1bZ/ans8dN47LGKLgOA3RAGManq65Nob89aUR2ww6WjvzgZGEhjy5ahcGjT5ojNmyI2bsreAF9TevN77bosLNq4MTvcd39+DyPDovq6iIV7pbF4UUT7/Kwd3bx5EfPnJzG/fLy0nRfR1qYygekzOJjGpk1ZmPPUUxEbNmRDNp/akMb69UNhz8ZNu7+v1taI/Z+WHZ72tCT23z9i//0i9tknm9szEx13bBKX/GfEJV9L47LLIm67PeL1b0jjT/44jXNfm8S+U9y6DgAAoCgeK4dBlV3H8nJlUGXXAcCuCYOouPr6JObPzwKaHY18Y3jLlqHqiLxaYv36iCfWR6x7IuKpJyMGBiOeeCI7jDR6i7qmxoh589LyGubPz0Ki+fOTEafbS8dnz565b7QzPQYH0+jujujqGjps2RqxZUt22Lwle64OP715cxb6dGzInqNjMWtWqQKudFi6JCmfXro0YuGC6gwyW1uTeOMbkjjrRWl89nNp/PSGiO//MOKH/5vGH78gjT9/RRIrDqq+rwsAAGC6pOlQJU6l28TlYdC6dVlL88ZG+3MAM5EwiKoyZ04Sc+ZEHPSM/JyRLzAGBtLYsCELh9avz6orNm2K2Lgxq8bYmB82Zofe3ojevoj1T2aHkUYPj+rrsvCovT1rSbegVAm1YEEy4vTCBVn10VS050rTNHp6Ijo7syCiszOirz9rG5am2TY/Xl8f0dwU0dRc2pYOs2ZN7+yY8ervT7OfT+nQ1xfRU9r292eHgYGh4/39Ef2l0wPbnR55/TT6+7Pv18Aoty3fvnS6uzuis2tk8NPdPfGvb/78iIULs+fJwgXZ8b32Ghb2LMme70W2z95J/L//m8Q996Zx8X+l8YubI354bcQPr03j8MPSOPslSZzy3Cw8AgAAYMimTRFbt0UkScSyfSq7lgULIlpbIrq6s9b/++1X2fUAMDphEIVSX5/ND1q0aPtLRn8zuasrzYKhYQFRx8aIjZvS8ulN+WWbsjZ1A4PZPKQNHRGrfj/83nYMj+pKwdGCYcHR3LkR8+ZtizRNy8HM4GAWVOSHzq40tm3NXtjls5S2bi0dLwVAO5sXMx6tLWnMnp3NmJk9OzvMGXE6idmzsuBo9uzSdtjp5uZdv0k/MFAKrbqy72P5MMocqS1bRlbX9PZO/OubakmStWprbR36vpW35UMWYM6dMxT6tLfP7CBuuh16SBL/+uEk7rsvjf++PI2fXh9x190Rd92dRktLxEknpvG8P0rixBN2/5wDAACoBXlLtkWLKr+flCRJLFuWxoOrsnUJgwBmJmEQNa21NYnW1oi9997+ktFfSPX2ZhVGHRsjOkqB0IYNERs60ugozX7Jz9+0KQtsOjqyw8jgaBJKS8pfQ0RbaxYqJXURdcmwbZJVt+TVNT2l7cBAdtuu7uywY1VUbvTqqOGX19fHyENdVlXT05M99mRoaChVNDVGNDRGNNRn5412qN/+stLp+u1Ol8+rz4KZ4devH3b71pahwCc/tJW2zc3V2aZtpjr44CQ+cGESTz2VxtXfi7jmB2k8/njEj38S8eOfpNHaGnHcsWmsPDaJ446LWLaP7z0AAFCbHi21iNu3wi3icsuXRzkMAmBmEgbBODQ1jb3yqL8/jY2bshkxG4YFR1u2pBFJS2zZ3J21PeuNqNsuUGltiZg1q1SVMzt2qM7Jw4iWlj2bX9Tfn5arjfJqnK1bh53emmbHt4ysSsorlTo7sxZ0EUPVTLtSXxcxZ27EvLlZ67x5cyPmzsuOz52TxNy5Iytq5s7Jvs6mpojGxqlptcfMtXBhEuedG/G610bcf3/Ej3+axo9/ks0Ju+FnETf8LHvyLV+WxjFHRxx5RBJHHpHNURLOAQAAteCxx/L9ogovpCRfx+rVaezsA7YAVJYwCKZIQ0MSey2M2Gvh9pck0d4+Kzo6KtcHraEhyUKZeTu7xq5fuA0OptHZOVRlNLBdm7vGUiVPc3N2aGras9CK2pYkSRx8cFYx9OY3pnHf/RG3/jLi1l+mcdfd2SfOHlsdcdXV2U7Qor0ijjwijSOPSOKIIyIOPECQCAAAFNP9D2TbA54+M/Z5li9LIiItVywBMPMIg4Bxq6tLYvbsSq+CWpIkSRxycMQhB0e87rVJbNuWxh2/jvj1b9L47Z3ZjtD6JyN+9JOIH/0kC4daWyOeuSKNQ0qB0iEHR+yteggAAKhyg4PZB+QiIg4/vLJrye2/f7b93YMRaZra7wKYgYRBAFSdWbOSOPk5ESc/J9vB6O5O4557I357Z8Sdd2U7Rtu2Rfz6N9khn381b27EwQcPBUTPPChir70ERAAAQPV4+JGsnXtLS9YRYSY46BnZ3N2OjojH10Qs26fSKwJge8IgAKpeS0sSRx8VcfRRERFJDAyk8fDDEffeH3HvfWncd182zHTT5ohbbs0OeUA0d27EAU9P4xkHRhxwQBIHHhDx9P0j2toERAAUR5qm0d8/+mUNDT4YQWZgIHueJElEXV02z9RzA2aeu0tVQYccnLWBnwmam5NYcVD2Ib277xYGAcxEwiAACqe+PokDDog44ICIF52R7Rz19qax6vcR994Xcd99adx7X/aJus2bd6wgiojYZ580Djwg+6Td05+exH7LI5Yvj2htnRk7WwDUljRNR22709WVxpq1EWvXRqx7ImLdurS0jdi8JaKzM6JzW0RnV8Tg4Oj3nSQRbW1pzGqLaGuLmDMnq5xdvDhi76VJPG2/iKc/PWLhAsFAterqSuOppyKe2pAdNmyIeGpDdt6GDVHedmwc+Typr4+YMyeNOXMi5syOmD8vYtGiiMWLk1i8KHuOLF4csXhR9kYwMD3uvDvbb5kpLeJyhx8Wcc+9EXfdncbpf+xvAsBMIwwCoCY0NQ3NHYrIdkx6etJ4+JGIVasiVv0+jd//ITv+1IaIxx/PDj+7MWJ4SLRorzT23Tdi3+UR++6bxPJlEUtKb4TMnetNMgAmX5qmcfbLN8VTT6Vx1FFpdHVlb9qvWROxceNk3H/WXnXbtlEvLR+bPz/iyCPSeNaRSTzriIhnPGPmfCK96NI0je7urMp58+asPdSWrdk2O6TbnR66fPPmiK6uPXvcgYHsObbj8yzd4boLF6axz94RS5dmcxr32TuJvUunlyz2XIHJdNdd2fbwQ2fW79VhhyUR3xiaZwTAzCIMAqBmZa0MIlYcFJEHRBERGzdmwdCDqyJ+//ssMHr00YiNmyLWP5kdbr8jYvs3QpqbIxYvTmPxouxTs/PnRcyfn8T8+dkbaO3Dtq2tgiMAxqa7O+J3Dw5ERMSPfrzj5XPmRCxdUnrTfUnEksVJLF6c/b9pK1X7zGqLaGrKqoAisgAoIvtP1ts7soJoU+n/3RNPpLH68YiHHo5YvToLBG74WcQNP8tu3Noa8awj0zjm6CSOPTriwAMj6upq+3/b4GAavb0RfX0R/f3Ztq8/or8vonfYedtf1tWVBT2bNqexedNQ6LNpc/bz2Lwpu/1EtLRk1V0LFmTbhQsjFixIhh3Ptq0t2fNjcDCiqztiy5ahQ8fGiPXr03hifcQTT0SsL227urPqoqeeirjzrvwRh14n1dVFzJmdxqzZ2XNx1qzsddPwl0L58bxFXb5tqI9omxUxe1Y2N3JW6fjs2dlhzpxsO3eO11fUhtWPZ/snSZJV4swk+XpWrcoqEnVVAJhZhEEAsJ3580fOIMpt3pzGo49Fdng0O/7Y6uxNkI0bI3p6stDo0UeH39uOn5yNiGhqjJg/P4357RHz5kbMm5dvk6HTww9zs9lIANS2N10QMW9uEnPnReyzNAuA5syZhP8PC0c7c+h+e3rSeOB3Eb/5bcRvf5vGb+/Kqk5uviXi5luy/3Xz50UcdVQaRx+VfdjiwAOq639XmmZVV1u3RmwtVUpt3Zad3lY+L822pdM9PZti48bB8nnbOoeCtqnQ2JiFHnPmZm3bZm93mDM7idmzs7BlzrCwZOGCPQtK5s7NqnpGGnkfaZrG5s1ZpdrjpZaFj69JY82a7Ly1a7Mga1Mp3JqYXX9z6+simlvSaGraEA0NaTQ2ZN+zxsZsNlZDQxYwDQ+bhp+ur4tI6iLqkoi6+u2uk2SXDb9OUlf6eacRg+nox+vrs0C2tS2irTULsxa0Z8HbwoXZz0aLPcbjBz/Mfg+OOzbbd5hJlixOYvGiLDD+9W8jTjy+0isCYDhhEACM0dy5SRx2aMRhh0Zs/0ZIT0+afTq2dHjyyazCaOOmofYqGzdmn6jt6cneFMmvO9LO3+Robk7LQdHcudmbbkOBUVI+b/jWJ2QBiuVPz04q8knr5uYkjjg84ojDI+LVSQwOprFqVcSvbo+47fY0fvObrIL2Jz+N+MlPs/9ldXURey9NY8mSrGI2r4xtbk6iri5rQZYd0ujri+juiejuyqpMenqyapmentLp7mzb1xfR2JBVOeWHlpbs0NqaVbW0tES0lI43NCTR15dGf39WjdPbNzzYiRHBTmfnzucq7Vz/Li/NQ4jGxmzdDY1Dx4df1tw89OGPuXOzD4bMLZ8e+uDITPy/niRJ+fXIwQeXzy1fPjiYRkdHFgQN/5739maXD3/ls32Ykg5mP7POzmFBXB7QbStVLG3Ntv39EQODpSq3zilM5CZk9HXNnpWWK7MWtEe0t0e0tyfZdn52uq0toq219DxvzZ43M+25wNQbHEzj+z/Ijp/xwpn58z/5ORHf+nbEtf+bxonHz8w1AtQqYRAATILm5iSWL49Yvnz4uaPv/HR1pVk4VAqK8hYwmzal2TZvCbM5u86mTdkbHD09OwuQInZVgTRvXhpz5w0FRPPmZu1WZrUl5dZBs2YNayU0K8pDxFtbtfwBYEd1dUkcdFDEQQdFvOrPs8DlnnuzNqp33pXG7x6M6OiIWP14dhhpOt+oH/9j1deXWpLNzluT7Xh61qysAmfpklkRsS2rzCld1tqahVT19d6sj8ieK3kVzMTs/HuZpmn09GShUE9PRGvr3Hhqw+bo7R3Wkq/Uni9vgTdY2qal4+lgFibtcDq/XpqFl+XbDw5VgeWVRdsfT5LsNp2daSmkysKwDRuyGZVPPZWFYltLIdkjY6guz9XXR7S2pNHSGtHSHNHckm1bWrJwsbk5O93amj93k1Gfy3nLvZaW4etOIk3TYYFtKWzbbts/7LK6pHS/pVaA9fWe+1Ph17+JWLsu+9mdcnKlVzO6F/5JEt/6dho3/CwLcWfN8lwAmCmEQQAwzVpbk2htjdh77+0vGX1HKW9bs7E0M2DjsKBo8+a0HBiVzyud7i3NJ8jnHI1yz2Nab1tbWg6N2mZln0rNe/03NmaBU2Pj0Ce0GxuT8vn1DVmv//qG7E2Lhvx06fio22HHd7j9iNvasQSYKRobk3jWkRHPOjIi/3/21FNpPPJoNldm3RMRW7ak0dWdVf8MpiP/9jc2ZG9mt7Yk2RvarUNvbA8/NDaWKnx6s0NPz1D1UF5V1N0d0dWd/e8cGChV5DQMVeG0tSVDrdVGCXuyWTZj+x/T3t4cHR2dU/eNZUySJCk/RyIi2tsbYmHHTHqdsPPXeFu3DoVDTz4VsbEjomNjVk21oSOrKt+4MaKrM5vplVdUDQwMhUhjM55gdOKBbVtbGu3zs1lUCxZk1U3L9umM1tY0FpZOz5071LovHRz6/e3uzioDu7uH/U53RXR3Z1WE2e9yUv6dnj0ra4eYH+bOzdopZgHXTHoeTNyPf5L9bJ73RzO3veAhB0fst28Wbv70hogXnVHpFQGQEwYBwAyXJEm5amefcQRI3d1ZKDQyPMoqkDq7skHh2zrz1itR/sTqttLpgWxWefn8UfOk0R99z77QcUqStPxGYnPT0Cdim4d9Knb7T8fOm78tIh2MlpbsTaPWlqF2KyMOpfNbWoROAHtq4cJku2qQ6fx76m83M1+SJOUA42lPG3HJTm8zMJCWw5HOrqyFYndPFpj0lLbdPUOtFbu60h1aIm5/On/NNxb1O/lQz2ApnMrDqvz148jKwK5xfHd2Z/evNxsaIubOSYcColK7xfmlFstDx7ND+/wsJJ6pAVKapvHzX2THT3nuzFxjRPb9+5PTI770H2lc96M0XnTGzF0rQK0RBgFAASVJUg42li7d4dLd3j5N0+jtHQqKtg0LivIQKf9Udm9vWm6/0tNbasXSm1UlDQxEDGzXRmTU7U4uH8i3o8xwSNMoz4Do7o6IMQ2l7s5vPZYrR0REU1Maba3D5lFsd2hpiWGXJ+U+/nVJ9q3OB0yPth0+wDrf5rcZfl59/cj5GPmhuUkrIgCoJfX1SalV4VhvsevXB3mLve7SS6TyK6Ttqvfyw+5eb/T1ZbOdtmzOqpo2bMgqnDZsSGNbZ3OsXdsTT22I6NiQzXsaLL0GTOqyD+M0twyb/dUy8vVWa14dmLep6xtqs7dlS3bYvDli85ah14gbShVWo3zlo66/oSGifX4a7e0R8+dHeW7T/PkjZzi1z89CvObmbDbZdHjgd1m1f0tLxNFHTctD7rE/OiXiS/8RccevszaJbW1epwLMBMIggN0YGBiIm266KdatWxdLliyJE088Merr6yu9LJhSSZKUK2ra23d77Slfz+BgGoODo4dJfaV2QT3dWRg1/BOx3T1Dn5Lt6UkjoiU2buoe9mnZGPHp2vx4V9fQEPE89IpNY1lpZQZW19VloVXWpq8UFjVmg8rztnujHupL12kYdr0Rt0lGv01D1rqvcbvL6utLA7/ToTkKw0+npW/RiNORPYPy8Gt4OLb96TwYq6uLqK+LqKvf7vSw88qn64bewKobdp7wDAB2bLE3UY2NSRaYzI/Yb78RjxTt7bOjo6Nvch5oF/IK+c3DA6JSSJRVzZfmdG4aqqLftCn7AFR//85aLO/8NV59XRpNzaUP6TRnr8Ma8tdJjdm2sXHo9dLw8/PXYS3NQ7PI8vmd+fHZs7JWzTf8LFvDccfO3BZxuf32i1i+LOKx1RG//FXEqadUekUARAiDAHbp6quvjve+9/2xevUj5fOWLdsvPvjBf46zzjqrgiuD2lJXl0RdXbazvOeSaG+fFR0dvbu9Zl4ZlYdFnV0jg6OuYaFRdkhHXHegf2j49OCw8GNwcOfbEdcfHHmb/oFStdXww7D3UgYHh3rsT67KhFvTob4ujbr67QKjUpiUh0uRB1JRGqq93emkbtjx/PLtTtclQ3NKRlR2DZ+zVa70SkZUfDU3j9zutVdf9PSkO1yeV4dVIuRKS6mfcA2AmWJ4hfySxaNeY9Tb9fRkszg78llNpW1HR1rajjy/r/RabGBw6DXhxIztddfJz5n5/3OTJInnnJTGZVdE/PymNE49ZddrHhjIKtR6e7MPd/X3lz4INOz1VF1d9mGk5tJrIK2cAcZPGASwE1dffXWcd955MXvO6bH/gV+MlpaDo7v7vnhq/SfivPPOi4svvlggBAU1vDJqjLeYyuWManAwa8/Xu31IVNqJ7u0dqp7KD339pbZ9/UMtVvr6hl8vHXmd/Hp9u7rN0P0ODEQ5EMlb3u0uLImIcrXQaEFYGtl5A4Ol7UB2/sBgaTtQajEz/PTgUGXXzgwMjt5+sLJ29ybQ7nshJkk6onJqeDXU9hVUdXm7wu0qqerqh73pskNFVf442c/ovvuz87/42TSWL6+b+LcAACqkuTmJJYtHC5B2fJ2Xf3CoHGCUqtHzlsn566W+/qHXUfnx8nkDpev0ZZVM5VlOww756Txoam+POPmkKf9WTIqTTkzisivSuP6GiE2bBssfqurpyT5YNbyKv79//Pff2JiWX6/n80HzmaGtLREtw9oLZq0Gkx1aDtbXD1WVNwyvOK8fWVmeXx4x7DXrsNersd15EUOvs5Lhr7GGnR5eJdZQP1Q95gM2wFQSBgGMYmBgIN773vfH7Dmnx/KnXRpJkr3B1Tbr2GhtuzQee/i18Q//cGGceeaZWsYBFVFXN97AaiyKs/OZpukO4VB/KTgacXpw6Lz+YZcNDpSCqF20vdvd6fwwMLBjVVd+vK8vLYd35TBvuzeW8oBvoL8uOrsGR1xnx6+7NGdrICKmvhNP2S9ujvizl0/f4wFAJY3/g0O7vLfdXmNgII1tnXmIUR2v1551ZMS8uRGbNkf8/Bdjv11jKRwpvw4rfTgo//BPLp9ZunXrWO+5OireGxrSckjU1LQh6uvTodbMw9oONjWVZms1l4Kv5mzmVktz1voxD8ZamodmcG1/Xn66Wp5TwMQJgwBGcdNNN8Xq1Y/E/gd+sRwE5ZKkLhYu+ut4aNUZcdNNN8XJJ59coVUCsDNJkpQ/0TmzjX3nu729PTo6hqZg559KzqvA0rRUITWseiodHFlJNTiQfXJ1eFCWB0iDgzu53bD7yx442/T0pPGRj2bHX3j6JH07AIAd1NcnMXdOpVcxPg0NSXziYxG/+e3IwCIPJsoBxQ6tb3f+2mhwMB1RhdXTXZoP2jO07c5bO3fnLZ7T7U5nh/zDM/0DQ8cHhx0vnzc4VBEfUarsyVsH141sZZcMq6IeXtmev/YafhgYGGo1OFxeeR/dEXsWYI3/NvX1aTkkam4ZqoLaU+V5n8Oqz5O67SrRx3iorxuqphp+PG/dPLwbQV39UOvlHVo0D2vFPPzQ0DA0YzafPdvdNfR82f451N8X0dS0JXp7sxfGSZLNChuqThsKivPneGtp29aa/R60tg6d19ioGozpJQwCGMW6desiIqKl5eBRL28unZ9fDwCm2+R+Knn80jTimh9kbzjMmWMnFgCq2cDAQNx0002xbt26WLJkSZx44okT7oKx4qAkVhw0SQuMrDI+nwc1djP3NUqapuVQqNx+eVgrwda2ubFhw+by+eXL+4bCsO5SkNHTk45ov9fdPSzk6Bl2ftfQ5Xlb5YGBodaExTDVVWC7mkE7vseur49obUl3CInKx0vntzSPPod2tNmzu3y8hlJrxaaRwVUeymbzuEbOVe0fGHreDH9+bR+05tdJ05GtpfNtfX2pwq1hqC1jQ0O2pvJl+Xn1WaBcPl6fXa9hp9eNmD+/N7q60hGPM/y6I84fdvuGhuxvy3hU89xUYRDAKJYsWRIREd3d90XbrGN3uLyn+74R1wOAWpMkSXz2oqHjAEB1+ta3vhVve9s7YvXqR8rnLVu2X3zwg/9sTu4USpKk/Gb0aNrbG6KjY6yvscb/ZnZ//46hUXd3qd3wTm+3u/sdGVRsX3GeV0wN7uL47g/pqK2ZBwdHtmMey6Gvf6giKg9impt3nDuVBTTZz6utrTW6uroiSbLHzCrV0h0r1YZVo+WhSX48rwobGMhmg22tSBA301snjnd9W/b4kerr03KLynI7xlGqypqbsvN/e2fEor0i/uOL1bcfJAwCGMWJJ54Yy5btF0+t/0S0tl06olVcmg7GU+s/GcuXPy1OPPHECq4SACqr2nZ+AICRrr766jjvvPNi9pzTY/8DvxgtLQdHd/d98dT6T8R5550XF198sUCogJIka6XW2Bgxp8paEFa62qu9vTU6Orq3O3d8a+rvT0cNifI2hiPPzypwyi0KS9usXV5SruJJkqHDaNI0qy7r6UlHzigdNqu0p2fH9tEN9TvOnGreLiRrbR26LKmLiDykyx97WLvF/tK2fLo/m4vWPxAx0D/8vKHr5qcHdnr7iDTqo7dnYORl2113oH/k7LFceebqOHR0ZD+n8VUqVp4wCGAU9fX18cEP/nOcd9558djDr42Fi/46mlsOjp7u++Kp9Z+MrVuujc9cdPGEy+YBAACgEgYGBuK9731/zJ5zeix/2tCHINtmHRutbZfGYw+/Nv7hHy6MM888074vTKKGhiTmzBlrEDfZ4ddM/DDXxNfU3j5/xHzVnRkcTGNwcKjtYv9A1paxLw+iSsf7SlVmPb0RvaXQrLc3YuvWND7z2Qkvt2KEQQA7cdZZZ8XFF18c733v++OhVWeUz1++/GnxmYt8OgoAAIDqddNNN8Xq1Y/E/gd+cUQ3jIiIJKmLhYv+Oh5adUbcdNNNcfLJJ1dolQCTp64uq6ZqaMiqmcarqyviM5+d6S32dq4qw6CWloijnt0Q/f39e/RDAxirs846K84888xJH6QJADBW9n8AmArr1q2LiIiWloNHvby5dH5+PYBa19ISccThQ8erTVWGQUmSxKUXz42Ojg59yoEpV19f71NQAEDF2P8BYCosWbIkIiK6u++LtlnH7nB5T/d9I64HUOuSJInPXjR0vNrU7f4qM1OSJFX5DQcAABgv+z8ATLYTTzwxli3bL5568hORpiOnqqfpYDy1/pOxfPnT4sQTT6zQCgFmnmp+XV61YRAAAAAAsGfq6+vjgx/859i6+dp47OHXRue2X8bAwJbo3PbLeOzh18bWLdfGv/zL/9UmHaAghEEAAAAAUIPOOuus+MY3vhFz59wbD606I+6/++nx0KozYt7c++Liiy+Os846q9JLBGCSVOXMIAAAAABg4l72spfFKaecEjfddFOsW7culixZEieeeKKKIICCEQYBAAAAQA2rr6+Pk08+udLLAGAKaRMHAAAAAABQYMIgAAAAAACAAhMGAQAAAAAAFJgwCAAAAAAAoMCEQQAAAAAAAAUmDAIAAAAAACgwYRAAAAAAAECBCYMAAAAAAAAKTBgEAAAAAABQYMIgAAAAAACAAhMGAQAAAAAAFJgwCAAAAAAAoMCEQQAAAAAAAAUmDAIAAAAAACiwJE3TtNKLAAAAAAAAYGqoDAIAAAAAACgwYRAAAAAAAECBCYMAAAAAAAAKTBgEAAAAAABQYMIgAAAAAACAAmuo9AJyv/3tb+Oiiy6KO+64I/r7+2PFihVx3nnnxZlnnjnm++jt7Y0vfvGL8Z3vfCfWrFkT8+bNi9NOOy3++q//OhYuXDiFq6fWTfT5+61vfSve85737PTySy65JI4//vjJWi6UXXXVVXHbbbfFXXfdFQ888ED09fXFhz70oXjZy142rvsZHByMr33ta3H55ZfHww8/HG1tbXHSSSfFO97xjth3332naPXUssl47t5yyy1x7rnn7vTyPfldgN1Zt25dfP/7348bbrghfv/738eTTz4Z8+bNi6OPPjre8IY3xLOe9awx35e/vdWhUvs53/nOd+KSSy6JBx98MBobG+Poo4+Ot73tbXHYYYdN1pdW1Sbyc0nTNG644Yb48Y9/HLfffns8/vjj0d/fH0972tPizDPPjNe//vXR3Ny8w+2e+cxn7vQ+zz777Pjwhz88oa+pCCq1XzUZv6dFNtHvz/Oe97xYvXr1Lq/zta99LY499tjyab8vu1bJ/bif/exn8YUvfCHuvvvuSJIkDjvssHjLW94SJ5544mR8aVVtMn4uv/rVr+K6666LW2+9NVavXh2dnZ2xbNmyeP7znx9vfOMbY+7cuTvcZle/YytXroxLL710j7+mIqjkvuMf/vCH+OQnPxk333xzdHV1xf777x+vfOUr41WvelUkSbJHX09RTMbP5bWvfW3ceuutu7zORz7ykXjpS19aPl3rvy8zIgy6+eab4w1veEM0NTXFi170opg1a1Zce+218Y53vCPWrl0b559//m7vY3BwMN785jfHjTfeGM9+9rPj9NNPj4cffjiuuOKKuOmmm+Lyyy+PBQsWTMNXQ62ZjOdv7vnPf34ccsghO5y/bNmyyVwylH3qU5+K1atXR3t7eyxevHi3O2k7c+GFF8YVV1wRBx10ULz2ta+NJ554Ir7//e/Hz3/+87jsssti//33n9yFU/Mm67kbkb3gW7ly5Q7nj/b3GCbq0ksvjS996Uux3377xXOe85xYsGBBPPzww3HdddfFddddFx/72MfG/Oaav70zX6X2cz73uc/FJz/5yVi2bFm88pWvjG3btsX3vve9eOUrXxkXX3xxHHPMMVP1JVeFif5cent744ILLoimpqZYuXJlnHzyydHb2xs33nhjfOITn4jrrrsuLr300mhtbd3htsuWLYuzzz57h/P9z6ncftVkPm4RTcb359xzz40tW7bscH5HR0d87Wtfi3nz5sURRxyxw+V+X3auUvtxV111VbzrXe+KBQsWlN+wveaaa+L1r399fPKTn4wXvvCFE/3Sqtpk/Fze/va3R0dHRxxzzDHxkpe8JJIkiVtvvTW+/OUvxw9/+MP4n//5n9hrr712uN2cOXPida973Q7nez+pcvuODz74YLzyla+M7u7uOOOMM2Lx4sVx/fXXxwc+8IFYtWpVvP/979/jdRTBZPxczj777FF/Hv39/fGFL3wh6urqRg2qa/r3Ja2wvr6+9AUveEF6+OGHp/fcc0/5/M2bN6enn356ethhh6WPPfbYbu/nG9/4RrpixYr0b/7mb9LBwcHy+V//+tfTFStWpO9///unZP3Utsl6/n7zm99MV6xYkX7zm9+cyuXCDn7+85+Xn6Nf+MIX9uh5eNNNN6UrVqxIX/Oa16Q9PT3l83/605+mK1asSM8///xJXTOk6eQ8d2+++eZ0xYoV6ac//empWCKM6oc//GF6yy237HD+L3/5y/Swww5LjzvuuBF/S3fG396Zr1L7OX/4wx/SQw89ND399NPTzZs3l8+/55570sMPPzw944wz0oGBgUn4CqvTZPxcent7089+9rPpxo0bdzj/jW98Y7pixYr0S1/60g63W7FiRXrOOedMzhdSMJXar5qsxy2qqf7+/Md//Ee6YsWK9J//+Z93uMzvy65VYj9u48aN6bHHHpsef/zx6Zo1a8rnr1mzJj3++OPT448/Pt2yZcsEvqrqNxk/ly984Qvp2rVrR5w3ODiY/uM//mO6YsWK9J/+6Z92uM1pp52WnnbaaXu+8IKr1L7ja17zmnTFihXpT3/60/J5PT096atf/ep0xYoV6e233z6uNRTNZPxcduYHP/hBumLFivSNb3zjDpfV+u9LxWcG3XzzzfHII4/Ei1/84hEp6pw5c+JNb3pT9PX1xZVXXrnb+7niiisiIuJv/uZvRpTZvfKVr4x99903rr766uju7p78L4CaNlnPX6iUk046acKffMj//r797W+Ppqam8vmnnnpqrFy5Mm688cZ4/PHHJ/QYsL3JeO5CJZx++umjfnrt2GOPjeOPPz42bdoU999//27vx9/ema9S+znf+ta3or+/P9785jfHnDlzyucfcsgh8eIXvzhWrVoVt91222R8iVVpMn4ujY2N8eY3vznmzZu3w/lvfOMbIyLil7/85eQvvsAqtV9lf27Xpvr7841vfCMiIl7+8pdPeK21phL7cT/4wQ9i8+bNcc4558TSpUvL5y9dujTOOeec6OjoiOuuu25Ca6p2k/FzueCCC2LJkiUjzkuSJN7ylrdEhP8ve6IS+45/+MMf4pe//GUcf/zxceqpp5bPb2pqire//e0REXH55ZdP65pmmqn8ufj/snMVbxOX9/U7+eSTd7gsP293f+h6enriN7/5TTz96U/f4UmUJEmcdNJJcdlll8Vdd901ogctTNRkPH+Hu+eee2Ljxo3R398fy5cvjxNPPDHa29snZ7EwRW655ZZoa2uLo48+eofLnvvc58att94at95664gerTCTPPTQQ3HxxRdHT09PLFmyJE488cQddsBgOjQ0NIzY7oq/vTNfpfZz8sd9znOeM+rjfutb34pbb701jjvuuPF/UQUw2a/ft5f//tbX1496+ebNm+Oyyy6Ljo6O8rywXc1GqRWV2q+a6udDtZvK78/tt98eq1atisMPPzwOPvjgUa/j92Vqjfe1xO6eDxdddJHXHlNod/9fent741vf+lY88cQTMXv27DjiiCPGNYuSsRnrvuOufl+OOeaYaGtrq+n/L1Np7dq1ceONN8aiRYvij/7oj0a9Ti3/vlQ8DHrooYciIuJpT3vaDpctWrQo2tra4uGHH97lfTzyyCMxODi4077o+fkPPfSQMIhJNRnP3+G2H1LW0tISf/mXfxkXXHDBhNYJU6WzszPWr18fK1asGPVFaf67MZ7fA5hu3/3ud+O73/1u+XRDQ0Occ8458a53vWunO1sw2R5//PH4xS9+EYsWLYoVK1bs8rr+9laHSu3nPPTQQ9HW1haLFi3a4fqeG5P/+n173/zmNyNi9DAuIuK+++6LCy+8cMR5z33uc+MjH/lILFy4cI8ft9pVar9qqp8P1W4qvz/5p7Zf8YpX7PQ6fl+mzp68ltjV88H/l6m3u/8v69evj/e85z0jzjviiCPi4x//eOy3335Tvr5aMdZ9x139vtTX18fy5cvjwQcfjP7+/jF9EIyx++Y3vxmDg4Nx9tln7/R7W8u/LxV/tm3dujUiYkQLg+Fmz5496qDB4fLLZ8+evdP7GP5YMFkm4/kbEbF8+fJ4//vfHyeffHIsXbo0Nm3aFDfddFN8/OMfj4997GPR2toar33tayd17TAZxvr3dyy/BzDdFixYEH/7t38bp512Wixbtiy6urrijjvuiI997GNx8cUXR5Ik8fd///eVXiY1oK+vL971rndFb29vvPOd79xtCOlvb3Wo1H7O1q1bY8GCBbu8fi0/Nybr9ftorr/++rjsssviwAMPHPUN7vPPPz9OP/302H///aOxsTF+97vfxWc/+9m44YYb4o1vfGNcdtllNfshhErtV03l86EIpur7s23btvj+978fra2t8eIXv3jU6/h9mVp78lpiV88H/1+m1r333hv//u//HgsXLow3vOENO1z+spe9LI455phYsWJFtLW1xUMPPRRf+cpX4qqrrorzzjsvvvOd7+z0Z83YjHffcXd/P2fNmhWDg4Oxbdu2HdrOsufSNI1vfetbEbHzFnG1/vtS8ZlBQMTKlSvjnHPOif333z9aWlpiyZIl8dKXvjT+4z/+I5qbm+Mzn/lM9Pf3V3qZAIVy0EEHxQUXXBAHHXRQtLW1xcKFC+MFL3hBXHLJJbFgwYK49NJL46mnnqr0Mim4wcHB+Pu///v45S9/GX/2Z3+mtQpUqd/+9rfxjne8I+bMmROf+tSnRszfyL373e+Oo446Ktrb22P27Nlx1FFHxRe+8IVYuXJl3HnnnfGjH/2oAisvFvtV1eGaa66Jzs7OeOELX7jTN9z8vkDm0UcfjQsuuCAGBgbi4x//+Kgf+HjrW98aJ554YixcuDBaW1vjkEMOiX/913+Nl7zkJbF69eryfCj2nH3H6nDzzTfHY489FitXrhy1KivC70vFw6DdfXpg69atO01Rc/nlO6v8yc8vcqpHZUzG83dXDjrooDjmmGNi48aNsWrVqj2+H5gqY/37O5HfA5huixYtiuc///nR398fv/nNbyq9HApscHAw3vve98Z3v/vd+D//5//EBz7wgTHdzt/e6lCp/ZxdfVLfc2NqXr/feeed8f/9f/9f1NXVxZe//OU46KCDxnzburq6chXR7bffPq7HLZJK7VdN9eNWu6n6/uTtrsY72Nvvy+TZk9cSu3o++P8yNR599NE499xzo6OjIz796U/HCSecMK7b//mf/3lE+H2ZSjvbd9zd389t27ZFkiQxa9asaVlnrchbkI73/0tE7fy+VDwMyvtcj9ZXdP369dHZ2bnTJC+37777Rl1dXbkf4/by83fWaxv21GQ8f3cnH3Ta1dU1ofuBqZDPJHjsscdiYGBgh8vz342J/h7AdPO3l6k2ODgY73nPe+LKK6+MF7/4xfHhD3846urG9tLc397qUKn9nP333788C2J7nhuT//r9zjvvjPPPPz8GBwfjP/7jP+LII48c95ry/zmdnZ3jvm1RVGq/ajoet5pNxffnwQcfjDvuuCMOOOCAPZrp7PdlcuzJa4ldPR/8f5l8eRC0fv36+OQnPxmnnXbauO/D78v0GO//l4GBgXjsscdi+fLl5gVNok2bNsX//u//xty5c+OFL3zhuG9fK78vFQ+DjjvuuIiIuPHGG3e4LD8vv87OtLS0xJFHHhl/+MMfYvXq1SMuS9M0fvGLX0RbW1scfvjhk7RqyEzG83dXBgYG4q677oqIiH322WeP7wem0sqVK6Ozs3PUT0/87Gc/i4iJ/R5AJeSf6lq2bFmFV0IR5UHQt7/97TjzzDPjX//1X8c998Df3pmvUvs5+X3+/Oc/3+njrly5chxfSbFM5uv3PAgaGBiIL3/5y/GsZz1rj9aU/89Zvnz5Ht2+CCq1XzXVj1vtpuL7M5FPbUf4fZlM430tMZbnQy3/f5lMw4OgT3ziE/GCF7xgj+7nt7/9bUTYp5lqo+077ur35bbbbovOzs6a/v8yFb7zne9ET09PnHXWWdHc3Dzu29fK70vFw6ATTzwx9t133/jud78b9957b/n8LVu2xOc///lobGwc0Tv9iSeeiFWrVu1QZvdnf/ZnERHx8Y9/PNI0LZ//P//zP/Hoo4/GWWedFS0tLVP7xVBzJuv5m++YDDcwMBAf/ehH4+GHH47jjz8+Fi9ePGVfB4zFhg0bYtWqVbFhw4YR5+d/fz/1qU9Fb29v+fzrr78+br311jj55JML/8+UmW1nz93R/vZGRPzXf/1X3HLLLbH//vvHEUccMR1LpIbkreG+/e1vxwtf+ML4t3/7t10GQf72Vq9K7ee87GUvi4aGhvjc5z434r7uvffe+O53vxsHHnhgHHPMMZP95VaNyXz9fv7550d/f3986UtfiqOOOmqXj3v//fdHX1/fDufffvvt8eUvfzkaGxv36FOsRVGp/arxPm6tmayfS66vry+uuuqq3X5f/b5Mrsl6LXHGGWfEnDlz4qtf/WqsXbu2fP7atWvjq1/9arS3t+9xaFGLdvZzyYOgJ554Ij7+8Y/HH//xH+/yflatWjVqN4NVq1bFRz/60YiIOOussyZv4QU3WfuOBxxwQBx33HFxyy23xPXXX18+v7e3Nz71qU9FRJTbXrJ7O/u5DDeWDxv4fYlI0uF7FBVy8803xxve8IZoamqKF73oRTFr1qy49tprY/Xq1fHud787zj///PJ1//7v/z6uvPLK+NCHPhQve9nLyucPDg7GX/zFX8SNN94Yz372s+O4446LRx55JK699tpYtmxZXHHFFaMOWYOJmozn7zOf+czyYcmSJbFp06a49dZb46GHHoqlS5fGV7/61dh3330r8eVRcFdccUXcdtttERHxwAMPxN133x1HH310ubz/mGOOKb9Aueiii+Izn/lMvPWtb42/+qu/GnE/73vf++KKK66Igw46KE499dRYv359XHPNNTFr1qz4n//5n3j6058+vV8YhTcZz93nPe950dDQEIcffngsWbIkurq64je/+U3cc889MXfu3D1u9wO7kj8f29ra4txzzx21NcQLXvCCOOSQQ0Zc39/e6lSp/ZzPfe5z8clPfjKWLVsWp59+emzbti2+973vRV9fX1x88cU1HQZFTPznsnHjxjj99NNj06ZN8dznPnfUiqA5c+bEeeedN+J+fvrTn8YxxxwTe++9dzQ0NMTvfve7+PnPfx5JksSFF14Yr3rVq6b8a5/JKrVfNZ7HrUWT8XPJ/fCHP4y3ve1tcfrpp8dFF12008f0+7J7ldqPu+qqq+Jd73pXLFiwIM4888yIiLjmmmuio6MjPvGJT8QZZ5wx1V/6jDZZ+yirV6+OZz/72XHyySeP+jjDr3/RRRfFV77ylTjuuONin332idbW1njooYfihhtuiL6+vnjjG98Yf/M3fzNVX3JVqNS+4+9+97t41ateFd3d3XHmmWfGokWL4vrrr4/f/e53cc4558T73//+afoOzEyT9XcsIgvr/vRP/zQOO+yw+Na3vrXTx/T7EjEjGhOecMIJ8fWvfz0+/elPxzXXXBP9/f2xYsWKeOc731n+57I7dXV18bnPfS6++MUvxlVXXRUXX3xxzJ8/P17+8pfHX//1XwuCmDKT8fw9//zz49e//nX84he/iE2bNkVjY2Pst99+8eY3vzle//rXx7x586b4q6BW3XbbbXHllVeOOO/2228f0SpgLJ9W+b//9//GihUr4vLLL49LLrkk2tra4o//+I/jHe94R+y3336Tvm6YjOfuK1/5yrjxxhvjl7/8ZWzcuDHq6upin332ide97nVx/vnnx9KlS6dk7dS2vNVXZ2dnfP7znx/1OsuWLSuHQbvib+/MV6n9nDe/+c2xbNmy+K//+q/47//+72hsbIxjjz023v72t8dhhx022V9m1Znoz2Xr1q2xadOmiMhaKeXtlIZbtmzZiDDo+c9/fmzevDnuu++++MUvfhF9fX2x1157xYte9KJ43ete58MHUbn9qsl43CKbzO/PWFvE+X3ZvUrtx73kJS+J9vb2+MIXvlB+w/Xwww+PN7/5zXHSSSdN8KuqfpPxc8lfK/7617+OX//616NeZ/ib4ccff3ysWrUq7r333vjVr34V3d3d0d7eHqecckq8+tWv3mmgVEsqte940EEHxeWXXx6f/OQn4/rrr4/Ozs7Yf//948ILL4xXv/rVk/PFVbHJ+jsWMfb/L35fZkhlEAAAAAAAAFOj4jODAAAAAAAAmDrCIAAAAAAAgAITBgEAAAAAABSYMAgAAAAAAKDAhEEAAAAAAAAFJgwCAAAAAAAoMGEQAAAAAABAgQmDAAAAAAAACkwYBAAAAAAAUGDCIAAAAAAAgAITBgEAAAAAABSYMAgAAAAAAKDAhEEAAAAAAAAF9v8DbXRvULKsxesAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1656x552 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "az.plot_density(\n",
    "    trace1,\n",
    "    group=\"sample_stats\",\n",
    "    var_names=\"accept\",\n",
    "    point_estimate=\"mean\",\n",
    ");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-09T19:30:24.497625Z",
     "iopub.status.busy": "2022-01-09T19:30:24.466625Z",
     "iopub.status.idle": "2022-01-09T19:30:24.706631Z",
     "shell.execute_reply": "2022-01-09T19:30:24.705632Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1656x552 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "az.plot_density(\n",
    "    trace2,\n",
    "    group=\"sample_stats\",\n",
    "    var_names=\"accept\",\n",
    "    point_estimate=\"mean\",\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Issues with mixing discrete and continuous sampling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A recurrent issue/concern is the validity of mixing discrete and continuous sampling, especially mixing other samplers with NUTS. While in the book [Bayesian Data Analysis 3rd edition](http://www.stat.columbia.edu/~gelman/book/) Chapter 12.4, there is a small paragraph on \"Combining Hamiltonian Monte Carlo with Gibbs sampling\", which suggests that this could be a valid way to do, the Stan developers are always skeptical about how practical it is. (Here are more discussions about this issue [1](http://discourse.mc-stan.org/t/mcmc-sampling-does-not-work-when-execute/1918/47), [2](http://discourse.mc-stan.org/t/constraining-latent-factor-model-baysian-probabalisic-matrix-factorization-to-remove-multimodality/2152/21)). \n",
    "\n",
    "The concern with mixing discrete and continuous sampling is that the change in discrete parameters will affect the continuous distribution's geometry so that the adaptation (i.e., the tuned mass matrix and step size) may be inappropriate for the Hamiltonian Monte Carlo sampling. HMC/NUTS is hypersensitive to its tuning parameters (mass matrix and step size). Another issue is that we also don't know how many iterations we have to run to get a decent sample when the discrete parameters change. Though it hasn't been fully evaluated, it seems that if the discrete parameter is in low dimensions (e.g., 2-class mixture models, outlier detection with explicit discrete labeling), the mixing of discrete sampling with HMC/NUTS works OK. However, it is much less efficient than marginalizing out the discrete parameters. And sometimes it can be observed that the Markov chains get stuck quite often. In order to evaluate this more properly, one can use a simulation-based method to look at the posterior coverage and establish the computational correctness, as explained in [Cook, Gelman, and Rubin 2006](https://amstat.tandfonline.com/doi/abs/10.1198/106186006x136976)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Updated by: Meenal Jhajharia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-09T19:30:24.714631Z",
     "iopub.status.busy": "2022-01-09T19:30:24.712630Z",
     "iopub.status.idle": "2022-01-09T19:30:24.766626Z",
     "shell.execute_reply": "2022-01-09T19:30:24.767626Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last updated: Sun Jan 09 2022\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.8.10\n",
      "IPython version      : 7.30.1\n",
      "\n",
      "pymc  : 4.0.0b1\n",
      "pytensor: 2.3.2\n",
      "arviz : 0.11.4\n",
      "xarray: 0.18.2\n",
      "numpy : 1.21.1\n",
      "\n",
      "Watermark: 2.3.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -n -u -v -iv -w"
   ]
  }
 ],
 "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.8.10"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}