diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 0000000..c69bf3e --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,30 @@ +name: CI + +on: [push] + +jobs: + build: + runs-on: ${{ matrix.os }} + continue-on-error: ${{ matrix.os == 'windows-latest' }} + strategy: + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: + - "3.10" + - "3.12" + - "3.13" + - "3.13t" + # NOTE: Example for excluding specific python versions for an different OS's. + # exclude: + # - os: windows-latest + # python-version: 3.6 + # - os: macos-latest + # python-version: 3.8 + steps: + - uses: actions/checkout@v4 + - name: Install uv and set the python version + uses: astral-sh/setup-uv@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Run tests + run: uv run pytest -s diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0c1cc23 --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +# Python-generated files +__pycache__/ +*.py[oc] +build/ +dist/ +wheels/ +*.egg-info + +# Virtual environments +.venv + +demos/emcee.ipynb diff --git a/.python-versions b/.python-versions new file mode 100644 index 0000000..c31d378 --- /dev/null +++ b/.python-versions @@ -0,0 +1,3 @@ +3.10 +3.13 +3.13t diff --git a/LICENSE b/LICENSE index 070475d..b94b391 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2025 Los Alamos National Laboratory +Copyright (c) 2024 Los Alamos National Laboratory Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/README.md b/README.md new file mode 100644 index 0000000..84f0ee3 --- /dev/null +++ b/README.md @@ -0,0 +1,181 @@ +# Arianna +A probabilistic programming language for python built on numpy. + +## Installation +**pip** +``` +pip install git+https://github.com/lanl/arianna.git +``` + +**uv** +``` +uv add git+https://github.com/lanl/arianna.git +``` + +## Usage + +**Model Specification (linear regression)** +```python +from typing import Optional + +import numpy as np +from numpy.random import default_rng + +from arianna.distributions import Gamma, Normal +from arianna.ppl.context import Context, Predictive +from arianna.ppl.inference import ( + AIES, + AffineInvariantMCMC, + Chain, + LaplaceApproximation, + ParallelAIES, + RandomWalkMetropolis, +) + +# Type annotation are, of course, optional. Provided only for clarity. +def linear_regression( + ctx: Context, + X: np.ndarray, + y: Optional[np.ndarray]=None, + bias: bool=True +) -> None: + _, p = X.shape + beta = ctx.rv("beta", Normal(np.zeros(p), 10)) + sigma = ctx.rv("sigma", Gamma(1, 1)) + mu = ctx.cached("mu", X @ beta) + if bias: + alpha = ctx.rv("alpha", Normal(0, 10)) + mu += alpha + + ctx.rv("y", Normal(mu, sigma), obs=y) +``` + +**Simulate data from Prior Predictive** +```python +nobs = 100 +rng = np.random.default_rng(0) + +# Generate random predictors (X). +X = rng.normal(0, 1, (nobs, 1)) + +# Simulate from prior predictive using Predictive. +sim_truth = Predictive.run( + linear_regression, # supplied model here. + state=dict(sigma=0.7), + rng=rng, + X=X, + # since y is None, the returned dictionary will contain y sampled from it's + # predictive distributions. + y=None, + # Not return cached values, so the sim_truth will contain only parameters + # and y. + return_cached=False, +) + +# pop y so that sim_truth contains only model parameters. +y = sim_truth.pop("y") + +# Now sim_truth is a dict containing ("beta", "sigma", "alpha"). +``` + +**Affine invariant ensemble sampler** +```python +aies = AIES( + linear_regression, # model function. + nwalkers=10, # number of walkers. + # Whether or not to transform parameters into unconstrained space. + transform=True, # Set to true when possible. + # Random number generator for reproducibility. + rng=default_rng(0), + # Provide data. + X=X, y=y, +) + +# Does 3000 steps, with 10 walkers, after burning for 3000, and thins by 1. At +# the end, 3000 = 3000*10 samples will be aggregated from all 10 walkers. Then, +# by default, these samples are passed into an importance sampler to reweight +# the samples, yielding 3000 samples. +chain = aies.fit(nsteps=3000, burn=3000, thin=1) +``` + +`chain` is an object that contains posterior samples (states). +You can iterate over `chain`. + +```python +for state in chain: + print(state) # state is a e.g., dict(alpha=1.3, beta=2.5, sigma=0.6, mu=some_long_array) + break # just print the first one. +``` + +You can convert `chain` into a large dict with `bundle = chain.bundle`, +which is a `dict[str, ndarray]`. + +You can also get the samples directly with `chain.samples`. + +**Parallel Affine invariant ensemble sampler** +Works only in python 3.13t. But 3.13t does not yet work with `jupyter`. + +```python +from concurrent.futures import ThreadPoolExecutor + +paies = ParallelAIES( + linear_regression, # model function. + ThreadPoolExecutor(4) # use 4 cores. + nwalkers=10, # number of walkers. + # Whether or not to transform parameters into unconstrained space. + transform=True, # Set to true when possible. + # Random number generator for reproducibility. + rng=default_rng(0), + # Provide data. + X=X, y=y, +) + +# Same as non-parallel version, but will be faster in python 3.13t. +# Will be slightly slower than the non-parallel version in GIL enabled python +# builds, i.e. python 3.9, 3.10, 3.11, 3.12, 3.13. +chain = paies.fit(nsteps=3000, burn=3000, thin=1) +``` + +**Laplace Approximation** +```python +la = LaplaceApproximation( + linear_regression, + transform=True, + rng=default_rng(0), + X=X, y=y, +) + +# The MAP estimate and inverse Hessian are computed via L-BFGS optimization. +# Those estimates are used to construct a MvNormal object. 3000 samples are +# drawn from that resulting MvNormal. +chain = la.fit(nsamples=3000) +``` + +**Posterior Predictive** +```python +rng = default_rng +xnew = np.linspace(-3, 3, 50) +Xnew = xnew.reshape(-1, 1) +ynew = Chain( + Predictive.run( + linear_regression, state=state, rng=rng, X=Xnew, y=None + ) + for state in chain +).get("y") +``` + +See [demos](demos/). + +## Threading +As of 8 Jan 2025, `jupyter` does not work with the threaded version of python +3.13 (3.13t). You can install `arianna` with python 3.13 or python 3.13t but +you cannot install `jupyter` also. If you must use `jupyter`, use python 3.12. + +## Developer Notes + +### Updating versions +1. Update version in `pyproject.toml` +2. `uv sync` +3. `git commit -am 'some message'` +4. Update git tag +5. `git push --tags` diff --git a/demos/friedman.ipynb b/demos/friedman.ipynb new file mode 100644 index 0000000..4a8e837 --- /dev/null +++ b/demos/friedman.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from concurrent.futures import ThreadPoolExecutor\n", + "from typing import Optional\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from numpy.random import default_rng\n", + "\n", + "import aria.distributions as dist\n", + "from aria.ppl.context import Context, Predictive\n", + "from aria.ppl.inference import (\n", + " AIES,\n", + " Chain,\n", + " ParallelAIES,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_theta_pairs(df: pd.DataFrame, truth=None, title: Optional[str] = None):\n", + " # Initialize the PairGrid\n", + " g = sns.PairGrid(df, corner=True)\n", + "\n", + " # Map the upper and lower triangles with scatter plots\n", + " g.map_lower(sns.scatterplot)\n", + "\n", + " g.set(xlim=(0, 1), ylim=(0, 1))\n", + "\n", + " # Map the diagonal with histograms or KDE plots\n", + " g.map_diag(sns.histplot)\n", + "\n", + " if truth is not None:\n", + " # Iterate through each axis in the PairGrid\n", + " for i, j in zip(*np.tril_indices_from(g.axes, -1)):\n", + " ax = g.axes[i, j]\n", + " # Add the custom point\n", + " ax.scatter( # type: ignore\n", + " truth[j], truth[i], color=\"orange\", s=100, edgecolor=\"k\"\n", + " )\n", + "\n", + " if title is not None:\n", + " plt.suptitle(title)\n", + "\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Friedman function (Friedman, 1991, Multivariate Adaptive Regression Splines)\n", + "class Friedman:\n", + " def __init__(self, theta):\n", + " self.theta = theta\n", + "\n", + " def __call__(self, x):\n", + " return (\n", + " 10.0 * np.sin(np.pi * self.theta[0] * x)\n", + " + 20.0 * (self.theta[1] - 0.5) ** 2\n", + " + 10 * self.theta[2]\n", + " + 5.0 * self.theta[3]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Make data.\n", + "rng = np.random.default_rng(1)\n", + "theta_true = rng.uniform(0, 1, 6) # using only first 4 elements.\n", + "f_true = Friedman(theta_true)\n", + "sigma_true = 0.5\n", + "grid_size = 30 # sample size\n", + "x = np.linspace(0, 1, grid_size)\n", + "y = rng.normal(f_true(x), sigma_true)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def model(ctx: Context, x, y):\n", + " theta = ctx.rv(\"theta\", dist.Uniform(np.zeros(6), 1))\n", + " sigma = ctx.rv(\"sigma\", dist.Gamma(1, 0.5))\n", + " f = Friedman(theta)\n", + " fx = ctx.cached(\"fx\", f(x))\n", + " ctx.rv(\"y\", dist.Normal(fx, sigma), obs=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prior_predictive = Chain(\n", + " Predictive.run(model, rng=rng, x=x, y=y) for _ in range(1000)\n", + ")\n", + "fx_prior = prior_predictive.get(\"fx\")\n", + "plt.scatter(x, y, label=\"data\", c=\"k\")\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.fill_between(\n", + " x,\n", + " np.quantile(fx_prior, 0.05, 0),\n", + " np.quantile(fx_prior, 0.95, 0),\n", + " color=\"red\",\n", + " alpha=0.3,\n", + " label=\"Prior predictive (fx)\",\n", + ")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 11000/11000 [00:09<00:00, 1188.68it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "array([0.2089, 0.1847, 0.1787, 0.2009, 0.1857, 0.1912, 0.2072, 0.1979,\n", + " 0.2217, 0.1993])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parallel = False\n", + "\n", + "if parallel:\n", + " # This will run in a script, but will not work in Jupyter notebook in\n", + " # 3.13t. You will not see speed ups unless you are using 3.13t.\n", + " aies = ParallelAIES(\n", + " model,\n", + " y=y,\n", + " x=x,\n", + " nwalkers=10,\n", + " rng=default_rng(1),\n", + " transform=True,\n", + " executor=ThreadPoolExecutor(),\n", + " )\n", + "else:\n", + " aies = AIES(\n", + " model, y=y, x=x, nwalkers=10, rng=default_rng(1), transform=True\n", + " )\n", + "\n", + "# The default behavior is to reweight samples from the ensembles using\n", + "# importance sampling.\n", + "samples = aies.fit(nsteps=1000, burn=1000, thin=10)\n", + "aies.accept_rate" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot logprob history.\n", + "plt.plot(aies.resampled_logprob_history)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqWFJREFUeJztnQecFEXWwN9sYsk5SlZJEkSQIIIBFHP2zCjmHDCc3p2oGDCd6QyYELP4GTCDioKiZBBQQImSc1gWWDb193u1zGx3T1d3VXd1mJn397eyO9NdXV1dXfXqpYppmqYBQRAEQRBEmpAVdgUIgiAIgiBUQsINQRAEQRBpBQk3BEEQBEGkFSTcEARBEASRVpBwQxAEQRBEWkHCDUEQBEEQaQUJNwRBEARBpBU5kIGUl5fDunXroGbNmhCLxcKuDkEQBEEQAmBqvl27dkGzZs0gK4uvn8lI4QYFmxYtWoRdDYIgCIIgXLB69Wpo3rw59/uMFG5QYxNvnFq1aoVdHYIgCIIgBCgoKGDKifg8ziMjhZu4KQoFGxJuCIIgCCK1cHIpIYdigiAIgiDSChJuCIIgCIJIK0i4IQiCIAgirchInxuCiAplZWVQUlISdjUIwpHc3FzIzs4OuxoEIQQJNwQRUq6GDRs2wI4dO8KuCkEIU6dOHWjSpAnlByMiDwk3BBECccGmUaNGUK1aNZosiMgL43v27IFNmzaxv5s2bRp2lQjCFhJuCCIEU1RcsKlfv37Y1SEIIapWrcr+RQEH+y6ZqIgoQw7FBBEwcR8b1NgQRCoR77PkJ0ZEHRJuCCIkyBRFpBrUZ4lUgYQbgiAIgiDSChJuCIIgCIJIK0i4IQgibbn//vvh0EMPhUyidevW8Mwzz4RdDYIIFRJuCIKIDJMmTWJ+Hary/9xxxx0wceJEJWURRJCUl2tQVFIWdjVSFhJuCIJIy7wspaWlUKNGDc/h9hQZRITBGS/+Ap3vmwC7iqj/uYGEG4KISpK04tJQfvDaohx99NFw4403sp/atWtDgwYN4N577zWUsX37dhgyZAjUrVuXhQ6feOKJsGTJksT3f//9N5x66qns++rVq8MhhxwCX3/9NaxcuRKOOeYYdgx+hxqcyy67jP1dXl4OI0eOhDZt2rB8K926dYOPPvooSePzzTffQI8ePaBKlSowZcqUJLMUljNixAho3rw5Owa/Gz9+fOJ7rAOWM3bsWDjqqKMgPz8f3n33XcvnhWW3bNmSldOsWTO4+eabE9+//fbb0LNnT6hZsybL6HvhhRcmEuDp6zthwgTo3r07u6djjz2WHYP30LFjR6hVqxY7D5PnybS/GdSCXXnlldCwYUNWJl5n3rx5ie/xd2x3rCt+j+03a9Ysy7JKy8ql+gvhnvlrdkJpuQbTl28LuyopCSXxI4gIsLekDDoNnxDKtReOGAzV8sSHgjfffBOuuOIKmDFjBpsEr776ajbJX3XVVex7FEhQmPn888/ZZPnPf/4TTjrpJFi4cCHbn+iGG26A4uJi+Omnn5hwg5+jhqVFixbw8ccfw9lnnw1//vknOzeeOA4Fm3feeQdGjRoFBx98MDv34osvZhM2CiFx7r77bnjyySehbdu2TEBCIULPs88+C//973/h5ZdfZkLF6NGj4bTTToM//viDlasvB4/DY1DAMYP1fPrpp+GDDz5gwhlmnNYLDKjtefDBB6F9+/ZMYBk2bBhrFxTi9KCA9PzzzzMh8B//+Af7QWHpvffeg8LCQjjzzDPhf//7H2tD0fY3c+6557J2RKEJBSK894EDB8Jff/0F9erVg4suuojd50svvcQS8/3222/sOZkpK9dg2eZC2LyjCNoK9RSCCA8SbgiCkAKFEJzYUfOAk/eCBQvY3zi5xoWaX375BY444gh2PGo+8Jxx48axiXbVqlVMgOnSpQv7HgWRODjZIpgBF/cxQvbt2wePPPIIfP/999C3b9/EOaiZwYlaL9ygVua4447j1h0FHxQUzj//fPb3Y489Bj/++CNzwH3hhRcSx916661w1llnccvBe0CNzKBBg5gggMJFr169Et9ffvnlid+xrs899xwcfvjhTGBBQS7OQw89BP369WO/o8Byzz33wLJlyxJtcs4557D66YUbu/Y3g22EQhAKWCg0xdsAnwVqvlAwwnu58847oUOHDux7vZCnZ99+/w/S2xCpAAk3BBEBquZmMw1KWNeWoU+fPoZkbihwoJYDt5VYtGgR5OTkQO/evRPfo88LTsL4HYLmm+uuuw6+/fZbJhygoNO1a1fu9ZYuXcpMM2ahBbU/qHHQg6YgHgUFBbBu3bqEMBEH/9ZrXZzKQVBIQ4EIhZATTjiBaabQ1Ib3jsyePZtpZbBcNNOhOQxBQaJTp06JcvT33bhxY6bB0Qt7+BkKJ6Ltb94SAa+PApXZ72jv3r1MiEJQq4RmKzSl4fPAezvwwANt758gog4JNz4zd9V22FiwD07o3CTsqhARBicrGdNQKoMT6eDBg+Grr75iAg6anHByvummmyyPx8kZweMPOOAAw3dxbUQcNHOpwKkc1J6g6Qy1Sd999x1cf/318MQTT8DkyZOZ0IX3hz+otULTGQo1+Dd+p0dv/sE+YDYH4WdxwcgN2Ha4yaXZPIfENWMohKFvD7Yvmq7uu+8+Zm5DkxhBpCqZMZqGyJkv/sr+/e62AXBw45phV4cgPDN9+nTD39OmTWOmDNQaoCMsRinhMXGz1NatW5kgoNdYoHBw7bXXsh80xbz66qtMuMnLy2PfoxYiDp6HQgwKCHoTlCzow4OOv2gy05eDf+tNSqKgHwtqa/AH/YjQrIMmInS4xXt+9NFH2X0iPAdd1e1v5rDDDmP+QKhRwvw3PNq1a8d+brvtNrjgggvgjTfeSBZuaOcFIoUg4SYgVm/fQ8INkRagkIGmjGuuuQbmzJnDHF5R84LgJHv66acz/w/0h8EIHHTORY0Lfh73Z8EIKpxM0WSDPiUoFCGtWrVi2oovv/ySmXpQgMAyMF8NTryoxTjyyCNh586dTChBgeXSSy8Vrjv6lqBmAs0uGCmFkzg60FpFRNkxZswYJoCh+Q1NSejsjHXF+mMdUUjDdkHh7ffff2fOxUG0vxk0M6HZ6owzzoDHH3+ctTma5lBLg8ILOkNjm6BvD0airVmzBmbOnMlMhQSRypBwQxCEFBjmjT4bqO1AbcEtt9zCHFPjoMCAn51yyinMDDNgwAAWJRQ3uaBQgJoOnEhROEGfFXSIRVAIeuCBB5hANHToUHYtFCRQOEDzDpqwli9fzkwqqJX417/+JVV39PdBwej2229nTraoFUIHaJ4TLQ+8PmpmUMjA+0Hn6C+++CLh24J1xrqhIzHWE514MSoriPbXg4Iitv2///1v1p6bN29mjtD4TNCfB89HLROWuXHjRhZajo7U+AwIIpWJaRmYtAAdCzEkEgc5HFz9pPXdX7F/X7+0Jwzs2NjXaxGpQVFREaxYsYKtlK3CjKMM5llBjQel98+89secSEvWbYNN69ZA/8M6pVzfTTXic8drQ3rCoE40d8jO35TEjyAIgpAiA9fERIpBwg1BEEQAwgAmwUsXSLYhog753BAEIYxVSDHhzJrte2H7nmI4uFENqOoh5D8q7U+yTXDoUhoREpDmhiAIwmdQsEE27zLmuUlVyCxFRB0SbgiCIAhH9AoEEm2IqEPCDUEQBEEQaQUJNwRBEIGRHjoPskoRUYeEG4IgCEISkm6IDBduXnjhBbanCSZ8wlTl5h1uzezYsYNlL8XN3nA/GUwXjhk2vZRJEERqgVFBmF0Xx4P0Ij1CX0hzQ2S0cDN27FiWnhz3csE9ULp168Z2xsW051ZgqvbjjjsOVq5cCR999BHbbA831NPvBCxbJkEQakBhw+4Hd5d2m3UX95vKDEgqIIiUF26eeuoptoEe7mmCe7iMGjWKbTI3evRoy+Px823btsG4ceOgX79+TDuDu/eiAOO2TIIg1LB+/frED6b/x9Tn+s9wc0t9qDDuDk6kJ6S5ITJWuEEtzOzZs9mutImLZWWxv6dOnWp5Dm5ghzvYolkKN3Xr3LkzPPLII2xjOrdlIvv27WP7Ueh/goYGAyLVwQ0X4z+4twtqa+J/L168mO3e/c0330CPHj2YSXnKlClw2WWXsR2p9aCWBrU1CH4/efJkePbZZxMaINTcxsH3vWfPnmwBc8QRRzBtLhE+GmmgiEzNULxlyxYmlKCQogf/xoHQCtzt94cffoCLLrqI+dksXboUrr/+eigpKWFmKDdlIriTMO1yS0QZ1HTs2bMnlGuj4IBChQpwN2/cAbtt27ZQt25dx+NRqPnrr7/YQmbEiBHsM9z9Oy7g4G7W//3vf9ln1157LVx++eXwyy+/KKkrIUtlHyHRhog6kdp+oby8HBo1agSvvPIKZGdnsxXg2rVr4YknnmDCjVvuuece5qcTBzU3LVq0UFRrgvAOCjY1atQI5dqFhYVQvXp1JWWhgIJ+c6KgBigvL48JWKgBMvPwww8z03RccDr55JPZrupR3pG6vFyDfaVlkJ+brUxojBok3BAZK9w0aNCACSgbN240fI5/Ww1iCEZI5ebmsvPidOzYETZs2MBMUm7KRFBFjj8EQfgLmpBU0rVrV8P4gGDwQMuWLSGqLNtSCHuLy6BlvWpQp1oepCVkZycyVbjB1RhqXiZOnJiwuaNmBv++8cYbLc9BJ+L33nuPHYe+NAiqrHFQw/IQ2TIJIhVAzQVqUMK6tirMGiB8j837EKGZWRRc7MSJa0HwnY8yKNgg23YXp61wQ6INkdFmKTQFXXrppWw116tXLxZhsXv3bhbphAwZMoSFeaNPDHLdddfB888/D7fccgvcdNNNsGTJEuZQfPPNNwuXSRCpCE7cqkxDUQJ9ZX7//XfDZ7/99ptBaMGFSzxoIJ1IV5MUQoobIqOFm/POOw82b94Mw4cPZ6alQw89FMaPH59wCF61alVCQ4OgH8yECRPgtttuY+poFHxQ0PnnP/8pXCZBENHh2GOPZT5zb731FouEfOedd5iw071798QxmPJh+vTpzIkY/Y7q1asXap0JIkqksYyc2g7FaC7imYwwC6kZHACnTZvmukyCIKIDJti899574a677mKOwBjthBrbBQsWJI7B/DiojcW8VXv37oUVK1ZAupLSCg/aFpxIISIVLUUQRGqA+WnwJw7mrTH71sTBNAx2qRhwixVznirU5pjLQy0t7xpEsFCeGyLq0MaZBEEQhJzihmQbIuKQcOMjpWXRjuogCIJwA8k2/kIaSu+QcOMTq7ftgU73TQi7GgRBEMqhuddfqH29Q8KNT7zy03IoLiXNDUEQBEEEDQk3PkEOd4QTpHomUg7WZ6M9uqXDe5X6dxA+JNwQRMDEE9iFtVEmEQzpmJ5EKy2GkjINsnIqt8iJEje8NwcGPjWZ7e1FZDYUCu4TUVg8vDhpKXw0aw18eG1faFCD9taKCrg/Wp06ddgeSap35SaiIQAgZSXlUFSUbfistLjys1QCtSE7dhXC9m1bYOLyQujZLZr38NX89ezfKUu2wMCOqZvYNR20T2FDwk0a8/j4P9m/z/+wFO4/7ZCwq0PoiG/0GhdwiPRh0/a97N9duVlQvKOK4bPCvGwo3pGa+02hD+GXi3fCJ4t2w11nQqRJ9bUCiTbeIeEmAzpracQ3GsxEUFODG8I2atRIaiNJIvpc+UlF5vU+bevDw2d2MHx2VLuGMPzU9pCKLN9aBB8vWhl2NQhCCBJuiEiuEPNysjLGRIU/RPqwdleFv8fOYoD8/HzjZyWxxGepRiyrwrSGkNXEX6h9vZMZM0gIUN90x6jJy6Ddf76Bqcu2hl0VgvBIittGbCbcaMdLkXBAkHBDRIxHv1nM/v3Xp5UbKxJE2pAmky4JD/4SdeExFSDhJgNIxYEovda8RCaS6k6tdhNuCg4pKUUqjtlRg4QbIi0nhrU79lI4JRE62AfX7aiIlGKkicBD7xYRdUi48Ql6973hJe/Laz8vh36P/pAwcRFEGGAPfvq7v+CIR3+o/FBLE5+bFL6PVCOWLhJxwJBwQ0SSLA/v80NfLWL/vvzTcnUVIggXPPfD0rCrQBAZCQk3vkFLGy/QaoUgogtpbvyF2tc7JNwQkSTdnDGJ1OPTuWtg5sptrs9P5z5M0Tz+Qu3rHRJuMoBUfE2C2Gvp+R+WwFPfVmxRQRB6FqzZCbeNnQfnjpoa2DX/2riL5XkqKonmpo/kc0OkEiTcEGnncyPC3uIyePLbv5hPxOZd+/y9GJFyrNq2J3DT6vFP/8Sc4F+atMz1Nb9fuBH6jpwI05ZTEsxUxiw8bttdzBKbUpSaOCTc+IS5D1KnlMNvxU2Z7nmUlNHeW0R0zA3z1+xwXf6Vb82C9TuL4KLXpoNqKM9NeBz9xI9wwavTYPzvG8KuSspAwg0RScihmMhUAV2FSbasXPPZLEXijZ+YW7egqJT9O3HxplDqk4qQcENEknR2xiQyl3QR2km08RcSHr1Dwg0RSXir14XrCmDI6BnM4ZMg0tEsFVXxR19zmnuJqEPCjU9E6eWPUl1E4Q3waHf+6a/NcPZLv3oqn1ZGRHTNUpAC0PvjJ9S63iHhhkipaKmde0vYv8XkBEykLdGUbvQLAlobEFGHhBsiI/PcBJFHh8hs0sW/xoqoyzapLnylev2jAAk3REbmuSGIqBJVuZt8bgKE2tczJNz4BKXPjvaql3xuCN+JqJCSCeNbVAVEIjhIuMkIoj0QWUGDE0FE6/1Jpe0Xwqzf+zNWecoynSQ86p4lDYvikHDjE1F/+ZFF6wvg4a8Wwo49xZBpwk0KPB4pLVS5D0nbCG+47cIquj5NguFxzycL4LHxi2Hllt2hXB8zXE9ctBEynZywK0CEx4nP/sz+3VJYDE+fdyhEiSyfpZtUED5FueG9OTBv9U74fthRUDUvO+zqEGnrtE7RUjIU7qvIKuwGL+172vO/sH8n3n4UHNiwBmQqpLkJiCiPBX+si15CvLSbF3zk6wUbYO2OvTD5L0rNHnVEJi0Vfd9vwSrqPjdRwIuAoqJ1V231vvlrKkPCDeG7liSSdUrDsZlW09Eiem9V5vjcRIGwBcDyDH9IJNz4hJbmA12qE/bAQ2Rm/xCR2VVECtJ4k+KamwwXTFRAwk0G4PSeRNE3IEifmwjevitoOIwWVv0qOLMUZFyemygIBIYszqHWBCL5jIKEhBsikqu8IAWOdBkE0uU+Mp1UELZJ8+nvO6iimPIMHxBIuPEJc7+KcjfLimAv8F1zA+kHTThEJvvcRKFORu2W+woZTnVZjAb+MHrKCnhx0lKIOhQKTkTSodjvGukHngjePpHReW5U+NzQ4iDTzVJ+UFxaDiO+XMh+P6dHc2hUMx+iSgTX7OlBEKvoXUUlSuzMUZzbg/QDisKKTwXpch+EAnzJUKzPcxO9zqalUR3084fbuUTzoUH0pq59JeUQZUi4SVFmrNgGXe7/lmXDTEeH4iAjwaMwKKogXe4jXXD9XkXvdUy5vqalk/+NW7OUFoVWCA8SblKU5yYuYf9+MHO157IiKNv4vit4hr/3hASfzFnDkiSmEn68PlF/ZaIwmRv9ksTqs3BdAbw1dSXbQgXNPue9PBX+O+GvlBmrowr53BCRXCj67zMQbRW7G9LlPqLGsA/nQV52Fvz18Ikps7eU30Sxq0WhSm5MSCc9V7ENTn5uNlTJyYLpK7axn0SZNkVOW76V7WG1u7gM6lbLhbMOa66rS2ZDwo1f+NyzVErwUTRLBRnBFcWBWhTaMDMYisui7V8Q9K7gNHUKaG4kz0UNTqemtaTOOf+VaYa/9cJNuQ8DWyqNlWSWInw3AS3ZuAsufHUazFxZuRoJW3OTDmPzxoIi6PHQdyk58BD+LjZ813y66GtTlmyBf326APYUu99QUjgxJ4RP2DlvtAwfD0i4IXzX3Fzx5iz4ddlWOHfUVIk6+VqldJBt4OXJy2H7npKwq0HwcJuhGKKJMYJHnotfnw7vTV8FL/zoLUdKWbkGT337J/yydAv3GKzfj39ugn9+NN83Ycryuh4GFtVjngaZDQk3GYCTHdjvwXTDzqLo7Woc8YRkbp5rOibxK9xXCs//sASWbS6EKFJUUsYmWzf8uHgT02RgGXoiaCVOwss7s2b7Xs8O3s/9sBQuem26bf8f+sZMGDtrNVsEpIIPHO9wt750mh9mqRQaY0i48YnU6QJBZAPWImcqS0dSVUiz49FvFsGT3/4FA/87GaLG7n2l0Pm+CXDyfodQEdOQ/lUbOmYm02S8PmWF8rr58kq7iATyo5+u3rYn8fvOvc6ay/U7g4t004916egOp6XQPZFw4wMfz14Dn85dC6lCFFeKvmcoVpAkK3JbfKTmbdgya+V2iCqz/t4OpeUaLN6wS/gcq2dk1mRE8HVMQovIgNXtgW/h8fGLI9P//TBLkc+NO0i48YHb/29eSnW0KAo3Qe4KHuVnQ6Quol3YD/OB33luwnxnzPf24qRlEBWMyUG1kLd/0NSXD6kDCTcpikqfFL8jK1yVH0GBK+qk0sCTCYh2YT9Cdn33WfPQ27xWTXbh43vkJU9Q9SFDsdO9+L1o01JoJUjCTWCE1ymct1/w+fou7j3Ijf9S53VNn4GHqMScQieKeadU7VSdVI5K843i7o++OiO/XgRrtlf6+DjhpQo45jmNlfrvf122JbLatShAwg0RyV3B/d9+IfUzFJvrnZp3YU9UJ3oRRKvui+YG0hfZe3Pbha4YMwte/mk5XGyKyrLDB8WNZUkYBn/hq9MD35Vcg9SBhJuAiPL8GcX5w3dtki+DEEHIYxZuVHT9XftK4bPf1irNYO01z43f8LQebseShesL2L8rt4prbvwXWituxi7Hj6+h4BqkDCTcBITqPqFy7o+gbBNJbVLk+1QKDTyZgKhp1SpPDoY4fzp3DQs3d8stH/wGH81ZA34Q5iSXFeU8Eb74uYhfxs5yWF6uwa0fzIXXfl7uy/1huRP+2AAZI9y88MIL0Lp1a8jPz4fevXvDjBkzuMeOGTOGqaH1P3ienssuuyzpmBNOOAFSAZUZM1XO/VERJPQrjSCrFPRAjfe5t7hMfbkk3aQkSSv8GMB178yG28bOg7s+nu+p7Bm6DRjVajuj19eioFUwbsgbwvVtpJvJf22Gcb+tg4e+WqT8uvPX7GDlXvP2bMgI4Wbs2LEwbNgwuO+++2DOnDnQrVs3GDx4MGzatIl7Tq1atWD9+vWJn7///jvpGBRm9Me8//77EHWw0wWVMVNWHRkR2caQ9CrIDMVBqzwwVUDH4eOVZ92NwuBOuPC5MTsUQ4xtV4J8NX89RJFQQ8EF8sEYfeoAFm8ocJ1JWgZfIpQkrqMXlDXTmbsVLKp5Qu2Wwn0QNXwVbp566im46qqrYOjQodCpUycYNWoUVKtWDUaPHs09Bye1Jk2aJH4aN26cdEyVKlUMx9StW9e2Hvv27YOCggLDT5j4mTETV3zHPf0TFJdWjpjO71s0NtnTv5gRkbd84ZM5FQke3/hFfWZaP/hzwy644d05sHSTeLI6QnxySPK5iWjnj0qEoWwk5QczV8MJz/wMI774A6LcRjJRYDwhwy4UPEtBx+KN5VF0/PdNuCkuLobZs2fDoEGDKi+WlcX+njqVv4FiYWEhtGrVClq0aAGnn346/PFHcoecNGkSNGrUCNq3bw/XXXcdbN1ascrhMXLkSKhdu3biB8sOmqDUuN/8vgGWbiqUUkdHxYStH+RFXsQr35zFdht3Y+IJW32M5GZnqc1QDP6AbfzVgvVw/ivTfLpCaqLqtfHD8dRvPG2/4PHavPHKqU5vTk22AqRsFKaA5qY82drp12UhO5OEmy1btkBZWVmS5gX/3rDB2ukIhRXU6nz22WfwzjvvQHl5ORxxxBGwZs0ag0nqrbfegokTJ8Jjjz0GkydPhhNPPJFdi8c999wDO3fuTPysXr0aUp2YQmEqKv3SkKxKoE7fL9rI1PdzVm33dK1Nu8JRqeZ5FG7M+DWWbt1dzP7dUljxb5BEpGu6QvS9MptLonrPfocZp9p45YSqNrIay0UcioNst6j4berJgQjRt29f9hMHBZuOHTvCyy+/DA8++CD77Pzzz09836VLF+jatSsceOCBTJszcOBAy3LRjIU/YRK802rqdUxZzY3VeaLoz8DdhVc+ejKknOYmA3YFzwT8dAXx7c0O0+eGc1dR6P1eXfm8zhN2PjegoDfwtFFZEYy79q1KDRo0gOzsbNi4caPhc/wb/WREyM3Nhe7du8PSpUu5x7Rt25Zdy+6YKKBF+HoRkW0sB/miEmeTUwpq9ZUIN+nSDumL2Ivl5HOzaVcRRAGjP4n7zhaF4WbV1j2++JDpH6Xdomv55kK4/t3Z8PvanVJlVn7m7HNTnuRz43gp57pwPtcvRlXmVoqkcJOXlwc9evRg5qM4aGbCv/XaGTvQ1LRgwQJo2rQp9xg0WaHPjd0xmYiMNkPvDIa5NaYtt/dhCkpz882C9dDh3vHw1tSVwueJEoWsxLk5sZTwuclEguweTlE8vR6uHEPToX28Nq3X7Rfw3R/wxI8w6KmfYFdRicfamMrW3Z3dY730jRnw9YINcMYLv0iV77gQtblmzMdVrF64KYvA2Ir4qkzCMPBXX30V3nzzTVi0aBFz/t29ezeLnkKGDBnC/GHijBgxAr799ltYvnw5Cx2/+OKLWSj4lVdemXA2vvPOO2HatGmwcuVKJiih0/FBBx3EQsyjTNCTqTkU0o54t1y4roDl1gjLcVTThcTiu3L9e3PY78M/s49ycNOyUXj9VPvcEOrQAszVlOxzEwXdhgU2kThBwp2khaMy1fjbYdK6S16fbtQuG9qIX6HV2yoiZkt1leE9dWOIu/Ff24Wept6Xi3ddvVYoiJD70H1uzjvvPNi8eTMMHz6cOREfeuihMH78+IST8apVq1gEVZzt27ez0HE8FsO7UfPz66+/sjByBM1c8+fPZ8LSjh07oFmzZnD88cczf5ywfWqCxkkKN+fOEClLZoM4GTRXmhuJATQE23Y0fG6CuamcrJhhEM4E3C5GtBTti6lETOGzLS3T2N9utBrxZHgfzloNQ/q2rihb972frwyvaLtoqSwFaylelKm+/aIS/ee7Q/GNN97IfqxAJ2A9Tz/9NPvhUbVqVZgwYYLyOqYjTh1s9bY9kQ4FlxlsovIyiaBf1eRkq214v1ohOwOFG7foW0n06aZOnptoR0uJ+gHpu/LgZ36CgR0aweuXHe66PoWcLTJUaetltIG20VKg1ulG395R1NyQXjwg7JIr+YFdB8Pv+j/+Y+Jvv8dS8UFe/hz37WmKNApIQNInV1Se50ZLDcdnGcKa6N22pVM/svq6LEWEm6j4rHmN7jQLQRMXb/JlbJdtIZnbEspQrAX3jIwOxRAJSLhJUWICm+bxKCkz9j7ftzqw+Q79fDDhICbic5tHw51DsbkMCFy4qZKTGq+fVw0TPtdfl26BzT7nE1I5mLuNBnJzVnJ0STSlGy8Ttwifz1sHPyw2Rtf641AsWTHH8vTjlt4s5N+gwu2fNtFSEDPWuSJiTG4LGCv/n7h2N05pRKSb1Bhd0wDVOUic5JFinQBjvrb53PjfQa/FVm7ZDSc99zP84+WpMOipya4FDDenPWjaPC4o05b+uegHBBX4tVLL8Wis/3bhRrjwtekwQKctjJtGh74xA35dtsVjDQFuen8uHPvfyUKpA0QQacqnv//L9jyrd9Tqs6hEl8igusobC4rg5vfnwuVjZgXgcwNK0Y9bdqHYIgi7GTrLNqDZaFfQzFwRMTZZKmJMRMCNSn8m4SaFwAFAxQTmx54jbligy/Gwdsdeg8Qvc59umuSnvzaHLtwoX0GCP+R61Nz8uF/tv9ckeNz+4Tz48c/NcOGr08ErX8xbByu27IZJfxqfq1ucns3OvSUwd9WO5PN0T0HUx+H3tQWwm+O34RXRVxvfv2e/XwJbbTZAVLXZrNW7vWNPiXdnbuHj1L4pxsR54Po+tu8p4eS0cVkXjR8tpdfey2QeF9nTKiKKGxJugsLrRPbZb2uh9yMT4e6PF4BqoqIEd/tS+CHwBWGW8o7ZbwgiaZbiTbDrfNhAVpWQ6lSK2bQrqrnhVe+O/5tne57fnP/KVKaJunUs35ztZ1/T37OTxkPzOA6U+6q5sY4mEuGj2WvgX596G9/t7i0m0cZezHGkuckwvD7vp7+rUIGPnaV+X6ywHBjN1zVqbsTLUfEqBaa5kdqt3Z6gxhCvZilVoF/WgjU7bScxVZEabhyD7T4X2fA2TOJ5V3CvNh52Jg+vxCTeRa8ZcJWbbzkCjTpBW5PIUKwJaeg1BakOeP43aZ+hmEgd/Eoatq+0DB744g/hCcftYICOqq9PWQHb92/w6IYwHIpVD7KaROhqKUfzwMtz4w01/eui16bBqc9PYSvcsDU3XPW8wSzlbiERpiZVdHdn2WaeK7G5raNw48LfhHecCrj18WFMcfKPNAofmvFcFVpygc8pFDzDUP+43Q+BSRK9T73gjV9Wsh9R9LlUZNrrvs//gAe/XAg3fzAX3MIbUK95exacO+pXZasRvc+NV5JDwTUhQbDzfRPglP9NEb5OTkRCwefs93EZO3O1/xo4t87tTiaVaIz7XOzGAp4ZQoQzX/xV+Dk7tZHXZ6zPhK4CXn2UCdoSfji2KUdioNR0xCuCzFJEcJgnQZe7xWIG42Ef/gZ/rNspfLyMxsirxP/zki2KBxANJvyxEWau3A5LN8uFTPLQ32MYY8CPf1Y49y7esCswh2LVZk87B3hVsqPj5C2gPXBLmHlu/NLcOOM9w61oLjH1DsXOdcAoPgxiQG22LJZjk4DmULMZb/XjkFxOMWv9mP5zMktlGF5NEH7mohEt+oZ358Anc9bCyc9N8cXcFebEb/V8/LCfq/TtUT1I+2eWssZtl7Y7T9XA6qiB4Z6nmzRSIRufCbv0BH72NhlnV7F3iH+M6rmXp9HS/37b2N9gyOgZMOKLheAnPEEL0T9atznFRELQSXNDhAav0zsNxYskVvusPMmxPUxbbfzS+NI/N3EJCy02hlWquo471T62zWPjFyfCqq3wLVrKo91S9RRvp7kJzOfGT81NiF43tsINx5lUBTGJhSDf50asVn76uvHy3MQdxt+dvspT+V7Gl5jinbt5WircrysKkHATEMoHg5i6usQnC+cBXfP1Hgyam4BTCsYHhdl/b4envvuLJYWzWwW5RVR1bmbc3LXw0qRlMHTMTO75frWZ6j2wvGIna6laNcoWE383VFxepcJHVlASTSypfizQm6Xsj7USYNnYIWyWUoteW8gTdFTjxucmxtn/yW13MxavM0uR5ibDiMbzVrb3k8pyo6G50ZISWrnVsqBfy2s/L7e9DitT4nbX7XDOCePXmCIy4eGzm79mh2UUVpA+N8rMUg7PWyT9vVvCFCXtE3r6937KaG6svu44fDzMWLlN6FpuJl9c8Exbbh0mz+ty6hyKLUzmEseqzSnm/DlFS2U42AEw3fioyct8v5a5qyVlrhScfWRfVlmfg3B9buw/k6nP0DdmwkNfLYLpFoNh2O+9XxMnmsxOe/4XGP75HxbXVHtVu36lqn3lNTcWoeBWSfx0v1fLy4aoIepfFWoSP4uLY4qFW3X76dkW4aLuaKo+/5VpnOL045b176rhFc1LKJgkgLh12jbcq/UxpLnJMMxe7Og5jxvFPfrNYnXXEOxU5qNEZRCn4t+Z9jfLdCqzVwkvFDxorF7Iz+etTfzu5n3dUFBkex2ZIkWekVElrjEHxivfdN6rRwWv/FShqXrPwqfAi+bGSjCym3+VJfFz+t7iANRcneUQ8iwSmRSmI3KWsM+N+3bWgshzE6BZipvYzuJYN775miLhQ9NHNKmISONEZinMduGJnLArkKlgIjUZzO+EyuFP1cr6P+N+Z/++9vMKuO24do6TmvnrML3s4wOmvs7/1G11ocqfReXKLlkjZxSs4vtnYV+rUSV9XvUgHIqdpNmktgeA816elrR/lq35BaKHuM+N2uvKRCZ6zSujWrPAMzVbmUi97+MXP1+TdvrWdL+rDtcms1QGk+z86Q2ZfWvs1JMVdVHbGeObAEqHgofoZe823b4selu3nObGuS0N+7socBiMKtHQ3CQfYRZsrPq/WbsWNezy3IhqRnwPwxfw+7Ab06xN0B40UYZT9doRUCPcWJQvYhLSbG7JvVlK9zvHBEZmqQwjeZWtvgPwSnRzJRX1kw4FD8herTKviaxAojTPjWBRYadbUX15v31usO8N/+wP6XNkicgC153mRqJMu53GrcpzekdE2truEKvyvTwLnkCh+fguuhHwNAXaFd7eVUazVDQ6Ngk3qYKX0G87/aSPqzCnKptfdMziGRYqBlSx6+gLBaVMXbYVrn17NmzYWeTbM42CtsFu/lUhPMY3kbRD5DJuI678Ekbx/Vq1dY+aPDcS7Xy5gN+XceVvf6zXudOq6l76DX9vKc218MjvJ/G0HQJmKY1fjp9mxbjmPmxIuAmIZOcuP67B6fBJf3tb+YgiO0jfIhrt4AOOERouyowJZDMVnSSsI2+0pO0nxv+xAf758XxQide+wNO0iJgtrU61334hHOHLnXYUAuWkZ3+GAU/8aLuJpajZRKbq81bvkCrPyR9EaPwSqpnumpoGn85dA5/M4W/Kyr0WJ0jASmDy7nNjj2jAQrlF3YaN/Q1O+d/PUGLjEWxcmxnHsjjXvTsHogAJNyHh1c9Fxp9FVCvhpFIVJf7+plL6+TA0Nz8u3gxdH/gWJvxRkb1UFWtNOXFUTqJRCNH3W7hR1W2ddqnn1VRl6Lz+XpZv2c3+/Wr+elcJG/1MrCmTdkHkEdu9r1bv+q6iUrht7DwY9uE822APK8GLV3erKrhyudEkzFKGYzTul1bvySdz18Lvawtg+vJtSp5T2JBwExAqB4ade0ospWvuFVxojZT43Hg4IvhJ1P6CfmzIiFoWHFSveXu243mWE55NlXmCqleBMwrjmd0tBOUrJqKJHffbOodCIHIIaxaU111vltL83RXc4vS9xZUm8X025vFr3kl+V3nJPkUcit2+jpqkT4yIVkkMAakqIqRPfGiK4eX97DbiW7lrcRNlW//N+yydKS7VWGbhnXtLfDV3uC1GZhBcuqkQXtVlSFbpJ1NRVnAaORGzlP7+VKQTkI1Mc4sbn5sFa3ZCnWq50KJeNQ/XVbG3lPv7R83RpoJf4YOr+yauJxMK7vURW52uv6bd8/9u4UaLc63rZm2WMv8dc+yzMrdbbnH9PcWl8H+z1kBVXdJI/WLNfLt+5+IJChJuUsTnJqbIg170ey8DSPxcL1qCoPeWevmnZfCZzUrbzUrHOlw/mPt6e9rfldcM24SqfPsFsIkC8V5+LKA24nUF3vVXb9sDpz4/hf2+8tGTIehQcD1eu/HMldth1spt0Ltt/YrywFuGYhms3mVv4x1fW+KouXF9Tee6lO//FRPFvjW1cjxwXKzZakadf48KZJYKCBFtifdraIKClRaIcOGYxC9CLjl2go1azY27crw0lVKfGwifJM2N4mgpEdOMijaVreui9QUQ5qakBn8OBdcy+ofof3cySwmULWiyVaHx4yYVtKioecGnuq9Z+dxM+nOzlEBm5/PFNYdFYmQwQsJNSAQZUuuo5rXomF6qp0JosRLIflm6BcJCVfZktxvWWSFcI5XCjYuy9IOlGp8YG7MUZ+bDz9Fxe5PFlhjJ5btYrAjelojTfphCf5AZivUTu5OviqxQaJ/Ez2q8c39DRqHPyecGFPncOAtUWqIemuN4pr9/cbcrcY1VGJBwExTmzuT/JbjXcjswy6JyjP507lq46LXpSspylXAtbM2NlzxHCnubm7JkNkVMOlfELKX7nSfcvDdjFXPcHvjUZMdrijwiFRqiSE4IdhmKOY6z7q+lLztcnxu9r53Iq6bfIZznc2PVRm4cii3bWmCsL99fMUtNlek90f9pVyWuWcp03MyV2wxO2mFAwk1YaNHx9+FVZfhnv8MN785xvarxNiEb+faPZEc+12W7uB03ZinL9Psun7t1WWKFeZ4MPJ4f89COVkcnOxQ7T4w/LKroPxid5oSQZsDtcxR4J8JMoRDkruD6+5QTbrw9H6vvzn5pKsig3yGcv9cVCDkUO6EvPn441zxkaEfY/5nmmA9H/7ft5qmCE9e5o6bC1W8Hs2kvD3IoDgizfTlYG6X8tbCOcSe0mzceDJP/2iR87qs/r4Dlm3dDx6a1bI8TXSGoxk3RqrZNCENzoxKvzaDEJ8a0JDOaAjTPAoOgyChcnuEsmwknCqzZvhf+3robWtWvbnucitobNDeCJo77Pvsd3jQ5x1phV4bqvY+4WxJYRUuZBAfZpH5O/cdKu1Zuqbkx/60zSwlcv6J86+vqk4qGCWluUiVaykvkUZKmxmxvrfzG6ph3p/8Nj3y9WOqaExdvghX7k4apIOzJ3U0UjlWdVSbQ1VwcF0YzGs1Scg0Qk3wXVERLudEMyL7PdserfEay782STYVw1BOTYPEGB+dlxY7bIpqbjQVFQoKNE47Ro542w7UX0txES8nUx8pEplmUoBdmsL9baYcc62XS/kQNEm5CIkyfG4EPDGX5FaVhL7D597q4WTUrcygOYcWuNs+Nt/NVCHd2oeAqfKNE7tHrVaI4Geix2oNKxBlaBp7WgvcIi0vFJVfNwzv40FcLufmurK+luc5zIyt8OpqlLLSY5ZqzYGIc31wkV41ghyazVEgTjB9zHNeD3oWDnppkaBBJXJmlFKlc3Psvufff8TwReyxAX3djsjR35dmp8rlmKXeXEr6OrJnZ9p2MBeuLYxk9BP6jvx0Znxu/+WTOWuF8P7YbZwr0XTv/lsqC7BefvLqU7z/I6vnqx3f81eBzY5fnxqDdt/48KpDmJiRkO4PKPCciV9b0qlaX/ValKU0lQTkUK81Q7MUsJXFN3Dzv7Jd+5d6v10FMhZBo51DME8pluqKQ5sbjbdjLNtaV9ctPx+pZW11KdeivQbgxlM3pexLXtGsrkXIWrN3p6lr6oq2ENHM/dJ3ET6QumvFfu2euH+/txm1utFT0ZBsSboLC/OylbfQix0isIJzOM0j24A43abyDwM0ELarJcpqAwnAklblf3Dxv9t/b4TfOTs5Y/TG/rGCRdK5C6hVPikmqeO4FkjvjlsJ9cOsHc+HXZVvkd502HSJrurW7RtAaz1LLNvO/H/N9brz3Yy9mKaRYwnmL50RsdRlzHiGhaCnLa/IWH8ntWO4QLYVn6ce3mM7HCd8PHA8c60jCTeZipz3BjlrqwRNSdkLlOxhXvmiXjp7hWU0so9o188HM1RAl3IRdx0LaWyoJr1oGkyr6/i8Wski6WQKDnmcNmMWN24eCixf9yk/L2eaWF7463YXPjeYplNjNK+WfWUr+MxVzmVFzo94EzEOkdBn/HnNYtd19JOe5ifk4TmlJdYqjn27MZqk4d/zfPPZ+oCaXczWIMiTcRIBfl22FDveOh3d0+wGZEQnPEzZTCBypV8ua+73w++i0/YJgMVLXFGDDTucstW4HO80xWioMzY08Iu1dKJAzJilrqpIVv1yb8z7XP1OrzK52+PkYg1Z4WmYoD+D+eRoPruZG5po2x4r0wRKJxSY/iV8yZmFGdgf639fuhDNf/AVmrdzuHLmlxT+z19xonP6/bFOhbV1UC7uqIeEmIJIevq5nXP/uHKYa/s+439WUbcJrxk/zYCCqkbHbo4R9H4LZaueeEhbqKsu9n/2RZL5wp0UDdT43LrRJ9sclq6btjhE1E+jHVhWO6na7guMeYW9NXSlUzoENK3O5rN2xN5AkfqrO9xtRbY6qa5g12ZbHS5Rt9wxFFEMlZeJXM5t4Er9ZFJEULQVyzF+zE+au2gEbONuIGNsRuPUwt7FRQKv4Q0aBFsW8TSTchISm0Fk13rFEHfF4JjLeasVcqmjiqaj53GzaVQTdRnzr+vzbP5znu6Apls1Vrgy9EGL36PTdkPeM3dRef89qfG5Mwo3p++Gf/ZF8jkU5+kgVvY+FG7OULLZ7H1l9pmksuZ48chlwK+vgIKS7qIndNXimxd37SmHw0z/ByG8WSfV7+34moLmRCTvnaZpUbb8gdd/Jiw9NwCylX3TY+erwo6WiBwk3AWHn9yKiAhWZlDSX0VL4/fjfN8BN788VOh/rgoMOTvY/LuZnLpbNvuk3VrvjyqBiRa9icnd63mZEx0ZDllJOmK4ZfP53fzzf4fqa4mgpc/nuyuFHe/ipuZFfFSMvTV4GD321SHd99+3oNB5YHcM7zgu8Nte/Zx/NXgN/btwFL09eLnV9O+FMpO33yTgUc4Q0Mc2Nfz43mo2QYgwY0UzvJb+PplK0FOW5CQl9J7SOVjAfb/Odw2svohm69p3ZwuWj0PK/H5bCx3PWsJ+Vj54slCY/bLxryASOcXgWKrZfwDKyJQZFvtCrcXPQcDU3pgHt8jdnSl3fkOcG3JFUN4cm/b9Zq+Hbhcl7k5mWG5LP2RuyocqPj/8z6RixfapcVU/A50btbGbU3GiWCz+ZS9q96iLlSPncGDIU66+TfCE3DsRSQp3+/YTkz3iLDIPGJ754stTcqKhlMJBwExKaD5Mu76UtKCqx1yI5hn0mrz7W76z0UeCjblWiYoXj1ZlX5DHJ+i+Jor/7RBGa171vXGyN4GK1ptoslVwl60Kf/X4JrN6+h63+rU/ktIvINT32Jc/CkcfzDWVZTWKCn3m7ru53zueu319b4VGtZs5KMGC/g8jGmaAUq4VEucXNmOts8LmxOMbyWpz7jgok3ASEk9+LE14sPDv2mIUb0wEOdTFPSCp8bu76aB58OIsz6VihYBDwahKRHxRjPpml5Arh+wSYyxXxuZG/AYNDsWQDWCcvNAnnnCKf/v4vW41VsiLevjwVz9FpIYJwhTFDOZqhdZZuKoQhr093VycIB5FtC3iaRS/PR7WArTmZhXQXNOe5EdHkuBW0wKavGfeWMv6N9f1r4y7Ybpo3Ko7VnQfRJmKGg8wAX2q1K69EwZbI7JNiXb4mnzLcQQiSEmwU4VVDJuRz45NZykq6ddOLjL40mpjPDacs0asbB3zvPV/EZ8SOeFQi139ATHcjeVXTWTanY3JBJ/RduXBfKQx6ajKsc5HigIeTz42Klbqx/Z21ezLvr917pnqrAN6E//a0v2Hllt2mBHn+mqWsNDCaRQlmx2PzPRz/9E+OdblP57gfRUGHhJuASF5tqusOiT1EOF1sb0mZbZ4Wp5qYq1o1V8zjI2r7jYj4NvltlgpDc8MjSYEn7XOjSfskyISC7y0uE7L7y75L705flXSe7NYCXh+BymgrTEaoXpDx/93lac54/VuRVUr5TGwXNn7j+3MUpA0QL8BqIVFuqbkx/S1oYtJ/h47eIueEBQk3KYKdxC/Sr+y0N465WUxXqJqX7Vu2VD/x+gLioIu+RnbmLf03Vk2kwucmES2leTRLmT7naW4M54A8Bp8bjoyNWzocMXJiItwZw/Y7Dh8P89bsVK65sTqPZxYROVfqmjYTjlw5lb/v2FPssTD78q2OUyH88FNX6DUd6jU3qs1SuFXJp3MrNNHmy27Yuc8UPm08QPUwau1QrDn63OwrKff0bKO2kEVIuEkRnxv7sjXHMn9ftxNenLSUCTmyk4P5+PzcbEhFvCaQ21VUCn1H/sBWYzycJkYV0VJe8tzYfS6mmbJWwdthtVOxGdzSAc0qD3yxkP399fz1/DoI+tw4wTNLDX1DIALM7TUT58sVEPRaIoiVOC+zL68fyrw7ttoHHybi28bO45SNJh9vZUvdt4UGstzidPMC7fQXfkk6j3cFy0+jJ9uQQ3FQWHR538q2Ij5g/7lhFww7rp2n8qOWnC/onb2/XrCB+53TS65iEJC9Df017fMlyZlmxK+v09w4FCxkOkwSzjUFZpHKvzbtsvZ5Qd+W+at3QK829VwLqQmHYsnzYjamG7uquDUfWytuVPcPa40Gr22lMuZ6zHPjGh8WsW7NcZrLhZ6oWcrwOUQP0tyEhNLJY79GUaTIqcu2StfFaeNNHioTVKkoye8N+RgOl3C9caa+BWSFG97nmnN2U3MBPFOOHfpynQTM+F3amT2TSnCtuZGbrC8bPQMufG06jJq8TIHmxmNWZqXCp9Vn9hdQcXnDJTiaG+lUBRZlJF/Xv3FAVgsulKFY4vpW2yg47/cWfROTG0i4CQhVfgKWZUuUhi+TV7NUGJs/ivLZb2u536nY10hqqwOr7xXUIeFArqmdxM3hoc4rds2FWUroFNtBPzlPk/MxZtA8q8/4K0J8F/Sxs1b7uv2CFebm8LsnW7epf9cwCs0czY2yaCl/2FRQBD8v2SKlTVHtvM7bodwpQ7G4SY/zeQTnBDJLhQB61/ux8hLpYKgBSH7BNOmBIqqWqecmLvHdLGWH0yNQlaFYqk6iQqvFjsJJv7vKc+NscpDpXyL+a06PGrUvTmXYXt+rtkjy/IroNb2QyZ+cpOsk/KF/5haeQ7fBoViVz41PE3G/x35Iipyq6Co2gpaIcCPzfHkSo6C/U8V33uobFUhzExD6DvrFvHWwXTLCwXYla/pXNeaJwmsH91PKt8utE4hwY/Pdii274dWfVyi7huigx/O5SXYotp4wNZ8mMctjRcpL+jv5LCchqrCo1LEMmTrIIn2+qVv73ZVF/XCcsI0s5PQ3XkSdnAAa/AQtspO4m7HPveZGEzzOdD3bumgpI/SQcBMQ5oePAo66smXNUs5qfbuJQnT1LZKMzEyDGnngBTshMAizlF3b/PMj+w0m7TCvbNds38N1fLU42/LTBWt2slwyTrkuDP1FQlDR19f8e1FJGazcuod/kp3PjYCwLSvIympuvDoUy56f1BpKNb8WgoxD+dj/znnpV7bhrh0XvDqNf13O9fgOxdHMUOzUtvZmKefKbBZ+zyV84rTKX5NyoLlonyj66ZBwExIq51mZvCcxBSpoTdAu9Q1n4LOrp5/5c4JwKLa7N33SK+lydQ8JtQ5HPvYjzF21w1OdzntlGlz02jTnVZnA72ZKdVnCrISb539Yaltnu4i8JB8Bq2MkH7Vsz/CuvZQ7PnmvUE1dXUQ/04yJENEHyW7DXWT6im3863ImfaOmMaY+Q3GAaoYKs5T+2vJljPl1pfj1BBcf5bovcaFhKMPOjJZ0vYpPSHOTwfjroS+juUn2uZEdKPzcNJA3qakQeiQ2+nWNnTnnkGa13JerK2ztjr2SdeIzRycglYn43Ag8+oXrClgCvqe/+yv5nP2/L1pf4D5pZZLmRt4sBdxBWsy04PYNiJ8pe765PbzI6SK1D2KyMgpoyQKwlzrZRkuJF8Oph/sSZExAbhA3SwFXuOGZBe20piTcZDBJfitK9cpyZSZrYuzPM6+Y/PS5URk+rmf87+th7MyKtPu+okUv+aFhJWzTvrI+N7zH+PDXC5n/wbP7nbutoqVKFGrRLM1Skp1URvvJVuMezVJek/ipXCxZFWXtc6N4BuNobnih4FKmRh81N/J5puzq4qkqttfSBDU3+0xmKbsqiWhNefVJO+HmhRdegNatW0N+fj707t0bZsyYwT12zJgxbIWu/8HzzI01fPhwaNq0KVStWhUGDRoES5bwI2SigsgzNu8Yi/yydAtc8/YsW7ur95WIpObGoxDiRnOj9w1xyiJsxbXvzIHdgmV4MXHpP9222+g0nputps3kTS5iJ/BCwfV/uFn1W63K9WYrq2PtFHWopo+vNjfsLGJ7pyWVI62lk9OoiDiPWl7F5UrXLhTcriixPCpaSJob6z94CQrV5bkRLoZTtngBeKgWYMOK9os3flnJN0tJ3Z/9exOkf1Ogws3YsWNh2LBhcN9998GcOXOgW7duMHjwYNi0aRP3nFq1asH69esTP3///bfh+8cffxyee+45GDVqFEyfPh2qV6/OyiwqUrcjrh8km3bEhJtLR8+ACX9shK2midKybIGOlMWeuJwmJjlayr8eyzM/fb9oo9D56007I2Nd/fC1KS4rZ+V+vWC9wUykb5p/fboARk+pjI7Ky5HT3Gwt3MeckGdjfhVFbS4alsobJI3HiJkPrCIzSh2EA6c5GQfndTv2Qp+REy13MHYSwpI1IfF/xdr5qrdmQZCY34sJf9g78npFC0TLoL9e5R+/r91puReezGvsZ56bO/+vYqsFUewcijcUqJ237JLz8SiS0NyYv4z/yXtvgohQDSXPzVNPPQVXXXUVDB06lP2NAslXX30Fo0ePhrvvvpv7Ejdp0sTyO2zAZ555Bv7zn//A6aefzj576623oHHjxjBu3Dg4//zzpeq3e/duyM5WbyooL07usEV79xg+L9lXDuXFRoElC7JZnfQUFzn7V+wu3A27c8qhcHeR5bWNdYux44112Wt7XklOGZQXVw42JftiUFJUeU68zk7Xjh+L3vm8Y7VSsXJEKSzczUwUKstEtu3YBd8v3gj/+fR39veiB0/Yfz1jW97/yRw4r3ujij+K+c/H/NyRBz5ZAON+Wwvv/7oE7j2lY+LcPXuMz88JLHv37mzLfqi/duHuwspr7C6E3btz2e/mZx3/fe+e5LIqbnOP4fh9hvOx3Gqwd6/1PZTu27v/HOuy46zauBUmLyzjHlOwq/JerNDXkd3vHmyjKrZ9M876LUWuV6Ql+/ZUPI9C+/szo8VyoLy4Uit5z9hZMOjgOlCjSk7SvejB78zvp/4zZHdhcr8sYu1h7JNWfYfXd+PY3eOePdgXqlb8rutX7/2yBMb/thJ+uXug4d70xzjB6z9YV5lyrPhkhvgu7GVZpYZ3pqQoz/C3avTvZMn+vuZ0rYKCXYZj9lqcE3/G5rEHx9e8nCzYy+kb+B7iRssqsetvBjSf2Ldvn5adna19+umnhs+HDBminXbaaZbnvPHGG+ycli1bas2bN2fH/f7774nvly1bxszdc+fONZw3YMAA7eabb+bWpaioSNu5c2fiZ/Xq1awc+qEf+qEf+qEf+oGU+8G53A7fzFJbtmyBsrIyplXRg39v2GCtUm3fvj3T6nz22WfwzjvvQHl5ORxxxBGwZk3FdvLx82TKREaOHAm1a9dO/LRo0ULBHRIEQRAEEUUitf1C37592U8cFGw6duwIL7/8Mjz44IOuy73nnnuY70+cgoICJuCsW7eO+fioBB0lu9z/reNxdarlwo49yXblO45vB1f0b5v4+9Tnfoalm8XUcJPuOBqOfnJS4u+a+TksKd6KLZXJ0lo3qAbPnd8dTnu+cov7gR0bwcRFfD+o6nnZBmfcZnXyoXeb+vDp3LUGk0zHe8c71hGPRQe27iO+s/y+TYNqhvp6Zf79x8Oe4jLo88hEUMm4G4+At3/9Gz6eY2yDNdv2wHEmH5BRFx/GHJrtiJ9vtu1/OX89+/1fJ3WAR75ezH6/58QOMPKbit9F+Oi6vnBIs9qJ5JF3mZIJxq89a+U2uOT1Cof/d6/sBYe1qpf0TL+9dQAc/0zF/T35j25wx4dG/wN0Deneok4ixBzLHvrGDJi23JjvpH6NXNhamNz/+x1UH1679HD4eM6ahMnPiot6t4C+bRvAje/Ptfz+xzuOgmOenMw9/4JeLeD9GasTf795+eHQq019276pgp6t68LbV/SGFZsL4aTnphi+a1GvKqzeZm2Grl0119IPBdt3+Ge/w//NqlgAmjnv8OZw/2md2e/xZ3lJ35bwr5M6JY7ZuLPIMG7E+9slfVsbPnt/+t8w4svk/bhm/HsgC+2/dPRMQ9/RX9OKly85DAa0qzDZTly4MelZ4r3pr/n4OV2T+i6Pof1awRu/GP014xxxYH341WIDYTNobklKcCdJzSo58O2wAdB35A/s707NasJH1x4BnYZPAD+4a3B7eHzCn+z3/u0awCuX9HQcl684sjW8PsU+l058jPhl6Wa48s3K3EZzhx/HokD/b9ZqGP7ZH0nn/XL3sVCvurfErGZw/m7WrFl4wk2DBg2YP8vGjUZHUPyb51NjJjc3F7p37w5Ll1Yk/Iqfh2VgtJS+zEMPPZRbTpUqVdiPGXRGxh+VlJSVQ1aeMcLLiqy8XMgqTbZFPjVpFdx8QpfE3zVq1oCsnWJRPlWrVzNcOzsvB7LzqkBWXuULmp1XFapWq2447sdlBbZ11nKzIAsqy8jKzYe8/KqJc+JtKHLfeGx2SRn32JwqWK66hDTVqlWH8uxSobrJUJ5VBapWr57UBtX2xZKuNerXtY7Xt+qHdWvXhKy8is0a8/Irn+1jE1dK3c/uspxE+flVjX1Ef+28/KLEd/nVqsM7szYkHZtfrfL8Kro+EAd94rPZMyxKlI3HmI8ry8qBLAtbPD5/PKeqRT31YHvUxHeDcwzW3+78Kqby86tWjAVZxfy+qYKcvP33t0dLus7ZvQ6E5zjJDbOr5EJWWXJ7YVn6vmEmN79a0vuJx+v7W7XS7KTzzcdYtRk7LicLLn9nASxcXzmGrNutQX+BMQGfUfwaVXT9Sn9v+mvqxxwncqrw22Ta6t1iY3R2FmRleRuLsvJy2BgUvx6Ov/q/VZOra6Oc/X3N6VoVY67Y+JRfdY/hWLwX9KmxGlcqjsd+lDz3egEtQiL4ZpbKy8uDHj16wMSJlStmNDPh33rtjNNNLFiwICHItGnThgk4+jJRisOoKdEy/UY4Jb2gR6KMt7n52izCwhQVUrH9nniZVkmdvDrAB5mhGO+11C4rlUsw5DzHIrrNbUTJtOVb4Znv/zI8b3QWVbET+9AxM+GHxRuldtvGX620QyK1MEdOWPWXUo+dCPtJjk1ovWyEXGVyPY+dW/Q6kpdx+1aI5e1JPsjqNKvP8rKzmGAjur8br0BuPV1mKFYR2eXlnUvUw9Ruf6wrYJGWfqG/liZ4joqEkFZF4PgV5rYMroSbadOmwcCBA6F+/fpJeWlQ2IiDpqBXX30V3nzzTVi0aBFcd911zNM5Hj01ZMgQZjKKM2LECPj2229h+fLlLHT84osvZqHgV155Jfsey7/11lvhoYcegs8//5wJPlgGqqjOOOMMiALCifQEy3MKmdVjfvlx7o0pGCWT89x467B259ul3XcD5iNZvN79tgc8du0rtRzErQZEkTHy/FemwTPfL4GPZq+2FG7QtOaFF39c5lgX495S1gc6hUrjO5o0WGrWGk6ncpywSp3gemLSgsnvUlm+xYVs7tleYLCrtOYuiZ9gQ8Qkn4vhGpJTsVyGYjWCiR/ge+4XxhxBmtA5UkKj8MIaYMH9x0Ojmv5pQZWbpebNmwdHH3003HjjjfC///0PVq9eDRdeeCEzH1199dUGH5bzzjsPNm/ezJLuocMvmo7Gjx+fcAhetWoVZFUkXmFs376dhY7jsXXr1mWan19//RU6daq0D991111MQMJr7dixA4488khWpjnZX1gIv1OCx5VIaB3MnTQucBo+czGAi+TokcHufOFVnyB7ikthyGh+4ki37CoqsdbceCx3+ZZK/6oquZXvhpW/hZtnaCdYGpL4ccuxf44VmkHra4skwYsfKtILcrP5azPpjTNN//qN7GrZ7WuhUlgTLUu0r8pu6yGj7VORi0uJgMQ2zjSW8+GsygWMatxUeRcn8al1+dZzgXlcyc/J9nWfQF+Em5tvvhnOOussePLJJ9nfKHhccMEFMHv2bPjHP/6RdDwKQfhjxaRJRie2p59+mv3YgQ2GGh78iSKinUu0D8oM0uaU8zHe3lLSwo3935g9WZXGRfULIZrZWBbcvDLbwizied8tzoDv1bFRzJxk/btMSezxWWS0lmXsTOcJwE4Qlk+RH//Xb7OU8Xp6/JgKRLeTcHMejwe+WAjn9mxh0Dw6CsqcY/RtUiax0FPxFFV0BbNZCtmxh5+QVSWaYP3ReV+4TM7f5mupzm3ju3CDjrtTpkyByZMnJzkbhS2lRQVRk43oqkDGLGX2M7BwuVE0gGqGleThD38veTYf1b1o9z5/hBuuz43HcvXPUP84ZfdKSipXwOxi1NzYa1Zsj0k6R67uK7bshhkr+btJ868k+p2c74BKKtPVy15JfCNRw3cO18H67NUlB7Q7T+Y5rti8G7o0r+147crf1WpuMMtxFMD7mrWyIiggjp9Jew0ZisF/PSRv+4X8nKzUEm5QO4NOwbiNgvnznj17qq5bSiKsuRE1S0k4n939yQILs5TxGPzba6f37lDML0BnpVTC3hJxlasMhftKoVbVigy+8XviacVk2tu4yaRO0FHkxS26mR6vyk7VQHOTWc0tW/Uthfx91PTYC2qSezXFhT+fd4631dzEgjdLXT5mJvz452ah8zTFqxFN4B1xu3Gmfrf7MMF9z659pzJ02m+czMae0Th/mi4W1ibBeqSmEhRszOmP58+fDz/99BPzuyHENTLCmhuJF5rtQaQjZrHBJf7t3WfGo+kFgvO5CUpzU+lD4lVw1K9m9VocRZobi++uGDOzYg8uiz2gzBh2C9f4mhfjOf5gV65Te3HV635HS2nA9iP75ne5vaHcmn2dTE5Wgk38vEl/boLTnp8CizcYo6FEYIsop2cgORGHuU9RqiDyfnohaVdwDVj/uNeU4wZTBISNVA1wV2/cifvOO++ExYsXs32iTjvtNLjhhhugT58+/tUyhdAUHyejuTFjJSfgZze+Z59Qzgmv70yQoeCf/bYO/AAdivVRIfHnJDL+YnJFWVW91+hRu8l+4uJNsGnXPqFVn97tQVxLKd5jZIQLURObFW9N/dtave7z/FlQVALXvzsHnpuYHDFjXoiIfmdrlnJ5P3jeZW/MhPlrdiY2CZX1E3K+trMwrTJ9QCZg9GPS/L+gBjBkf+LPqGlupMxSDRs2hA8//BBuv/126Nq1K7Rs2ZI5C+uz/2Y6qgd8L6sVHBCtZIWVW71lAEYTid1g6wXVpco4y8mapfSaG3T4xVxVIo9V1BHWKGx41JYlfG74vjRCPjcuBky/BAa7NnEZCe77dLB7nzszqWuzlMs70p+3YSd/48UCm0gbpysbNTccs5RuRCDNjQCSfkyyfc9cJvYTXBhZ5T8KG+loqVNOOYX9EByEfWnUOxSLqLJVaEawRp6Ksbkl1Xlu/MLsVxLX3IhMJqL5WfS/e3cotnb8412bdzk31fBrBenFLMUrzO9oqY0FfH8iX2IyPGhuzGOVbFGypkEnSLiR9WPSmwjBNfpumSTccMqNQnxR+OJVmqEiN4LbPDdmeHluPOPVZ8c2iV8E3gpBzY1+rI1nHbV0xNTEBTheeKzXgT1RB5tihHxuOPWzw4cE0Y4DtqwwGFS0lFvs3gu79ynx2C1zDfnrPe30CGSHShJunLEKCogp7Hs8XzUzURjGI7VxZjqg8vXDl9lvH4AwBDi701NFuEGfG307fDhrDXRoUhNa13feq8xee6bXnqhTMW8u3Mc2WLQ1iRn8aZzNUqJaDr+6sO2kLivcJDQ3EBr+5Lnh+xLhJqFO5zl9ZnttpzB0SedX8rlx53MT86i6Ed2yxXCOT24LMpBwoxiVam2vKyvLPDcK+pzm4/ky9bukTyt4e5r1zr96268fe7mgWUofnh13EB13Qz/Hc201N7qqGsxSHgf2bbuLk5xobbdfAIVmKRmHYk1Nlm/ZR54QbiKqu3Hvc2P81xymzD3P4gTZLUBkNDci7S6TxC9TsYpAiyktX0sZzQ2ZpRTz50Z1+xh5XalkcfLceMXP1a2M5kZkDxu/Jqt9peXsx8wjXy1yPDfb1qHYejWr2tzpGLqruTddmfGr6navh2x7JY4OU3PjMs+N22ipfSV8YSHJ/KBp8NR3f/ELk7y2+RoivhukuXHGoO0FNei1MMn9AiILCTcKwZX8ha9OV1ZemQdn4oTmJmlX8FgEzFL882WEryoCuRT8fPmsVrIimXVjLqKl/BZuzNoOnlBomF8Eq+SHgMnyNdmUKy3cCDhchwnvvV26qRA+m7fOlc+Nk+ZGHw1oJcg7IZIdWX89JzwnsswA9P1+9t/bYfbf27wvaB2ipSxPIc1NerFlt1hm1SCcifl7S4FnNI/laIo0NyLCjZ9CgR9qcuOAr84s5Xxd867g3CNdlS2KTL9Smd9FC1CIdCP08r4a9NRk233H7IQ2W58b0Ay5SmRN5LJuHiKHkubGGXObn/3SVM8LWtuzI/xISLhRiF0+CDd4CQNPREuZuubiDd7NZio3h/SkuRFIFOXneCg62Jrv1+4eeWafIMZ1kZW0rJ/EovUFsGRToZL6JdXF5jt5zY3x36jhdnqq1NzIbSqLx+frdqWX3bi1QrMm4x/Cc0xVNx5mApYtFPNWpnG8EvS5iYBDMQk3ClmvWLhR4lBs6mNed5dGKsahWOih4CKaGz9xO9jaCze8TTSDMEs52+tlhawTn/1Z6vhflm6FUsF+bydky2u6om2Wcp1408ZR2tYsxd4vveZGvmWc89xorI//+Ocm2FJovVO2plCTnQlYtbnmceww+NyYzVJRfWEoWkotmwrUCjdeTRF+yc5+9mfVPjd+4nawtU2lD2H63FibxPSoDE/ncc3bYhsN2l1e2iyV0NxEeLR2QSJ/jyYpnLONYL0tikSipT6avQbu+ni+UBmkuXHX5iUKfDe51yOfm8zAbiXkBq8TWoVZSj2eJ1pFY5R+ZZkumpvlmwsTGhvjruDgKzhI6c1sPLmal2RQJbtEtyjQ1PXRxMaiIc6ffkwImss2Mn9TXOZibBMQbr5daL+BqH7ypCR+zvghnMf05SddDyILCTcKUf2gvb7LMZ9GTLxPvxyKZYqtovMJCINSQYlDk7jHP9YVwD2fLEj63Ov2C0IOxQJmsKjkgWEOqzZ1kZ0Io3JfqrHzJbIVbkz5hnyJlhIY4/R18Dujcjrgh/wXi9mYpSC6kHAT4Y7lVQpneW7AH7xUTdU8HfbmbO41N/ZPZeys1RY5b3wWbkwCAddZOkKjmb1WAlIwQ7EPC5GEL5Em1Ubm49353DjUTcMM7M4CUByKlgor7QK//CibcUm4UYhqvwivq3V/7Z5a6C9g+Jobl8KN4HEqMxQ7gYOU/n54Ye7GncohVNyaXCzLSvwb3cE6aM2NHnc+N86Ci2Nr68ogzY0zvryTMfnrqdig2Ssk3ChEtRSrws/Crz7m18Qm81KE7XPjerCNybex376UFWapcketlGE/oJAFAburu07il24+N6Z/9dgJzEk+N5LCTVFpGSxav0tAcwPimhtyKA7HLAWViL4f4Ys2FC0VcZ+baDoUe62bbZ4b8C9aSvU+U6LaFLdCr1FL4r/PjdGhmCPc6D4O20pg1yZu6xbmLfmzcWb8X81TEkRZQf6CV6Y5+ungNRzDxfUCftgdLlMdimP87ReiDGluIu1z4+18zJ4eBfWgmZVbdyspR1Zz89mNzptaBuJzI3hcoBmK9+cccTK5BekH5ITd1WXrhhuLfrdwYxqaPiraYabFtiD2mhvjd7IOxSLHP/ntX7CVk98mUQ+9WYry3Dji9yupmS7AN0tB6JDmJsI+N941NxA58OVQtf+WrM/NAXWrgkpEB1uzgCkqcAa5asXit+4udtzHx6C5CXElHVPsc/PAFwvZv2cf1hzSLRR82eZCuHzMLLk2YtFSld+r1HjG2VK4j/3Yoa/h3FU7lNch3fAjH1bMRZ6bKEDCjUJUP2bPDsU+JsF2O6+p3DVdZFdwt9mPVWpuzKsdNw7Ffq/IrntntmFrDp7mRj+YhW8lsDFLuZyLv5jP34QyFUEt6cnPWWeJlhEOSxRkNndD+H0stQjYnxi4mhsIHxJuFKJaTe85bbbF9guqcFs13MXYDpn6yt5aLCrRUoIV0Rfvd54b855jPE3RT39tSfwe5iaTiN3l3bZXmKY2P5YiyzbvdtVGSdFSIZnrwjZ9php+NFepIXO56XoQXcjnJtJmKVC+caYq3KojVfo0yPoTqdfcqN9+ga8lCXYY4Qk3Y35dmfg97HlHpc+N35qCEacfAlFDKkNxSJobInxhcFdRKXwyZw3bGPqXpVuErhcFX0/S3EQ5Wiqie0t5udeSUnWNhPfXq009mLFim9jxsdTS3ITp3yJyb35rkxwzFNtpbsqjpSno07a+4zFBzwe2SfzQ50b3d1iO1mEL0KmGX4ugYR/Os/w8yo+HNDcKUTX//LlhF3z221o1Sfx8GjDdDnbO6u2Y1P3JrIjVCzf+DviGJH4Bj/IiwlTYobl22kO3g7xftxT+OlbuGXuNllJFlB1Wo0jQraWRz01moGrVN/iZn9i/1wxo66kcH2UbKBTd3NBPsxTEpExNqk10fm2/YLkreMBzi4jmJmx/CPs8LTQpOiGToTisBHrp9Bir52XD7mK1myubCX69oVl+GgGrFGluVKK6Xy1Yu9P73lI+dbKCvSW+CDdSDsUxOT8ayeAqR9zst+M2z42sJsLrvlsi1ws7kmXVtj2R1SpFcbA39yuZTSt523H4CctgDOlDluoByIKgffM07uXC7/Ak3ChEtV9ElPPcFBS51dyobSOZ8UK1k5vogG9+jm58bmQn62uOaguHt64LbvlkzlrHY376azOEBTo5PjHhT+73EZNthAb7oJwwNRGzlKnPhrFpJV4ynTQ3sqkrXBFwe2kQXUi4UYjq999ztJSPmW7cam6coi5kaiuruVEeCi4oqJkFOvFQcPc5ZSpMku7veO2OvY7HzPp7O4SFU/3CDlOPMvGm+XjOGv4xpr/DEG6O/e8k2FfqrxknSFRHa1oRtK5L4/nchK+4IeEmyh3Ls9+Aj3luCor8MUvJIiXcqDZLCWpuzAKdcCi47vE7ZXIljERNthHpe7EAxyncjsGc2yg5WkoLNVrq7617kkKP/aCvQCSbCoJQ3ARtPdQirLsh4SbCA6qKvaX8oqikPBJ5brKywjRLaa4ixNxobqRV2yyDI2QsUdPcROlRYNMs31woNWmF5cOUI/OCR76viPeCa486MLU1NxA+JNyk895S+F8UepmEz41shmJRzY0fgp6o/5Bbgc5qPhEVbvyMlIsCTq9GmDl43BLUu6oJCPrJu4KHJNxkW9fzsiNaK7tGFHtKx6Y14eBGNaTPm/DHRggSLYqNtx8SblI0Q/EpXZsKLt6jNcXpM9x6RcbnJsyMmUlmKeG6WGhuhO83GnZvv3DSJPg96MoKy1HI2Bpnzt/bYdqyrbbH4CaVGwv2hRotxYv6+++53WBI31bKrhFU2oAIdQFl8DRFUbhXEm4ibZbiF3jjsQdB3Wq5GT3BsTw3gj04iGY4oE5VQZ8bMazm7xxhzY2f26ZGfyHhtxklPzdb6niRJxHU00Jfm0/m2kfDLVxfELpDMZJrIdy0rF9NqXNuULcmFywRi6RGyQxpbjKEIKOlRF7uILzzw0RGcxOEXZ2nQnc7MVj63HCukWmCrdPj9Pt5u3m3XrmkB6QqYSXx47W9yrEtigkfYxH0G5MhCgsrEm6ivCu4jeweftcJ/6WQ8bkJYnUm7A/jIs+NvOYmvYUbp4H/me+X+Hp92bbF4/sd1MDhmOg+ML+3GpHxncJ3QGVTBaa5kagzG9dSQLbRKBQ8M1C/caa3gZDtCh6FXuaA3n4uVd2YuA9KEAj7w4D/0VJR9LdSSdjjvhvNQSBJ3NJMc2OVaJBpbhS2ZXCxUnJpK1JBc6ORz01moLozmu3ebvJmRKCPOeK2jsyrJEI9WPSFFhU4rTU3YjdcIdhC2hL2wC/tUCywD1qUn5cXn5s6Dr6BspobfPYq5cQoOhTjodEXbYB8bjKFIH3uRN6TVFkoutUuyWYo9hvhyC0PE3gAaT9SgrC3V5DVwmDXSGnNjYcGz8/JhrtP7ODqXKvL4kdqHYqjN0OnjuYmutBQqZAgEyiZX+7/XdA9LVbvsqubFLs9BT434q9sKpgkU9UJ1E3bOsk2UX5apR6Sb2JTifqKiZilcNJX2bWxK/EiHVUiKQ5HWivi9B5GwSROwo1CguyM5pe7Y9Naycf4MGBGafEZNeFNXHMTC8jnJn0Je1Xr5j1wFIii1JkVam5iip8zTqiqQ8HHDD0coiQQM3/iFBBuogwJNyk64JonSKtJryIcOBb5dOhuqygTLRUEwlUJJFoqWoKfakLY6siAbL/jHR6lxYJ/mhv3N2mVrwg/Uh0KfnDjmhAlmM9NCkg3Gu+LCPRrEm7SRHNjNUj6YZbww+cDJ+J4qnGncFnDebGKZGpnH9Yc0tHnxsrM6bfmpmvz2pAKWJkrgkTV5Kp/nhGYD/zR3MTUjqmHtqij2KEYIgeO3WH7laVq28XJCbsC6USgmpsk4cZCc+PDgFmhuVG7bMaqf3NLfygqLYef/9osff5//9ENjmrfEG5+fy6kRrSU/3tLue2KUdKERTHvivs8NzGbzyM8QygIBffSpczRUpf2bcWyFqtcuAU1bsvluYn2jtuV8Hxuwoc0NymruTGm57bK++BHllo/1OhYZE52FtSokiPpUByLlHo/ptDn5vN56zz53ODA6GYCcBvR0/mAZJ8vPwl7VatMc6MrJ8pypZftLLw4l5rfgXifVqq5UVeU/XUkLhSGz83gQxqnleaGhJuUjZay/7tyUFHsc2Ox14tXXA/qsWh55wu73AgciFooLz43eK6bFnGbFPHLm/rDI2d2gahrbqrkyPXfw1rWUZTnxppUCQ8v8aAp8yK0mc2P8bJUtlvYzulW4HgWtAB/aIu60udoEY7UJOFGIUFqys3bIlqtJP3wj3Eb0mmH8UWQiyiIEqJNIx4K7l5zI3MdVX0myOfh9l3rfICcT9GH1/SFawa0DcjnJmIdWpHmBtvK7WRnvmy8jdQ6FEP0YLcXbMWyYgq3X4DwIeFGIbwVgB+DfpaQz436iJkorTT1NYmCfVqlWSovO4uzK3iWxIo3OLMUEmTPcKu5kb0/1FQ2qFEl6XNV6f+j9D755nPjIfLHLFTFXzG1eW6CGTtkNER4e0FrbmKuhBvafiEj0IJ00hQwS+Exqq/sx2Bs0NvI+NzoDo7C6ktl0+TlZFkKbKKTquZWc+OhrwY5oLnVJLgxu1mdoupZ69s7ChMCjxIvsfdezFJmnxsfxtQOTYL1FxP2qQx4UMty0aYRGHa5kHCjEF5n9GNzR/PqnxctJcMJhzQJxSzldvAzam680f9g8RB0HqJmBZHukJsdszS9+O5z40lzE4t8aLKb+7M6R3Yi4NXWBxe2CDoUqxNu4sK9CuHm65v7w2VHtIaHz+wMkXMojoDTvAhklsoQeJ0xELMUZwCWuXajWsnq96DV6DKl6+/N6yrnPyd38nR+RYUEDxN4KGgO8RIt5TZFfXa6a25c9F/LhYMf0VKQnnluvPjc/LWxkKO5Ac90alYL7j/tEKhvYXb0AxnTeUW0VCpobjSIKiTcBGBT9cMsZR4srJP4ya2mRQZ+P4SbMpf2fFWaAlXaKJVNs3NPCSzesMu95sZl+3jxJQkyQiJY4UbsMzdEIaokiL2llBELvt2ePq9bCJqb4PeWirlpUi26/ZqEG4XwOqPffiq8a+AnMn1MZNWe7UMIln5VKLv/Shy3A0Gr+tXgvav6KBmAhc1SAscUcyYT4b4UhuYGgmNPcZmr82QWGm9cdji3T0qbpQQcL0WLfM5ik1y/KQkpz42fZYlyZvfmPvtkWn8WdIh6FvncyPHCCy9A69atIT8/H3r37g0zZswQOu+DDz5gg8oZZ5xh+Pyyyy7bv2Fi5c8JJ5wAmRctZUrip0B1LjJxoi9IpJwV9+N2IJh85zHQq009UIGo3OelP4gn8XN3HU8+N+Ev1hyR8XE5pkOj/edYCTdq6iPbbd+7sjd0C2GLDE8+N6bAhoP2b7XitqxUhfesLYUKJtz4XiUF0VLWn8fSXbgZO3YsDBs2DO677z6YM2cOdOvWDQYPHgybNm2yPW/lypVwxx13QP/+/S2/R2Fm/fr1iZ/3338fUq7zesVUpOX7IZmhWGRi8+Ne9GGmbn1uvCJS1JC+raBHq7pwWrdmvmtueMhsvxC0WSoVtm5QZZaSXTiICDFCz0vS1BwF4WZDQZGyfcGCvvPjO8ln7eUj7rbAzFIB60Vi5HMjzlNPPQVXXXUVDB06FDp16gSjRo2CatWqwejRo7nnlJWVwUUXXQQPPPAAtG2bnDwLqVKlCjRp0iTxU7eufGZFP+A9aF8CjEyrIStzQkWiP7U+N35ESzllP+3Zyvr56u/NqwZX5L2+ekBb+Pi6I6BGfo7HvaXct6G4z427cCkvijm3tyV6TwP3a1K84EYAszZLQSik4m7vO/aUGEbGsLIdu+GFiw5TVhZXy8FZmJ7a1XoR5RcxF+dwx91YGgs3xcXFMHv2bBg0aFDlxbKy2N9Tp07lnjdixAho1KgRXHHFFdxjJk2axI5p3749XHfddbB161bbuuzbtw8KCgoMP37Ae2f9WNGay7Q2S8l1MpF6ulnZD2jXUFxzY1H8U/841PEaQdin45Mczy9FPIlfJX3aypnERH2e3IaCq0pOJwImKsRw3HaNawod365JTbhtUDtP11QVLaXKjw59vhKIKG4iMGmEFUCABKm1qpqbzTbpDCMPGn7ywOmHQKr63MQiIN34Jtxs2bKFaWEaNzaq9fDvDRs2WJ4zZcoUeP311+HVV1/llosmqbfeegsmTpwIjz32GEyePBlOPPFEdi0eI0eOhNq1ayd+WrRoAcH63PjjUKy/Gsdsq3wF7YfmxinbLK/5DA7FnmsREz4CE+zFaVizMowUm2bKP4+BDk3sJ2t9vQcL5BbSIzrWum0Pb6Hgcudi22E4ruhp2PeqV8mGVDRL2e1of3LXpvDxdX2FjpcNEogKMWVh5ZBS1Kue55wHzXLT4xhUy7PWEPtFzJXPDWUodmTXrl1wySWXMMGmQQN+QrXzzz8fTjvtNOjSpQtzNv7yyy9h5syZTJvD45577oGdO3cmflavXu3LPch4wyMjPEjmZimbF9Hh1MdGXXyY1Krd6kXEzQXP6+leYCxx0NzwJiTDpwGYpeLH4IouTn5u5SuEXzevWw0GdnQyn1ReTHYMKCwqFdfcxKK9/UL8WuLCTRbsdRkllbimojZRNck2rV0VXrjwMOjRqp5Q+8WDKOJceWQbSDW8+O8EOWuquNSPtx8tsMmkP9eWBft0p6Zy2Zqj63Hjo3CDAkp2djZs3LjR8Dn+jX4yZpYtW8YciU899VTIyclhP6ih+fzzz9nv+L0V6JeD11q6dCm3LuijU6tWLcOPH/CkWJ66b0jf1nBAnapKfG64xzi8JZ2a1jYM4v93bV84s/sBUgM9ah94fiisHh5zaIioS0Ud2967qje4JS4qVs3TCTc52Un1dBIp9bcjawbatqdE6Dhsj6DNUrJq7YRwI1jTnOwYFJV6FG5c3J+KUHArLu7T0kVdjO9T0zpVfdNmXNCrJTQWSOwpixfNTZBzvopriWgaVWSXV0EMYvDWFb3gnB4Soe+ZGC2Vl5cHPXr0YOajOOXl5ezvvn2TVbAdOnSABQsWwG+//Zb4QQ3NMcccw37nmZLWrFnDfG6aNm0KYcN7Z/WDD6riT+rSBD64uo/vErqIAJSt8yBFtf/hrevB4+d05R4vunGja82NRY15g7d+ULCSKx87u0vSZ0cc2AC6t6yT9LnYqrni33yD5iY76XunZ6q/H1ntyrbd+8QOZJobiFSGYvPu2vF2EJ2csX/uLfaWNsCN8MZLkClDvH/qFw73nmLMii3SF8xmKfz1p7uOAT+omZ8DNaqoMY3o6+w1rDyVENn/zk+zpwx4Sdwk9slzuwkvuqMcLeWrUQ/DwC+99FLo2bMn9OrVC5555hnYvXs3i55ChgwZAgcccADzicE8OJ07G/f4qFOnYhKKf15YWMiiqM4++2ym/UFtzl133QUHHXQQCzEPG779sbKjNqmVDy9e1EP3nZo8N9YImJl0FYgLC3arUiufDxEhypvPjbH0U7o2hduPb2+YqKza4rzDW8Kj3yyG7QLaDtGJxWyWqqLzv4mX4VRSnk7bI9tuoimB2PYLII8XLYDTqXcObg/HdWoM54yaatSiCL4EuCWFrOYGi9a/lu7axGpl7a6hcB+jAe0awLHtG0MVXT8QxVwV/BtNoW5BYevTuWu51/Il9YOXaKkAdQIqBIyYywz2YQhxMd1Fu7WoDWt37HU8x8OjTG2fm/POOw+efPJJGD58OBx66KFMAzN+/PiEk/GqVatYnhpR0Mw1f/58ptFp164di6hC7dDPP//MTE+R1dxk8SVdty+rqI+I03F6NX38d7sJzo3mxqkO+mgpq+YwmxI6Nq0FbRpUF8wOrbCLx31u8irL1JuoYoI3rP9WdvK458QOvvrceBnQnU5F4aRn63oWZjxxzU2RpM+NSFShbBluiL/36CSKGW9rV8tNOkbsKsb0Dl5rZndreB1Vwo3+/TS875IEOemruJS5vhhwkHwM3yx107EHsX8Paeb/zuVZumqIBp9e+dasyGrYfHfHvvHGG9mPFXZOwMiYMWMMf1etWhUmTJgAUYWrubF5TdyulIXMKALH6aOfKs0qNvXlOffaDpLeUrubL2nlN8FTj4pGd4m1Z8xCc2PlcyOOzCCA/kKt6xuFOvu9peTxMii5zYgtbJZy4XODmskyXd9wc39ezFL9DqrPnMBbeNCumK9rMEt5nEWcxiY/JqlU8bnxCmopDc9Hq9Cy1crPgQJdYICdWWrYce3g4j6t4Ke/NsOdH833tb4xF8JNlIlMtFQ64KY/iKyMrCZz/CwmlII/JuxzI4KVsFCRWMz9sKN3KLYqxVy2VR144yVOiEnleXz59dqrKvpoKQErCzOTuBRusZ1lMhS7uVEZTeL5hxv94GQvFxcSRftOblYWG+xlMBcdlOYG0wWMu6EfvHNFb/aviK+PkDbW1M6+++wpuoC+GBT4VJTzs2JfI1w8dGuh88fzcOs3DzwYXh3S0/BZ3CyVvOkxf4zCYxvXyg/EBydLdw2vl0vrPDeZCM+maud0JdKJLLMPC/ncOKMXFESkdeucDN7q4KSmNl/ScrLRPGpuBCcWcxtYRUvZgcfrNXzmQesom4SHMivpCp8bN2Yp8WMfPbsrvHjRYfD9sAH7zxU7+dGzujCHxUf3O3yLXhLb/aBGNeFciWiO5JQJwqdWluFilLyqfxs4tEWdpNBt76Zmo4Ob1Sm4d5OoEGiX/LLCLAXKefb87nDroIPhwIZiWkhDnXSN1MxlpCkPDDYYd/0RldfyUFYsYId11dx9Ygdf9hEMEhJuFMJzrrKLQBEZ+Ly4jcQUh8byhAW7UpzuUb9xptWx5jpaaWM0j/fHEwR6W2yqqa+iXnMTL8JOqNDnxdGdkuDSI1pxz8XVv0w0k5sBcvc+sTw6cU7q0pQJHOx6guec36sl/HL3sYnzRDUj8edeTefn5ISQYOyAK98ln1auFZobg10q6RgUGlBzIIJd5JJZmB5uiu4yIxo2jhE5tw5qBy3qyZvq/J70/dBUOeZB42jDjX/7T5au0q3qV4dZ/z7OdVlhC2cICTcKkfGGjyPSB8wTmnmC9GKa0JfN8xkyHB/C3lIiTqHmqqPTMc8BWmYA+4cuOWFi+wW9E7ZFtJld8WiusNvN3a6v4GXFzVLu9Hrrdxo3OQxkQBM8L54KX58h2gnzxOGmim7C4920hYhAlORzA96w3bYkZnQoxhQKdolHzfV36quu2lWhM7XjtTzM0HZjlIip1Coqzm8KTQubmJdFNQk3mYHdg3azn1PCV8HxTDlhRWQ65A5YMf92BTc3Ub+DkjNY67U5b1/RC8Ze00dOc8M5TC8bxQ/RZ/G0mmjsrrhzrzEs3Sx72dUXB1vRPC1uTZZFJe6T5LmNrJExSyEy+/2Yy3bnUGw1+dgX5NfYnrSij/kn3FRobpKFd27dYsl7hyW+szzem9DovxbHw7kS7gmq78OcT0oETGnRp63RF8pbtcKXboLdvCLN4Q0U9hOWvCkonjhOE0iO55wtV64T8vZBsbtOzGP0hH5QHdK3VVIYOHJW9+bw/oxV0P/ghuxHlUOxlZNd/RpVWEhn9bwceOb7v3THGo+zoqik3PDgkla7Dlo+0dWu22iHotLywMczUaEo7gOAIeXCZZv6qzuHYulTXM1YYj43ApnJJR6Enb+b+a122s7F/B1q2PbaCMtu2jUWcqI7UezcAmMCpn4RXzEWnKCpSVS54P7BSRrRKLevCCTcBJKh2H41LitQ6BPHOfmyqNzVltWF49nvFCFkR4u6VS2PxU3n0M6vb7/mumP1YL6ZL2/qr9yMpn8++qE9njjNMkeFww3rV3BJKmqb+mI7iE7OeA03As4+D5ob11YpwRPjJsaVW3a7769uJlRX5hPvXHvUgTBqcvK2MyonHbt1BV7GmE3bvixzvZzGHlemuwDnWy+XsnpGGjf608p07nwNHAvKLF5yN+a+PIs5xdv9Q+iQWSrEvaUqvnMu13z+HsFEZijcyPQxoWgpjge9276MOyJj9IQV3942AM7ofoCr5FKqoqUMp3NWT3EWrN3JLT++wSFm6e3QpBb32eY4CTdZ4pOWmwHGi1nK7aQrKoDGd2AX9TlTpblxtx8VeAKTtmHEilW5xi5pJVyrM0vp24u1g+1Czfh3nm6sOLFL08Qmu5Xlx0I3y9leS3Xh3ESjzs/Q8jmDc3l5Hha3URBQvECaG4Vw9w7J8taBzJ2/oEhs88Ti0nKongdKscxz4+ElwB2R9VilytcPMrL5v0QzKvMGMqfcD/pBh5mcOMdhIq7Lj2wDTWvnw77SchalgruHr9q2x3g9BxOmjFnKzQrOzozghFslmcgA3KdtvYST+C2D2sGHs9a4qpObOlqG6vocLfXs+Ydyy1U56dhFSzEfL5PPja1ZKsbXBmCulj8eGGxIgOkucs30d0R3prZ0KObU1CrkWqT/VFzDQnOj67C1q+XC5l2C+9G5qAP/3PAhzU3A0VLmQ4Qcik3HJCZRh/NwElUtffPqe/whyTu9u9G22EUSVXwvN5RZ+dzIYFDLW3yvr0/x/pB2680/YywvB04Y6DN123HtoGvz5A087QQSLENci6DZCtUX9rbekVpUK6hyMNSbLybcWpEzx8zl/So0X4jopn6qtl+wNj06nQOersMTyis0NzFlu47bRkuxC1b+6tT1zPUymzqqV8kxCO9e26iiTv5No7GAfG6ENDcx8Qrqn2m9ankZq7kh4UYh3DwGDk6ibidoTcgsJd5D3a6AcNDChGWX9m3lOd263rQnEvLthHieG87nBs2NfX30mZaTy/FeX5zvRFXlWC+7flfGcST1JNy4HAxzdZNg+yY1OWW7KzzZMVO+HFXaHhni/eC2QcZkfKz6gmU/dEYXFjno3ixlTOJXkZAQhEGfOb99mayK6HJAbelyLa/l4RlaL4SssfS5EbgGbyGEi4WTuzSFk7o0gWZ18iEMoiAYkXATiOYGlDoUj7rYaMqxjZYKoJOdcegB7N+DGltPTDKZLg0taLn6kZNuGtZITizGizxwGkBiDs88LsTJlC8nCEu0I5qlbDoeT+A8oTNfA+eE267mZyZU87yBZsFgfG68Tdzx028ZdDB8asia6yxg6L930mzYm6WM5zs1g1mr+tAZndl2BjwTm115jfb7V1nVyfC3Ra/74OqKNBAq0ad/cK+5sR4fLCM6BboPr/1wUfvCRYfBixf18HUj3KhDwo1CeLnovDoU6yfY14b0hBM6VzjnifjcyOAm8dsdx7dLqJ95t1I1LyfJt4ZfCfu2ka3iP0/swPayee6CSqflgR0bC60sk/LcxOwnh3hYrd1GeF7MaDJzLE40tpobTmcdeVbFlghucDuQenF6dMLcBpgdd6zk5Oen6UNEoNKb7USqotcEOB1up1Q1+w9X+NyItwVGFH52Qz84ff/iJ7l8fzQ3qElWQ2Xhn93YD+pLODBatRMvm5e18OysceS9b055w4LxuQlfMiKH4gBQGQpulVTO1iwl0cdqV80FWUSFDYyKuuE95+P0mhBrnxs5cDJ790rjZHbFkW1YSHmv1vUcX0ZeKLhVfUv3CwxW9eYJJvr269q8tmX0VKVGSE5zY9fveDux18qX7wOezVIBCjf4V29TsjInggpZ1p+jX9DofVdErFIGp3+Hg8vLnfaW0mtu5MxSfvsluS1D/FrGPlq/Rh5s3V0sfa7TWGmd58bdNUQyvgdilgtftiHNTSBmKbtoKYFyDRE7ujOcJvoKB1fnKzx+dlc449BmLOxav0Pugxap1s2laQId2u1WAFblOTpACoAD1Sldm0GjWs4mCqdoKb3mBs2A3FWWwHN476o+Sas4vQNm/Fderh89msMAyfO58YJ7s5TzMOS2D5nbwM2ga7drs18rV6NzsbEPGv3Aks/V9yGneljlSZG5lh2OGY3tEn8KXstchpvNOEWR6YIyCxGrpJRJQpzVNVxuRBwEEZBtSLgJe28pEdWsYcKT6DWimpt/HN4Cnjm/u2GSwR1yL+nbWuqeVagi9U1o1TayoeCi8NrJaQVlVR8ryxJ31wrd5ziJmZ0E9RNbvD3ev6qPLz43uJO1F+wG9B9uP0rY52aAxc7obh+7kl3BXUVYeev7PLOUyFumN2266b+JK5kcilHQjilsN1tfRN2Vmtn4SenLQF+br25OTuTpFruFnJXW+0zd4tDuzs3NUtPCjCa06OU0oF1ggwxeRvPBHnz3VEHCTRB5bmzNUs7lus2yK+tzI4Spwoa8NNwJXLz+BmHJ6jQFmhsrYi41N1ZqfctBR8AsVXGu8W+MQjNfH3dTvuuE9pwa7y8X0JncTrhJ7hv/Ptl+12cn7B5zTRtzl1lz8/yF3RVqbswrYOPf/Q9uAP85uSNMu2cgtww3VjOZncut+r5eyNULKxXaFPtyDJob3cH6cHoxs5R5Y1inO0g+X4XQ+MVNR/KvoSujbcPqia1pVGCunl0ffPGiw2DYcZWRbXa3Zv6qroUvT5LjtOWCKeZoco55Mi3Jn/zkud1g/K392eI4bEi4UQg/jNX6d7sOqndeM6qZ5YSbmItsvTKITDkyE5Nznptg4ZkE7dT6VoOCaD4js3PtVf3bCtfFAPO5cRcl4xb7qEAQFm6s/H7cyrROzV6jSg5c2b8tNLHRDrjZYgPLlcUg2GfxHYSdnr3heL3mxcGsahktlRW+z41dIs4gfTtkuqBMtawCG5IyMVvmzrIur0TRojbm4hzs9/oM7GFCwo1C3r6it7KNM/XOvYZwZIm32RwK7nWfJSdUlG6VoZj3vVIUmKV6tqrLPUdIzRzDfcOyDUnY9CtROyFZD25PcNPAgw3C0OjLesK/T+poMFmqx6af25yVm+PcOubHLpoOIanPJ63G/fG5cSXclHMcinXCHwpATkOAwUfHgw8bSxpp0lzKGKYcd04X1WgLakFUR+gkleeU79Dwfsa8CTdCp8d8XbjEXDSnz1OMFCTcBIAbs5TBbu7yKbVuUM3wgvoi3DiZkeQLdPC58cssZV15p4yq+vqMuqQHf3NRQc1NFd2+SegYaPSfENPg/X7/YLZzur7uAw5uCFcNaCs9AFr5A/CwVcXbfCkSCm5+7KLpEJz27qpXwzq8d9wN/XRlgDQ18r1pbvTvqr4PiCTE1O//ZtTcyL1PeLghUlOxmkS0XUXzhKnW4iSZpWyOxfBzfV1ktJh1BbIIW90bP1pKlXAj36BR2kmchJsAsNv4kTdgZOskGjdmKQy9NueW6d2mMvRZFfr3SMXKyVCepTABgeLky633WcCw84pzxFXIevA0/USP0W5uJpd49IU5u6wekUmyQ5OabG8aUexqZ3f/ItFSboVa83XjexuNurgHDOrYCO48vr2lv4ze18nNpF6zire0CgZHc71wIxAJY4yusu/ATntLGbdfMO3a6RHRdrWbMKOgKUBfpm4sjYPuQ4k+U6uqhUOxwOm8e2/AEdi/vW0Ad9sVVUThecQh4SYA7NWv1t9ZRclUHC92TRRsWtWvbjj+pC5NLZ01vWDISsqpm+Z6gPe+t5QoIs7QVvWxmhwsV1mcxjGG0uOu38aJzBwG7FRf0ezKWG+nMvBZyMgUbrMr+5nnxvzMqu539MVMzK9derilM6d5TyS7zUx909zo6p2rW+igUOrsUGydxE82+jCWdD7/2OuPPtC+UlblC5ub+P57xjxUajG3F893cPipnSq2pgCxupjfBcvtF5Ic4ZOx0hDjtgu3DjRu2RGnXeOa8MiZXdjC1y/CSHjJg4SbALDbDJEXfqtfrXlxBNafiVoAzO+i0jyl2krkKLz4FQrO+dzJFGSlUbDcCM/Fm4YRTcbIF8ldg21Maswfy+F8vDcZZ3Dbcc1Wc+N8L24fu/lZ6HelFjWTuXldqldxEy3FS9wZM2SWdppEeT56ov238txk4T7GiZC564QO4J/mJhomEac+KLr4MH+Hz/rWQQdDE13ereT8TBZjisVnuO2CUdsaUxZ5KER0ZBsSboLAzmem/8EN4ePr+iZ9rhdojCsx970nPph46X8xO82Dh3IT5YUj23AxO1SKrHzdOKBagQKIflUnq8EzHm88gU2SDoXImoLcJmU7bL8jdhBJ/OKaGzuSNDeWEwv4Gy3FuQA6nDs6FOt9bhzuo2W9atxyKrZb0P9tfVz8Y9lHJOqj5XXj4aAwapvEa4Zj/a2D2sE7V/binm+1ABAZA2IWx/gp25DmJsNwmkQa1UwOQ9Wv3PQLSdm+46fDnYgZqeIgifIcvrfLy+EFXt2dIiCEzVIuGh8jmvTPXnbgsNM4iPjcaLLhrzbXs6v7gQ1rwJc3HQlT7zmWXxfXoeAuNDcCwo0dfdrWE7qOjDB536md2LYhhzSr5ThtcrV9phNP6doUHj+nq71ZKmYs11qD4FAhbvneByQHlyKli1LHPhhzp+2rfF78sdpKG+xWkCiXeJneu7I3DNq/F1+q+dzQ3lIB4JiG3OJr/YpdlRnJD6lab0ZSo7mxf/HCTyzuzizl5hGizw1vV2Y3u8kn+dw4FaCpi05zulbnA2o7VEWN5kYkyZs+HN+qDDseOO0QGNK3lSth1k5wH6pLwGdVNPpS/OvTBQ7+esYTn3fYzDZZc2MtjrgdVszt2rdtfZi6fGvSOGC/wPBvNjXfrVMfFNWsxkTM2AJ+aW6nBU3iVTrioAawfmcRfL9oo9DxpLnJMJxcCqwGQjchwNZlW5ilVPY/gQzFKl88/0LBrbFyOHXS3FibpdxpbniJ+0RKs81QbBKcuJobVQ7FHvuG28dunjiqmLQy7jU3MZudtN2uqMWOsypdHwXDE2qlaxUTm7DdamDsHLU1F+XbNfuRBzWAFvWqekpt4NQHvZilkq5nOt3K79LvfhZH5jLREW1IuAkEN9KsvjPL7PJrXw9QjmpRw2l15Je9mPeIDqhTlTlMvrw/h42IsGWZxI9nsbO5ITQdGUwMkuZJK6H60r6t2L9s+4aYgEOx82WE6uTVBOH2uSfvLeVcjypJDsUSphgPUpwqwZ0XYSc7DrGjTedbm1xdVdP2PF5YfHK0lL6+Mdu9jn6+61jopgvxl4+Wsj9eVNgwHxcX8uyEI+vNNcElmn/CDWluMgvHTJ0WnxkcST1FS/HV0irQDza8wVNminR0KPbTG47DOT2aw+BDmgivglT5JZg3PpX2ubHoN/efdgjM/PcgOP3Qyk3+7EPB1URLyd6/PnLEy8Tvps+bNTduIt3cIHqLTrfEC0CQbYoKM5S1BtlNvZKOtxFG9GOGEodiF/1HWkvucswTEZ4tHYoBAtHcZEk82Cj53JBwEwBOD9yq7+izjBrzlUiuvgyTo7syeOWZxwzzpJBK0VJu28TKT8Iq9J83QNhNvhgtpT/P4IfgetCMQcOaVYTKQIHi2qMODMUs9dmN/QzOrq5DwV08VnM/tkvloBJRAc4pSMC80abrjS9jViY3/nOXlR/M9dELBE7bsFiiO/CzG/rBJX1a6cr2H7fdpNIspR/nzcdY+dw4XzAW8AKRNDcZhpNDsNXEagwFd69mjvnuUGzc08jvAT7ovaWcsNo40yr0n1e8rVnKlKHYmL3ZucJeV9pYNYzQ+frm/iCCXT4mWeGxca18+EfPFrrKgCvc9PnkPDfBDNhWfckNog7FTuDhZmdeq+fo3qHYTnMjVj4vGgzNTw+e0dmQwE62rskLOc2XiT2uYbXTgltpbtxHS0FS4j9V90WamwxD3zlExy9eEi89r1zSA+pUy4Wnz+sm1LESk66HDti7TX3D3/r7MUeZWB3jRNSioZwQN0uJN3rnAyp21T2j+wHQqGYV6H9wAzi6fUOopct6K+Rz4/B26yNwrMDBFuvdqVmt0HdvdhstpW/3D69JzidlhX5/r4oyJK4H7lEluHtZDIFAdJQqrae4z417ofmrm4+EZ88/FPq0rRi3mtrs/p5cv5j7JH4SOZ/ij8tOoLOMqBJo9ljMfgH5vwu626YD0NePR9sG1XXXi450Q8JNADhNMlb9QZ9ynbfLb8/W9WDuvcfBmd2bC9luvXQ8jDJ476re0PfA+mxPHqsXRSQSxRHOCHLzsQexif6GYw4CP3DbNOJmKfEy372yD7xx2eFwzYC27JnhbvNjhvYSSjV/xqHNKo9xuKnbj7NO0x5Hdq7Vm0PMeB3y3DsUV/7eS3Bvtc7NavuSlBECyuGkFzJjkpmgzQKg+dbtuhQK4eqesRofmUOa1Tb4l91zYkc4qUsTeGPo4dLlyURLyWAdCm7W3Dhv0eCGU7s1Y5t+2uEkQL4ypKeuThAZSLgJAEfzADj43PA2whOwv4tm+nSice18OOLAisHrpYutI4d4mhsVK/Rhx7eH6f8aCE0kVl4yuG0Z4VBwTttbJXCsXTUXjunQyDJCQleg4c+j2jVk+4Y9clYXYV8R2/JdOPHamaW8mnZUbb9gB+4EPuy4dnBZv9ahqNrLfdbciOzhheHSPIdiJ/5zcidQhXBYvOTiDVM7vHhRDzimfSOpskW0hwYNvc2xSVoZK5+lmPPCwW2/PH5/cAQuFkWwalb95pxetIN+Qkn8UiAUXNShseLlMoVKGuqR/Jkb9IOk3k6swufGbj6NkspTNhTcLpvtHce3g4MaVfgEiBKz2KgR9w0z1CMrWG2JnbDk2SxlURc0x942dp7teRjKLwruBK7fDdyNgOTlPlX53OjvWf/O2GnWeNuNyNwPagDQ7INJ30SwK1rU6dXPESEpiZ9DlUS7iblckWgptw7FVlzYqyUcUCcfujUXC4uPcXzithQWJ30fJZ8bEm4CwLETWnxt3H7BXjtTeR2P9fBIKvvcuE+IZeVQLDMZxuDGYw+Wvm6SucCH5y2rSbATArwKplbtjObYeat3wphfV3LPizuW2u2h5ATW/de7j2Wh+Uc9MWn/Z6Acr1Esb17eC1Zv2wNdmtfmmKWcpV2j6TM5r41TmgMv77r+bzctofqRJGtunK7vrgZW44X5E2uHYleXA3xPj+0gvqWCVV8///AWcO9nf7CtGVRZB1RDwk0UQsEdoqUMuzvbXsfKLqX71Y8B2cYRMw46xoriVwZiJ9w2Tf3qqNotNHwWxgvu1YnZmspn8c0t/WHszNXwzrS/uftSedm9XrwmcuCz0IcEu6WZSQPEm8jM/joyuOn7+nqgadKuD4j43Bi3+Ki4ggye3l/NTc4fsYWfCpyT+Ol+l2i36onNXPVbTogk8YsFsn+Xpllrbv54YDDbzmTVtj0QRcjnJgDcJOHTd2ZRs5RT2n8/tl/Qd/x8C80NhhEPPkR8lRCSbOMajDQ44sD6BgfFIFSzIoOW1/ws+mfRsWktlgCwns12FCJmDyWV0eF0i0GqydHEKJMB14wfe8LGBKPZrLRv2OQiGkK39+DGLBXk8JA8nkokIxX0uZl2z0BrwQVEtl+A0CjXKsyQbDNV3edR0tyQcKOYLvs3AOymVw3HAE7sXOHEdc1RbZPOseoPInluRMrx29nLEC1lobnBMGIZDQKuCMLAbdO0qFcN3ruqj8FB0UtGabVmKW/X0CTbSWTyVFkXlSnxVYD7F3nBD62l0aFYYKVvcooVab2YDwni3BSjQkthKM+mOBT2ZY7noQ+Q4G05wRVuIEw06zkmQhIFmaUU8/qlPZn6/rxeLaDXwxMTK2jcgXft9r3Qsn41oU6qnyhqGEL1+F3aSXhRkaHYjGaT/MwNGGaOYd9Ou0RHmSBWLyJXqFPNftNPBPfM+venC+C587sLTbZ2fUfV7vV+hYJHHT+0lvq+KOJz46i5iQUjoImWYoyWUnJpofI6N6sFi9YXuHrvYwL3bC7Lz3fLzbPQZ/E2bugbnReOhBvFNKqVDzcNNDqIYkfFzmkl2IjsCo6RMCI4uNz4tLcUKNVYYB0x7DtoVL6UgZilBCYdNJMM7dcaDmpUg1sO7pl1fCejU2Acq3kqLK2z20kzSDW513ndKq2ASpxC/819V7N4L5zeEy93YNx+QXQrCg8XVBwtJVoVN+OwPz518lw9oC0s21QIR7VrxLEOQGSIkBIpfXHzwPWSul5zYx8tZW+X9dLx+INNijnJcFA5TgSjuTFPOhbHxGJw36mHwEW97R1qeYOkilX42Yc1h1/uPtZzOTJVGaXLw+SXmtyqyby2Vtx0bd40VJlZSmAAMO9lJtuVVSUi5JViro6fmgK7aCmnnGJu6mVnlrKsn0CZMcXNc9ugdvD6ZYdzNUlRStdBwk1kdwWX19w4b9Dpr0MxEaC2IElzo+6a8bDpoy0Sncle5eDGNaRyzfCQ6Wb6fEtRGmydwIzj3w8bABNvP0pZmcY8NyKaG3uh2cmvz8t4MLBjReDB4a3rchPMaYFqbiT3ltIf61HUFRGOzPfetmF1x2Pc4CR0+Wka9AKZpQJ0MuZh1SH0WxkY9hSyLcfK6Szmq8rQvLrHLRoufHU6ZDJBONX5OYZgCv6vFqyHc3s2T75uSKMXb2Kxfncqo/aCrK0KQV82maPTDeq/lg0FF78fvROye+pWy4XFD57AfPeWbS6Ef4/7HW4dJJ4DSr3Pjckspej6KjQubRpUZ2HYet4c2gv8JsvBPEbRUhnChFsHsCyqA3V7MYlSMz/X8vd9peXcc6xNExBox4tv0ZBqpJpZyozKK2IEB+4GXkvX79zid0tYTcB6zY1fisXDW4vtUxU2ZodimUSfLFrKQZOj2pSJEzb67h3cuCYTsp3Gk1iA0VL6W7ukT+uk/bSEBX/OYXptj11Jw0/pBN8POyrpehi56TcxB7/OKPnckObGR9o3qcl+nLB6KWvqtDXVEkmeAPYUl3LLcdrgL/51LMBQ3EwkEJ8b2QQkyq4LodC6frLKnYd+RVtapraDTrrjaJi+YivzJRrx5ULDd15NEX4/LwxSYP3G5qXVBwW4ebelzlHQmfzUJNqZpTAL9Jx7j4M6VXP9ubbNfeEjQp8X/RzhJ5quXzv7dUZHuiHNTRSw6A96J2K989ae4rJIbb9gldb+1SE9mSlt9GWVu8VGHb2AWadaLrP5X96vjauygkniZ/47mEFFtgt57XIfX9cX7j+1k5T2Uy/c4JYJKmndoDqcd3hLIf+VKBAzpZeQ6ZuioeD6z6Q0N4pXRn6bpU7u2pT922H/ghUTWvqV08qq1At6tWB7d53Vo8JcfK/CjUpFsbrdKIV/6yHNTUTROxHrO4+dcGMp7VvYQ1WsdtC35ruFG+GqAclJCY/r1Bh+G358IMnsVKFvEhy0vr/tKNf1D0ZzY/93VPA68PVoVY/9yKD3LVEt3NgRSS2mrvnRl8Vqc10eVqHgTipCL20g0lfM5RvNUmoxlzf8lENYXzymfUOl5Yo67o48qyuLRouPS2g+blizCmzetQ+CIuakuYnQmE/CTQSw6sjGxH0AvdvUg5krt7GNykKxh5oGFbSF29nDo9TJZYl5rH8QCbfCEmaiukoLyixlRzRlm5jBLCWnuXERCi4j3ajoxD52R3P1quZlwzn7tSZ+YBRurG9MdlyK+bS3lPEalURp2CfhJgJY9YdqecbcNu9f1Yc5E+MLxsPJHppKYbFBY/RN8tZOwUSCyzl6KrtuhLsQOloWl5VDgxqVYcSl5cFpbqKIfrKpEG7EH2CF5kZuAeX3xrd21Vc9vvk1XvLK1TvCpxQx/a/RGSBIuIkAVp3dsJ/UfondTrAR87mp+Pf249vBA18sZDZc8UpCxuB19RElp7qwCbIpLj8y2UeqOEDNTRh2Kafm1ZJ8bmRUN/YRQ07XC4IgzVJ+l9u2YQ247IjWUFdg2xThLhcD3/E73YhbSLhJBQQ7jOiu4PgC4UaPVs7AmYrX7KJBCzfmyJyghIgIjV1C5OvyRWUierOceQdnP/py0PJdummj7z/tEIgaWoo+j8x+8yOCuTu0a1zD3e66DpEMeodijPqQst9G0aHAN7OUt7LC2Bk3uGip6AxedmCEFTq2n37oAYFdM4qviN4sh1nP5RQ3GjRPWgCFe5d2w6LqrpkOGtgT92/pwcv4rALKUExw0XeIj67tC4e2qJMYjPBdrieophTNc0P4O4GHksSPNDcGLuvXhv0ESRSjpRrVzGd9AxP4Vd2fIE8U3CbqgsNbwJpte+CIgxpEUuBV6SuXVLZPtxVkc53cpSk0uiYf2jeWzHydBuMDCTcRo3bV3EQOjQX3D2b/iubUcPS5iYhBFLeWOKBuVbh1UDuICobVh8eyzMLNmd2D0x74Tiw9NT3pSl5OFvzxwGDWJ/H9lxW8cey556SOkRXgfN1bKg26biwWg15tvGXTdrIiiER5hQGZpSKA3qSg70boQOzkRBzUruAqade4Jvxw+9FwWrdmEEmfG4/tlK0r4Oe7joGnzzsUMkVz0625cR+1iHS5QIhihuJ45GU8PP6odhU5WhrXcjZTiAoyqp5x7Wr+ZPuNmgY27ldz07EHQTqgCW4bkXbCzQsvvACtW7eG/Px86N27N8yYMUPovA8++IBNOGeccUaSFDl8+HBo2rQpVK1aFQYNGgRLliyBVEbVO2SdYCnZodgN0Ry2o/k8YlkBqLYlk6sFxQdX94VPrj8i7GoQHEacfgj85+SO8Mn1/RyP9TusW8+FvVvCcTY5vOIk7zoSjX4vA+YHww1Cbz++PaQbsViGCDdjx46FYcOGwX333Qdz5syBbt26weDBg2HTpk22561cuRLuuOMO6N+/f9J3jz/+ODz33HMwatQomD59OlSvXp2VWVRUBOmAl77hpJkJIrlcOqAyWiqo+SEwzY3DhVDTeEizWsFUhpAGN+G9sn9bOKBOVVfnaz71vUfO7CJkNk/KUJyiQ5p5R29I5WWnBpHEV+HmqaeegquuugqGDh0KnTp1YgJJtWrVYPTo0dxzysrK4KKLLoIHHngA2rZtm6S1eeaZZ+A///kPnH766dC1a1d46623YN26dTBu3Dhumfv27YOCggLDTzoS92HRZ9HU7yKu7oVKb7IUmqWi5qPglZikcJiqk48bwnjWfvo4HNiwhq/3GPWukQ7RUkGgRVST5ptwU1xcDLNnz2Zmo8TFsrLY31OnTuWeN2LECGjUqBFcccUVSd+tWLECNmzYYCizdu3azNxlV+bIkSPZcfGfFi0kktcFgKp3CENfZ/57EDxxTtfEZ/tKK/eiyvScH8IozFDslx9GUp4biE7TZOqcEIYce2gLo4+TCj67oR88eW436Htg/cj5FbVpIL47vFcytR97IpYB0VJbtmxhWpjGjY12VPx78eLFludMmTIFXn/9dfjtt98sv0fBJl6Gucz4d1bcc889zDwWBzU3URJwVEq7uJGann0lujwXHnYydpV3J0VRGS2F4bTphGxfjdBY5ztBviLT7hnINkw8qJH6EN9uLeqwnygJAf93bV9YuK4AjjZtWlnm4wuWCn23Q5NaMGXpllD7dZ5uXsH0JVEhMqHgu3btgksuuQReffVVaNCAn1PBDVWqVGE/mYjeLEUEtf1C8E6ZwfncCBxjOD46g106gTtC40/UOKxlHZizagd0bKrW7+rw1vXYjxk/369UMEs99Y9u8PT3S+CSPq1Cq0Pd6nlw+3Ht2OK5umnD5zDxrSYooGRnZ8PGjRsNn+PfTZpUZE3Us2zZMuZIfOqppyY+K9+fXTMnJwf+/PPPxHlYBkZL6cs89FD/w239ws93SG+WIsTwOiHrHbf9zAwKEbV1k0CTvjjJEi9f0hPGzlwF/+gZjGbcz7VDKnTjRrXyYeRZXXy9xqBOjaFe9Tw4rGVd7jE3DTwYooZvwk1eXh706NEDJk6cmAjnRmEF/77xxhuTju/QoQMsWLDA8Bk6DqNG59lnn2VmpNzcXCbgYBlxYQZNTBg1dd1110Gq4uc7VEyam8CfB07uU/55DGt7jE4JgqgOxFGtlx+E7Y8SBdAsfuOxwU10QYarZyo1quTAjH8NTLloW191SOjncumll0LPnj2hV69eLNJp9+7dLHoKGTJkCBxwwAHM4Rfz4HTu3Nlwfp06FXZf/ee33norPPTQQ3DwwQdDmzZt4N5774VmzZol5cNJVVRPBmSWCucZNK+bnpuSimhlUmsIVEgGzLOWoeAhPnE/fdpUaSBRJkh137scD/6aaSncnHfeebB582aWdA8dflHbMn78+IRD8KpVq1gElQx33XUXE5Cuvvpq2LFjBxx55JGsTBSOUhU/1fgk3KS2iUeUwKKlRI5JveYjUjSwIBUcitn4HrF2ywR89/5BE5SVGQqZNGmS7bljxoyx7CgYLo4/hDP7SsjnRpZUnJyD8nORvUwKNqVrMnb6cvmQVXRZP4WtVBwHiEpST9eUhqDa8qBGNZjzaav6avM4FJep0dxk0sBNg5rXPDf6XUipMdMdt09YhVziq1nKxZ3h3l24WengQyqDZlLMVSVtiE7cVgaDk8GEWwcw57hcxbZNfZ4bIo3NUqlX5bQjaiabTMBPh2I379SYoYdDSZnGBBzjeEJ9I2hIuIkI6Ime7cOkSqHg8ki6gWUUlMQvs1G6/UIs6g7Fbs6JQV4O9fooQMN4mnNoi4rcBLnZ9MKJgiuvVCMobRNpiPiQ4kaOHq34eVOi4XOjqLPTOxMKpLlJc4af2gla1KsKp3Vr5qmcTBq4d+wphlSDhI7w0TI0l49bIaD/wQ1h9GU94aCG7reQKPNTuIlYOYQcJNykObWr5iZ2CyfE2L6nBFKNKIWCG46nkT2tUC1LHNvBuE+gLOV+hoIr6rz0DoQDmaWIwIl6JtdU1NwExYNndGYmzjsHt09b52y3ZJJ2Myr4uv2CsnIy5x2IEqS5IYh08LkJaPzs2rwOLBpxgnDGUlq1Rh+ZHHNRE+B8NUupcrmhdyAUSHNDEPupmpvN/s1JgcQUYU4yqZiKnfCPWLqGgisqZ/gpndi/V/Vvo6hEQgTS3BDEfv7v2r4w/LPf4e4TO0KqQTtxh0/Uza0qiNod+hkKnqXonTq/V0s4tkMjtqkoERwk3BDEfjofUBs+ub4fpCJRFW2iWi8/iJrJRpRUTjHna+JEhZ23Ua3U3fswVSH9MkGkIEmLykySIohI0KFJTeZcriJfTbpsv0BEB9LcEEJkgsqdUA9Zy6KPzK7Vek3JVzf3h5Kycsjf76sWBlHbfoGIDiTcEEQaENVVZlTrRbhDM28ZkxWeYIOkiFWKCAEySxFEGkCrzPDJiI0zM+AW49A7ldqQcEMIkQnjdiqTqePwqfu3FWlVv1rYVUnZeX/YcRUZzC/o1SLsqkQK0jqmNmSWIogUJGWETZ/nB3RmnXzn0dA4AtEoKfNMTFx/9IFwfKfGcGDDGmFXJVJk0dI/pSHhhiDSgExWobeqXz3sKqS8Q/HBjcU2r8ykwIJDW9QJuwqEB0i4IQjCNzJY5iJSlO+HDYCZK7fDOT3ITJfKkHBDpLXKPVOIqn9AJmVOzgStRiaMAwc1qsl+iNSGrIpEYAzs0Ij9e3k/2mNFJQ1qVIHL+rUOuxoZTyZM/Blwi0SaQJobQggVC/CXL+kBq7btgbbkuKiUGf8aCFkR3ewzmrUi3JIJAhyRHpDmhgh0N2kSbNQLm1EVbDINmvcJIjqQcEMIQSs2giAIIlUg4YYgUpBUETYzyJ84ZZ5JOjlNx8O1D2tJYduEEfK5IQiCUMCZ3Q8IuwoZx6tDesJHs9fAOT2ah10VImKQcEMQhG9kiubmpzuPgZYR2AIi07RTDWtWgeuOPjDsahARhMxSBEFkXP4dlaA/dyYINkjEZBuC4ELCDUEQBCFE9bzssKtAEEKQWYogCN/IFLNUpnBK12bw9YIN0KdtvbCrQhC2kHBDCKFFzdhOEETg5OVkwWuX9gy7GgThCJmlCIIgCIJIK0i4IQjCNzJp40yCIKIDmaUIIgU5rlNjqFstF3q0It8HgiAIMyTcEEQKUjM/F2b+exBk075SBEEQSZBwQxApvBFp1GnboHrYVSAIIgMh4YYgCOWMu6EfrNm+BzofUDvsqhAEkYGQcEMQhC8bGsY3NSQIggia6Ou1iUhAWW4IgiCIVIGEG4IgCIIg0goSbghbauZXWC57t6GQY4KwIj+X9lsiiKhBwg1hy1c39Yc7B7eHEWd0DrsqBBEpXr+0J7SsVw3evqJX2FUhCMJETMvATYMKCgqgdu3asHPnTqhVq1bY1SEIgiAIQuH8TZobgiAIgiDSChJuCIIgCIJIK0i4IQiCIAgirSDhhiAIgiCItIKEG4IgCIIg0goSbgiCIAiCSCtIuCEIgiAIIq0g4YYgCIIgiLSChBuCIAiCINIKEm4IgiAIgkgrSLghCIIgCCKtIOGGIAiCIIi0goQbgiAIgiDSChJuCIIgCIJIK3IgA9E0LbF1OkEQBEEQqUF83o7P4zwyUrjZtWsX+7dFixZhV4UgCIIgCBfzeO3atbnfxzQn8ScNKS8vh3Xr1kHNmjUhFosplShRYFq9ejXUqlVLWbmEEWrn4KC2DgZq52Cgdk79tkaRBQWbZs2aQVYW37MmIzU32CDNmzf3rXx8kPTi+A+1c3BQWwcDtXMwUDundlvbaWzikEMxQRAEQRBpBQk3BEEQBEGkFSTcKKRKlSpw3333sX8J/6B2Dg5q62Cgdg4GaufMaeuMdCgmCIIgCCJ9Ic0NQRAEQRBpBQk3BEEQBEGkFSTcEARBEASRVpBwQxAEQRBEWkHCjUJeeOEFaN26NeTn50Pv3r1hxowZYVcpZRg5ciQcfvjhLGt0o0aN4IwzzoA///zTcExRURHccMMNUL9+fahRowacffbZsHHjRsMxq1atgpNPPhmqVavGyrnzzjuhtLQ04LtJHR599FGWpfvWW29NfEbtrI61a9fCxRdfzNqyatWq0KVLF5g1a1bie4znGD58ODRt2pR9P2jQIFiyZImhjG3btsFFF13EEqHVqVMHrrjiCigsLAzhbqJJWVkZ3HvvvdCmTRvWhgceeCA8+OCDhr2HqJ3d8dNPP8Gpp57KsgHjODFu3DjD96radf78+dC/f382d2JW48cff9xljY2VIxTwwQcfaHl5edro0aO1P/74Q7vqqqu0OnXqaBs3bgy7ainB4MGDtTfeeEP7/ffftd9++0076aSTtJYtW2qFhYWJY6699lqtRYsW2sSJE7VZs2Zpffr00Y444ojE96WlpVrnzp21QYMGaXPnztW+/vprrUGDBto999wT0l1FmxkzZmitW7fWunbtqt1yyy2Jz6md1bBt2zatVatW2mWXXaZNnz5dW758uTZhwgRt6dKliWMeffRRrXbt2tq4ceO0efPmaaeddprWpk0bbe/evYljTjjhBK1bt27atGnTtJ9//lk76KCDtAsuuCCku4oeDz/8sFa/fn3tyy+/1FasWKH93//9n1ajRg3t2WefTRxD7ewOfLf//e9/a5988glKitqnn35q+F5Fu+7cuVNr3LixdtFFF7Hx//3339eqVq2qvfzyy5oXSLhRRK9evbQbbrgh8XdZWZnWrFkzbeTIkaHWK1XZtGkTe5kmT57M/t6xY4eWm5vLBq44ixYtYsdMnTo18SJmZWVpGzZsSBzz0ksvabVq1dL27dsXwl1El127dmkHH3yw9t1332lHHXVUQrihdlbHP//5T+3II4/kfl9eXq41adJEe+KJJxKfYftXqVKFDfDIwoULWdvPnDkzccw333yjxWIxbe3atT7fQWpw8skna5dffrnhs7POOotNlgi1sxrMwo2qdn3xxRe1unXrGsYOfHfat2/vqb5kllJAcXExzJ49m6nk9PtX4d9Tp04NtW6pys6dO9m/9erVY/9i+5aUlBjauEOHDtCyZctEG+O/qPZv3Lhx4pjBgwezDdz++OOPwO8hyqDZCc1K+vZEqJ3V8fnnn0PPnj3h3HPPZaa77t27w6uvvpr4fsWKFbBhwwZDW+OeOWjS1rc1qvKxnDh4PI4v06dPD/iOoskRRxwBEydOhL/++ov9PW/ePJgyZQqceOKJ7G9qZ39Q1a54zIABAyAvL88wnqBbwvbt213XLyM3zlTNli1bmN1XP9gj+PfixYtDq1cq79qOPiD9+vWDzp07s8/wJcLOjy+KuY3xu/gxVs8g/h1RwQcffABz5syBmTNnJn1H7ayO5cuXw0svvQTDhg2Df/3rX6y9b775Zta+l156aaKtrNpS39YoGOnJyclhQj+1dQV33303E6xRCM/OzmZj8cMPP8z8PBBqZ39Q1a74L/pLmcuIf1e3bl1X9SPhhoikVuH3339nqy9CLatXr4ZbbrkFvvvuO+a8R/grpOOK9ZFHHmF/o+YG+/WoUaOYcEOo4cMPP4R3330X3nvvPTjkkEPgt99+Y4sjdIKlds5cyCylgAYNGrAVgzmiBP9u0qRJaPVKRW688Ub48ssv4ccff4TmzZsnPsd2RPPfjh07uG2M/1o9g/h3RIXZadOmTXDYYYexFRT+TJ48GZ577jn2O66YqJ3VgBEknTp1MnzWsWNHFmmmbyu7cQP/xeelB6PSMAKF2roCjNRD7c3555/PzKWXXHIJ3HbbbSwCE6F29gdV7erXeELCjQJQzdyjRw9m99Wv2vDvvn37hlq3VAH91VCw+fTTT+GHH35IUlNi++bm5hraGG2yOFHE2xj/XbBggeFlQg0FhiCaJ5lMZeDAgayNcHUb/0HtAqrw479TO6sBzarmdAboF9KqVSv2O/ZxHLz1bY3mFfRF0Lc1CpoolMbB9wPHF/RtIAD27NnDfDj04GIT2wihdvYHVe2Kx2DIOfr66ceT9u3buzZJMTy5IxOGUHD0Eh8zZgzzEL/66qtZKLg+ooTgc91117GQwkmTJmnr169P/OzZs8cQoozh4T/88AMLUe7bty/7MYcoH3/88SycfPz48VrDhg0pRNkBfbQUQu2sLtQ+JyeHhSovWbJEe/fdd7Vq1app77zzjiGUFseJzz77TJs/f752+umnW4bSdu/enYWTT5kyhUW5ZXqIsp5LL71UO+CAAxKh4Bi2jKkJ7rrrrsQx1M7uoyox3QP+oLjw1FNPsd///vtvZe2KEVYYCn7JJZewUHCcS/E9oVDwCPG///2PTQqY7wZDwzGunxADXxyrH8x9EwdfmOuvv56FDWLnP/PMM5kApGflypXaiSeeyPIk4AB3++23ayUlJSHcUeoKN9TO6vjiiy+YIIgLnw4dOmivvPKK4XsMp7333nvZ4I7HDBw4UPvzzz8Nx2zdupVNBpi7BcPthw4dyiYdooKCggLWf3Hszc/P19q2bctys+hDi6md3fHjjz9ajssoUKpsV8yRg2kTsAwUVFFo8koM/+de70MQBEEQBBEtyOeGIAiCIIi0goQbgiAIgiDSChJuCIIgCIJIK0i4IQiCIAgirSDhhiAIgiCItIKEG4IgCIIg0goSbgiCIAiCSCtIuCEIgiAIIq0g4YYgCCIAjj76aLZbNUEQ/kPCDUEQBi677DKIxWJw7bXXJn13ww03sO/wGD0bNmyAm266Cdq2bQtVqlSBFi1awKmnnmrYVK9169bs3A8++CCp3EMOOYR9N2bMGMPnc+fOhXPPPZftVp6fnw8HH3wwXHXVVWwDSoIgCB4k3BAEkQQKJyiE7N27N/FZUVERvPfee9CyZUvDsStXrmS7tuNuv0888QTbMXz8+PFwzDHHMGHIXO4bb7xh+GzatGlMOKpevbrh8y+//BL69OkD+/btg3fffRcWLVoE77zzDtSuXRvuvfdeX+6bIIj0gIQbgiCSOOyww5gg8sknnyQ+w99RsOnevbvh2Ouvv55pXWbMmAFnn302tGvXjmlihg0bxgQXPRdddBFMnjwZVq9enfhs9OjR7POcnJzEZ3v27IGhQ4fCSSedBJ9//jkMGjQI2rRpA71794Ynn3wSXn75ZW7dX3zxRabhQU0PanzOOeecxHcodB155JFQp04dqF+/PpxyyimwbNkyg6CG9/Lhhx9C//79oWrVqnD44YczTdHMmTOhZ8+eUKNGDTjxxBNh8+bNifNQk3XGGWfAAw88AA0bNoRatWoxzVdxcTG3nii03XHHHXDAAQcwwQ7vbdKkSQ5PhiAIEUi4IQjCkssvv9ygZUEhBAUOPdu2bWMCA2pozJoXBIUIPShsDB48GN58882EEDN27Fh2LT0TJkyALVu2wF133WVZN3O5cWbNmgU333wzjBgxAv78809WtwEDBiS+3717NxO68Dg0mWVlZcGZZ54J5eXlhnLuu+8++M9//gNz5sxhQteFF17I6vLss8/Czz//DEuXLoXhw4cbzsHyULuEAsr777/PhEEUdnjceOONMHXqVKYhmz9/PjO/nXDCCbBkyRLuOQRBCOJ5X3GCINKKSy+9VDv99NO1TZs2aVWqVNFWrlzJfvLz87XNmzez7/AYZPr06RoOI5988oljua1atdKefvppbdy4cdqBBx6olZeXa2+++abWvXt39n3t2rW1N954g/3+2GOPsXK3bdsmVfePP/5Yq1WrllZQUCB0PN4PXmfBggXs7xUrVrC/X3vttcQx77//Pvts4sSJic9GjhyptW/fPvE3tke9evW03bt3Jz576aWXtBo1amhlZWXs76OOOkq75ZZb2O9///23lp2dra1du9ZQn4EDB2r33HOP1D0TBJEMaW4IgrAEzSsnn3wyc/JFDQ7+3qBBA8MxmobzvhxYTmFhIfz0009MG2TW2rgtFznuuOOgVatWzLH5kksuYb46qB2Kg1qRCy64gH2PpiN0ckZWrVplKKdr164GbRPSpUsXw2ebNm0ynNOtWzeoVq1a4u++ffuy+9Sb4OKgX1JZWRkz4aGZK/6DJju9mYwgCHdUGrkJgiBMoOCB5hPkhRdeSPoefVvQR2Xx4sXCZaKZBwUPNP1Mnz4dPv3006RjcNJHsFwUEkSpWbMmMyWhaejbb79lpqP777+f+cugKQsjuFD4efXVV6FZs2bMHNW5c+ck35jc3NzE73h/Vp+ZTVkyoNCTnZ0Ns2fPZv/qQSGHIAhvkOaGIAgu6AOCE39JSQnzlTFTr1499jkKPujPYmbHjh1coQm1FKeffjrUrVs36fvjjz+eaYkef/xxy/N55caFJ3RAxnPRlwWdhDGSa+vWrcwPB31pBg4cCB07doTt27eDKubNm2eILkNnahRU0DHbDDplo+YGtT8HHXSQ4adJkybK6kQQmQppbgiC4IJaBXSSjf9uBQo2/fr1g169ejFHXjTplJaWwnfffQcvvfRS4nw9KFigw7DejKMHnZNfe+015mR72mmnMSdhnPjxHIxkQjOSVb4cDB9fvnw5cyJGoenrr79mGpb27duzvzFC6pVXXoGmTZuyMu6++25QBQqBV1xxBROeUKBCzRRqvdBp2UozhRFiQ4YMgf/+979M2MHoK3RKxvZD0x1BEO4h4YYgCFvQN8UO9F9BU9DDDz8Mt99+O6xfv57562DuGxRueKCgYQdqdX799VcYOXIki1YqKChgWpBjjz0WHnroIctz0PSEUUpoisK8PGg2w8glDE1HUCBCQQlNUSjwPPfccyxzsApQG4TXQ8EKw7zRtwfrwQP9mPA+sM3Wrl3LNFWY1wfD0wmC8EYMvYo9lkEQBJHRYJ4bNJWNGzcu7KoQBEE+NwRBEARBpBsk3BAEQRAEkVaQWYogCIIgiLSCNDcEQRAEQaQVJNwQBEEQBJFWkHBDEARBEERaQcINQRAEQRBpBQk3BEEQBEGkFSTcEARBEASRVpBwQxAEQRBEWkHCDUEQBEEQkE78P9gVsKlitTRtAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(samples.get(\"sigma\"), label=\"posterior samples\")\n", + "plt.axhline(sigma_true, color=\"black\", label=\"Truth\")\n", + "plt.ylabel(\"$\\sigma$\", rotation=0)\n", + "plt.xlabel(\"MCMC sample\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdEAAAXDCAYAAAA/S3eaAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Ql0VPX9/vFnsidAFgi7hASDsi+CoAJaLRUtLviz/SlqZVFrq2hba4u0CKJWbV1qFa11Qe2/br/WulQoVkUrKK6gLAISWYLsgSxk3+Z/Pl+ccSaZCZAEkpD365ycZO7ce3NnZHKOz3zm+Xq8Xq9XAAAAAAAAAACglojamwAAAAAAAAAAgCFEBwAAAAAAAAAgDEJ0AAAAAAAAAADCIEQHAAAAAAAAACAMQnQAAAAAAAAAAMIgRAcAAAAAAAAAIAxCdAAAAAAAAAAAwiBEBwAAAAAAAAAgDEJ0AAAAAAAAAADCIEQHAABAi/fOO+/I4/HoH//4R1NfSqtzyy23uOceAAAAOFoRogMAAKBZsmD2YL4sQD8c3n//fRcQ5+XlHZbQ2feVkJCgfv36aebMmSooKFBj27Ztm/udn332WaOfGwAAAGgNopr6AgAAAIBQ/t//+39Bt//617/qjTfeqLW9b9++WrNmzWEJ0efMmaPJkycrOTm50c//5z//WW3btlVhYaH+85//6He/+50WLVqk9957r1Enuy1Et8eRnp6uIUOGqLFZ+H/TTTc1+nkBAACA5oIQHQAAAM3SZZddFnT7gw8+cCF6ze3mcIToh9sPfvADpaamup9/8pOf6MILL9Q///lP9zhPPvlkNXdFRUVq06aNoqKi3Fdj8Hq9Ki0tVXx8fKOcDwAAAGgM1LkAAADgqFFdXe0muo855hjFxcXpu9/9rrKysmrt9+GHH+qss85SUlKSq1M57bTT3AS4j9Wf/OpXv3I/Z2Rk+KtXNm3a5LY9+eSTOuOMM9SpUyfFxsa6OhabLG8IO5/ZuHGjP6T+5S9/qR49erjfcfzxx+uee+5xQXMge2Nh9OjRblreJtttv9/85jfuPqu6OfHEE93PU6ZM8T+Op5566qCfC9/zYcd98cUXuuSSS5SSkuJ+Z+B9gSorK3Xbbbfp2GOPddduU/B2TWVlZUH72fZzzjlHr7/+uoYPH+7C87/85S8Neh4BAACAxsYkOgAAAI4ad911lyIiInTjjTcqPz9ff/jDH3TppZe6oNjHKlPOPvtsDRs2TLNnz3b7+0LxxYsXa8SIEfqf//kfffnll3ruuef0xz/+0T8x3rFjR/fdAvP+/fvrvPPOc1PY//rXv3TNNde4EP/aa6+t17V/9dVX7nuHDh1cUG7nfvvtt3XFFVe4GhYLmi3Y37p1q7sms3r1ahdCDxo0SLfeeqsLrO1NA18IblU3tn3WrFn68Y9/rDFjxrjtp5xyykE/F4F++MMfqnfv3rrjjjtqhfmBrrzySj399NNu2t7eCLDn/84773SfGHjppZeC9l23bp0mTpyoq6++WldddZV7EwAAAABoVrwAAABAC3Dttddaahvyvrffftvd17dvX29ZWZl/+5/+9Ce3feXKle52dXW1t3fv3t5x48a5n32Ki4u9GRkZ3u9973v+bXfffbc7duPGjbV+n+1fk52zV69eB3wcs2fPduddt26dd/fu3e78f/nLX7yxsbHezp07e4uKirwvv/yy2+f2228POvYHP/iB1+PxeLOystztP/7xj24/O084H3/8sdvnySefDNp+KM+F75onTpwY9vH4fPbZZ+72lVdeGbTfjTfe6LYvWrTIv61nz55u28KFCw/4vAEAAABNhToXAAAAHDWssiQmJsZ/2zd5vWHDBvf9s88+0/r1610lyZ49e5STk+O+rDrFql/effddN01+IIGd3TbxbuewGhT7PXb7YNjEtU22W12MTWFnZmZq/vz5rlJlwYIFioyM1PXXXx90jE112wT4v//9b3fbt+DpK6+8clDXHag+z4V1tx+IXbu54YYbal27sccYyB7/uHHjDunaAQAAgCOJOhcAAAAcNdLS0oJuW3e3yc3Ndd8tNDaTJk0Kew4LwX3HhWN1KVZ/snTpUhUXF9c63vrFD+TFF19UYmKioqOjXYe79Yf7bN68Wd26dVO7du2CjrF6Ft/95qKLLtLjjz/u6lNuuukmF35bFY3VqFg1S13q81xY4H0gdm32u+1NgUBdunRxob/v2g/lnAAAAEBTIkQHAADAUcOmt0Px9Xf7Jqvvvvtu1zMeii3OeaDucgur+/Tpo/vuu88t/GnT7zaBbV3lBzsRfuqpp/q71uvLJuJtYty6023Ce+HChXrhhRdcp/l//vOfsM9HfZ+LwAn8A6m52GhdjwEAAABozgjRAQAA0Gr4pr1tAnzs2LH1CoFtEdGysjK9+uqrQZPvFmQ3lp49e+rNN9/Uvn37gqbR165d67/fx6a+LdS3Lwv1bdHP3/72t+567DGGexyH8lwc6rVbQG+T7r7JebNz507l5eUFXTsAAADQEtCJDgAAgFZj2LBhLjy+5557VFhYWOv+3bt3+39u06aN+27BbyDfdLdvut1Xe/Lkk0822nV+//vfV1VVlebOnRu03SbdLRQ/++yz3e29e/fWOtY3VW5Bf12P41Cei0O9dnP//fcHbbeA34wfP75e5wUAAACaCpPoAAAAaDVsats6xC2E7t+/v1uItHv37tq6daub3LapbJs094XMxqa6L774Ytddfu655+rMM8909S32sy0IagH0Y489pk6dOmn79u2Ncp127tNPP9397k2bNmnw4MGunsUWEP35z3/unyK/9dZbXZ2LBdM24b1r1y49/PDDrmN99OjRbh/b17rIH3nkETfVbqH6yJEjXRf5wT4Xh8Ku1XrWH330URfc24KrH330kZ5++mlNmDDBPS4AAACgJSFEBwAAQKvyne98xy0Ietttt7lJbwvBbdFLC5YtFPc58cQT3T4WPlvXuFWUbNy4Uccff7z+8Y9/aObMmbrxxhvdsT/96U/VsWNHTZ06tdHCfquLmTVrlus4tyn39PR011/+y1/+0r/feeed50L2efPmKScnx3WsW2g9Z84c/+KmFv5bgD1jxgz95Cc/UWVlpTufhegH+1wcKgvne/XqpaeeekovvfSSO6f9fluMFQAAAGhpPN7Az6ECAAAAAAAAAAA/OtEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0XFEeL1eFRcXu+8AAAAAAAAA0FIQouOIKCkp0UUPvO6+AwAAAAAAAEBLQYiOIyYqJq6pLwEAAAAAAAAADgkhOgAAAAAAAAAAYRCiAwAAAAAAAAAQBiE6AAAAAAAAAABhEKIDAAAAAAAAABAGIToAAAAAAAAAAGEQogMAAAAAAAAAEAYhOgAAAAAAAAAAYRCiAwAAAAAAAAAQBiE6AAAAAAAAAABhEKIDAAAAAAAAABAGIToAAAAAAAAAAGEQogMAAAAAAAAAEAYhOgAAAAAAAAAAYRCiAwAAAAAAAAAQBiE6Drvi4mL3BQAAAAAAAAAtDSE6AAAAAAAAAABhEKIDAAAAAAAAABAGIToAAAAAAAAAAGEQogMAAAAAAAAAEAYhOgAAAAAAAAAAYRCiAwAAAAAAAAAQBiE6AAAAAAAAAABhEKIDAAAAAAAAABAGIToAAAAAAAAAAGEQogMAAAAAAAAAEAYhOgAAAAAAAAAAYRCiAwAAAAAAAAAQBiE6AAAAAAAAAABhEKIDAAAAAAAAABAGIToAAAAAAAAAAGEQogMAAAAAAAAAEAYhOgAAAAAAAAAAYRCiAwAAAAAAAAAQBiE6jhiv16vi4mL3HQAAAAAAAABaAkJ0HDFVFWWa/Jf/qqSkpKkvBQAAAAAAAAAOCiE6jqjImLimvgQAAAAAAAAAOGiE6AAAAAAAAAAAhEGIjiPWhQ4AAAAAAAAALQ0hOg4760C/+oklqq6qbupLAQAAAAAAAIBDQoiOIyIiJrapLwEAAAAAAAAADhkhOgAAAAAAAAAAYRCiAwAAAAAAAAAQBiE6AAAAAAAAAABhEKIDAAAAAAAAABAGIToAAAAAAAAAAGEQogMAAAAAAAAAEEZUuDuAhvJ6vSopKXHfAQAAAAAAAKAlYhIdh40F6P/7p4Xau3evfDF6ZXmpiouLm/jKAAAAAAAAAODgEKLjsPJ4PLru6fflra5u6ksBAAAAAAAAgENGiI7DLiI6tqkvAQAAAAAAAADqhRAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRcVh4vV4VFxc39WUAAAAAAAAAQIMQouOwKCkp0eUPv6nqquqmvhQAAAAAAAAAqDdCdBw2kTGxTX0JAAAAAAAAANAghOgAAAAAAAAAAIRBiA4AAAAAAAAAQBiE6AAAAAAAAAAAhEGIjiPK6/WquLjYfQcAAAAAAACA5o4QHUdUdUW5rn76Q5WUlDT1pQAAAAAAAADAARGi44iLjIlt6ksAAAAAAAAAgINCiA4AAAAAAAAAQBiE6AAAAAAAAAAAhEGIDgAAAAAAAABAGIToOCyKi4tVXVXd1JcBAAAAAAAAAA1CiA4AAAAAAAAAQBiE6AAAAAAAAAAAhEGIDgAAAAAAAABAGIToAAAAAAAAAACEQYgOAAAAAAAAAEAYhOgAAAAAAAAAAIRBiA4AAAAAAAAAQBiE6AAAAAAAAAAAhEGIDgAAAAAAAABAGIToAAAAAAAAAACEQYgOAAAAAAAAAEAYhOgAAAAAAAAAAIRBiA4AAAAAAAAAQBiE6AAAAAAAAAAAhEGIDgAAAAAAAABAGIToAAAAAAAAAACEQYgOAAAAAAAAAEAYhOgAAAAAAAAAAIRBiA4AAAAAAAAAQBiE6AAAAAAAAAAAhEGIDgAAAAAAAABAGIToAAAAAAAAAACEQYgOAAAAAAAAAEAYhOgAAAAAAAAAAIRBiI5G5/V6VVxcLG9TXwgAAAAAAAAANBAhOhpdSUmJrnr0bXmrq5v6UgAAAAAAAACgQQjRcVhExsQ29SUAAAAAAAAAQIMRoqPp6l68FL4AAAAAAAAAaN4I0XHEVVeUa/Jf/utqXwAAAAAAAACgOSNER5OIjIlr6ksAAAAAAAAAgAMiRAcAAAAAAAAAIAxCdAAAAAAAAAAAwiBEBwAAAAAAAAAgDEJ0AAAAAAAAAADCIEQHAAAAAAAAACAMQnQAAAAAAAAAAMIgRAcAAAAAAAAAIAxCdAAAAAAAAAAAwiBEBwAAAAAAAAAgDEJ0AAAAAAAAAADCIEQHAAAAAAAAACAMQnQAAAAAAAAAAMIgREeT8Hq9Ki4udt8BAAAAAAAAoLkiRMdhCccPpKqiTD968D/as2fPEbkuAAAAAAAAAKgPQnQ0qpKSEl3+8Juqrqo+4L4RMbFH5JoAAAAAAAAAoL4I0dHoIgnHAQAAAAAAABwlCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0XHEFxUFAAAAAAAAgJaCEB1NsqgoAAAAAAAAALQEhOhoVCwqCgAAAAAAAOBoQogOAAAAAAAAAEAYhOgAAAAAAAAAAIRBiA4AAAAAAAAAQBiE6AAAAAAAAAAAhEGIDgAAAAAAAABAGIToaDJer1fFxcXuOwAAAAAAAAA0R4ToaDLVFeW6+ukPVVJS0tSXAgAAAAAAAAAhEaKjSUVExzCNDgAAAAAAAKDZIkRHo1az1GcaffJf/ss0OgAAAAAAAIBmiRAdjcJC8MsfflPVVdWHfGxkTNxhuSYAAAAAAAAAaChCdDSayJjYpr4EAAAAAAAAAGhUhOgAAAAAAAAAAIRBiI5GU1VepurqQ69zAQAAAAAAAIDmihAdTbaoKAAAAAAAAAA0d4ToaNJFRQEAAAAAAACgOSNER6NgUVEAAAAAAAAARyNCdDR5lYvvHPYdAAAAAAAAAJoTQnQ0eZVLVUWZJv/lv+5cAAAAAAAAANCcEKKjWVS5RMbENcq1AAAAAAAAAEBjIkRHs0ClCwAAAAAAAIDmyONtZamlPdx9+/Y19WUcNSz4nvzwIlVVV7laFk9UtCI8EYf8s6mqLNPjPz5DqampTf2wWp127drJ4/E09WUAAAAAAAAAzU6rC9F3796tTp06NfVlAM3Krl271LFjx6a+DAAAAAAAAKDZiVIrExMT475v2bJFiYmJaokKCgrUo0cPHkMTO5oeg+91AQAAAAAAAKCVh+i+ygoLPVtq8OnDY2gejobHQJULAAAAAAAAEBoLiwIAAAAAAAAAEAYhOgAAAAAAAAAAYbS6ED02NlazZ89231sqHkPzwGMAAAAAAAAAjn4er9frbeqLAAAAAAAAAACgOWp1k+gAAAAAAAAAABwsQnQAAAAAAAAAAMIgRAcAAAAAAAAAIAxCdAAAAAAAAAAAwiBEBwAAAAAAAAAgDEJ0AAAAAAAAAADCIEQHAAAAAAAAACAMQnQAAAAAAAAAAMIgRAcAAAAAAAAAIAxCdAAAAAAAAAAAwiBEBwAAAAAAAAAgDEJ0AAAAAAAAAADCIEQHAAAAAAAAACAMQnQAAAAAAAAAAMIgRAcAAAAAAAAAIAxCdAAAAAAAAAAAwiBEBwAAAAAAAAAgDEJ0AAAAAAAAAACaY4j+7rvv6txzz1W3bt3k8Xj08ssvH/CYd955RyeccIJiY2OVmZmpp5566ohcKwAAAAAAAACg9WnSEL2oqEiDBw/WQw89dFD7b9y4UePHj9fpp5+uzz77TD//+c915ZVX6vXXXz/s1woAAAAAAAAAaH08Xq/Xq2bAJtFfeuklTZgwIew+06dP1/z587Vq1Sr/tosvvlh5eXlauHDhEbpSAAAAAAAAAEBr0aI60ZcuXaqxY8cGbRs3bpzbHk5ZWZkKCgr8X/n5+dq9e7eayXsHAAAAAAAAAIBmLEotyI4dO9S5c+egbXbbwvGSkhLFx8fXOubOO+/UnDlzam23MD0xMfGwXm9r8tWuQm3ZW6xOSXH6/p8WKyEmUg9MHKon39uo97L2+Pcb0ztVt57XX/tKK5RXUqn2bWIUFeFRTFSEOrSJUVJCTJM+DgAAAAAAAABosZPo9TFjxgwXmPu+tmzZ0tSXdFQqKK1QUkK0Coor3O2pozNqBehm8foc3fzKKu0uLNfl8z7SOQ8u0W3zv9CGnCLd+PfPtS2vpIkeAQAAAAAAAAC08BC9S5cu2rlzZ9A2u20T5aGm0E1sbKy7P/ALjc8myuOjIxUZ4dG/po3SBUO6a0RGezeRXtOSrD3qlBjrfrZanXdXbNCDr7yvYxKqNP0fnyu/uLwJHgEAAAAAAAAAtPA6l5NPPlkLFiwI2vbGG2+47Wg6Nj0+86VVWpyV4982KrODpp2eqaHHpGjZllwN7J6ksspqxUVHall2rnbn7NXg/Pf12cJn9fWmTfpa0quS4lO7Kn3Hz/XLaT9WcnJykz4uAAAAAAAAAPB4m3CFzcLCQmVlZbmfhw4dqvvuu0+nn3662rdvr7S0NFfFsnXrVv31r391+2zcuFEDBgzQtddeq6lTp2rRokW6/vrrNX/+fLfA6MGw/vSkpCQ60RuJTY1Pe3a5Ps3OdRUuQ3sk+8PyvKIyDeqRrDmvrtbigFqXjNL1+vSJmSouKdb/nCj9cIRXKW2k3CLpHx959M+PpYSEBP3f31886P+uAAAAAAAAAHDUhejvvPOOC81rmjRpkp566ilNnjxZmzZtcvsFHvOLX/xCX3zxhY455hjdfPPNbr+DRYje+AuKnjt3SchFRO+8YKAWrNwWFKCXbPhUu1+co7MGeTXvKq+6hBg235EnXfl4hF5f6dFrrx38GyQAAAAAAAAAcFSF6E2BEL1xLc/O1Vtrd7nvNRcRfWLScF3x9Cf+29Wlhdr+yGR9r2+ZXr3Bq6jadel+lVXShD9GaHFWvDZnf021CwAAAAAAAIAm0aIWFkXzkxgX7SpcagboxmpdAhWuekveijI3gV5XgG7s/seuqFZxcbG/zgcAAAAAAAAAjjRCdDRIatuYsPfFRn37z8s+8FDy2b904YjQFS6hdE2R60x/+KEH3PEAAAAAAAAAcKQRoqNBkhJi1D0lPuR9y7fkaVRmB/dzdUmBSvfs0A9GHNr5LzzRq3VffqW9e/c2xuUCAAAAAAAAwCEhREeDRXo8GvNNWB5o3pKNmnZ6prvPW1HqtqW0ObRz+/bft29fo1wrAAAAAAAAABwKQnQ0WGSER78c10ejawTpw3qmKMLj0bD09nrgRye5bblFh3Zu3/7t2rVrtOsFAAAAAAAAgIMVddB7AiHkF5crJsKjuGiPZp/XX5VVXu0rqVC7+Git+jpPH2zco4Hdk1RaUaW09HT946PN+uHIg+83f/Fjj44/rpfat29/WB8HAAAAAAAAAIRCiI5625ZXolmvrNL0s/uooLhCWbuL1DkxTmWV1S5E35xb4ipdisur3P77jv2eXnz7ce3I00EtLro9V/rnx9K9910vj8dz+B8QAAAAAAAAANTg8Xq9Bz8WfBQoKChQUlKS8vPzlZiY2NSX06In0Kc9t9xVtnRPitMx7RM09+0svZe1x7+PLSo6ZVSGrn9uuQvSq0sLtf2Ryfpe3zK9eoNXUZHhz19ZJU34Y4QWZ8Vrc/bXSk4+iNQdAAAAAAAAABoZk+iol5zCcn26OVe/Put42dswv1+4NihAN3Y7NipCD04c6m7bhPrqAU/pNz+9VOfdV60nrvSqa0roCfSrnojQ6ys9mj//nwToAAAAAAAAAJoMITrqpaC0QlNHZ2hXQZk6toutFaCbhJhIXTKyp556b6MWf3P/tDOGaPS19+iNR2aox/VluuBE6YcjvEpps38RUetAtwqXhIR4F6CfeeaZTfDoAAAAAAAAAGA/QnTUS2JctIb22D8hXly2v/O8JgvZn3xvY1DAbsfMjeutrj95SoWrFum1z17VPz7c4b+/17Hpuve+n2vSpEmudgcAAAAAAAAAmhIhOuoltW2MNu0p0vIteRrbp3PIfVxgvigraJtVupiIuLZKHH6e2g07V9Wl++QtL5EnJl7/uGGchvZsf0QeAwAAAAAAAAAcSMQB9wBCSEqI0TEp8Zq3ZKMiIzwak5laax9fYB7IOtIDeTweRcYnKiqps/ueGB9zWK8bAAAAAAAAAA4FITrqLTkhRiekJWvKUx+5BUbH9A4O0pPjo2sdY5ProzI7hDyfHW8T7gAAAAAAAADQXFDngnorKqvU5FEZevbDzdpbVK7vD+iiyaekuwl0mzhv3yZGYzI7+BcVNTa5/sDEofJIWhKw3QL0P1w4yE24AwAAAAAAAEBzQYiOessvqdBNL67Q81efpI837FWnxDgXoMdFR2rF13mKiYzQtadnykpdfIuLFpdX6fmPsnXHBQO1r6xSRWVVSoyLUtekOAJ0AAAAAAAAAM0OITrqLTEuWj86uafklV5bud0flBubQB+Z0V7Tnluui0ekaeqoDP+E+q6CUm3KKVJymxjFx0QoOjKCAB0AAAAAAABAs0SIjnqz/vIz+3bWnFdXBwXoxipcbALdAvS5i7JqHTtv8oluKt20ZzFRAAAAAAAAAM0UC4ui3tz0uMcT1HkeyIL1oT2SQ95XWlGlqAiPkuKjVVBWofzi8sN8tQAAAAAAAABw6AjR0SCFpZV13p8QE+WmzqedkamEmEj/9m5J8creU6TKqmrdsWCt8koqjsDVAgAAAAAAAMChIURHgyTEfhuMh1JcXqmpT32s5dm5emDiUBekj8rsoDU7CjSsZ3v98v8+1+L1OSr5ptoFAAAAAAAAAJoTOtHRIAnR+0Pxmp3oxrYv35LnfvbdP3N8X3VKjNP1zy3XsJ4puvuHg7WniCoXAAAAAAAAAM0Tk+hokDaxUbrujN4uMA9kt6eMytC8JRv92yxIP65zOxeg26KiNoFeUVXtJtV/t2CNtuWVNMEjAAAAAAAAAIDwmERHg9hUuVWxnDOwq64Y3UttYyO1r7TSTaD7wvJAu/aVBW2rrPa67xao3/TiCj04cej+BUsBAAAAAAAAoBkgREeD7CwoVVF5lTJS2yq5TbTb9r9/+cB/v3WgTx2doaE9klVWWa209glukVGbULcwPXCx0XfX5yinsJwQHQAAAAAAAECzQYiOerP6len/+FyLv+k7t3A8LSVeYzI7uG0WkD90yQnanl8SNInePTleL197ivYWlSs+JtLt55tO31da0WSPBwAAAAAAAABqIkRHveQXl2v6iyv8AboZ2bO9ktpEu2nzakkjMtorLjpC81duD1p41PrS0zsk6KNNe/XJxr16YOJQf/VLu7j90+wAAAAAAAAA0BwQoqNerHbFesx9bJr8mPbxmvnKKi3PznMVLuMHdtXsV1cHBejGd3v6WX30xzfWu8Dd9l+xJU+pbalyAQAAAAAAANB8RDT1BaBlKqhRu2Ih+Pb8UheQ20T53EVZ7nvNAN0ncLv9fEqvDvr9hYPoQwcAAAAAAADQrBCio14Sa9Su2MKheSXBwXpx2f6e83B8PegmJipCXZPjG/kqAQAAAAAAAKCFh+gPPfSQ0tPTFRcXp5EjR+qjjz6qc//7779fxx9/vOLj49WjRw/94he/UGlp6RG7XuxntSun9k713y6rrFZsVPA/p6hIT53niIr49v6EmCi3UCkAAAAAAAAANCdNGqK/8MILuuGGGzR79mwtW7ZMgwcP1rhx47Rr166Q+z/77LO66aab3P5r1qzRE0884c7xm9/85ohfe2tntSu3nj/ALRJqLEBfviXPf9ssycrRmMxvg/ZAtt3uN3aMLUA6+5VVbsFSAAAAAAAAAGgumjREv++++3TVVVdpypQp6tevnx555BElJCRo3rx5Ifd///33NWrUKF1yySVuev3MM8/UxIkTDzi9jsNjX2m5Wxz0mStHqn2bGK3dXqApozL8QfrfPtisG886XmMCJtbNmMwOmjI6XY++u8Hta8fsKijV8V0T3YKlAAAAAAAAANBcRDXVLy4vL9enn36qGTNm+LdFRERo7NixWrp0achjTjnlFP3tb39zofmIESO0YcMGLViwQD/60Y+O4JXDJzEuRr95eaVbGDQhJlIvXzNKdy1coxEZ7TXjrL6KjPRoZ36pfj2uj3723SrtLixTUly0uifHK2t3oR6cONRNr1//3HK9cPVJGp6Won01FiwFAAAAAAAAgFYZoufk5KiqqkqdO3cO2m63165dG/IYm0C340aPHi2v16vKykr95Cc/qbPOpayszH35FBQUNOKjaN3Kq6pdgO5bJPTfq7frrP5dNKRHim57bbUWf3Of8U2cX/nXTzQsLUU3nHmccov3B+Yn9WqvlV/nq2/XRLWrsWApAAAAAAAAALTqhUUPxTvvvKM77rhDDz/8sOtQ/+c//6n58+frtttuC3vMnXfeqaSkJP+XLUaKxlFYVhl0+y//3aA+XRM1p0aAbixsf/K9jZo6OkOLs3K0t6hcU5/6WJ9l52rm+H66740vFRMZ4RYsBQAAAAAAAIDmoskm0VNTUxUZGamdO3cGbbfbXbp0CXnMzTff7KpbrrzySnd74MCBKioq0o9//GP99re/dXUwNVldjC1eGjiJTpDeOBJDTI1XBEyn12Tbp47KcD+XVVa770uy9mj2K6t18Yg0lVRUuQVLgYORnZ3tPpnSGH+L0tLSGuWaAAAAAAAAcPRpshA9JiZGw4YN01tvvaUJEya4bdXV1e72tGnTQh5TXFxcKyi3IN5YvUsosbGx7guNr21clEZndnBBuHWiPzBxqPK+qWgJxxeex0Z9+9/RJtOnjM5QCgE6DkGfPn1VUlLc4PPExydo7do1BOk4JLyJAwAAAABA69FkIbqxCfFJkyZp+PDhbqHQ+++/302WT5kyxd1/+eWXq3v37q6SxZx77rm67777NHToUI0cOVJZWVluOt22+8J0HDlFZZWaPCpD9vbF0LSU/XUt30yah2PhufWj24KigeKiqHLBobEAfeTU2Ursml7vcxRs36QP581xYShBJg4lQOdNHAAAAAAAWo8mDdEvuugi7d69W7NmzdKOHTs0ZMgQLVy40L/YqAUVgZPnM2fOlMfjcd+3bt2qjh07ugD9d7/7XRM+itYrv6RC1z+33PWcj+vfWXMXZbkw3ULyUJUutn1nQalbYNSOC5TSJoYqFxwyC9Dbpx3f1JeBVsbedOFNHAAAAAAAWo8mDdGNVbeEq2+xhUQDRUVFafbs2e4LzaMTvbi8yoXnA7oluW3zlmx0tS4mMEgfk5mq2ef10+urd2h3YZkenDjUVbvERUe6YL1tDJ8kANCy8CYOAAAAAACtQ5OH6Gi5rH7l1N6p+mRzrtLaJ7htFqr7ptOt2sWCcqtw6dQuTh6PdEJaiua+naU/vrHef54xvVPVK7WN+7lHh/3fAQAAAAAAAKA5IERHvVn9yl0XDtJ/v9xtS7u6MHzx+hz/dHpgjYvVvFwwpJseejurVtWLHVPt9eqcgV11RnSkOifGNcGjAQAAAAAAAIDavi0cB+qhW3K8hvdM0ZbcEt1yXn+NzuwQdL8F6NaB/sW2fDeVviREV7qxYL1TYpxyi8qP0JUDAAAAAAAAwIExiY4GKyyrVFSER9v2lujXZ/XRT0sr3aKjVuOyfEuenv1wsy4Z2VMFpZV1nsdC9oLSiiN23QAAAAAAAABwIIToaJQFRt9au0vdkuL05NKd6tctSUN7JLtQfHhaivs5ISZSER5p3uQTtSw71y1AarUvgSx0bxMTpfziclcVAwCNLTs7Wzk5OQ06x5o1axrtegAAAAAAQPNHiI5GWWB03fYCDUtL0Y/HHKsH317vOtEtOH9g4lA9+d7GoB50q3ix7bYAqS9It227Ckrdz3HRkYToAA5LgN6nT1+VlBQ3yvkqyqifAgAAAACgNSBER4PY1PieonLddHZf3fnvNbrujExNP6uPq3eprPbq7oVray0k6rs9dXSGC9stQJ92em91TYrTDx55X49fPryJHg2Ao5lNoFuAPnLqbCV2Ta/3ebavXKpVrz6qysq6K6oAAAAAAMDRgRAd9bYtr0TTX1yhxetz3NS5heJREREa/+ASd/uFq0/S4joWErWwffzAroqJjFBJRaVyCkvdZHq7uOgj/lgAtB4WoLdPO77exxds39So1wMAAAAAAJo3QnTUewLdF6AbC79tqtyMzuygJVl79HVuibvtC9h9PelW12K96HsLy9UpMVYb9xS5apfHLh+um8/p5+phAAAAAAAAAKA5IERHveQUlvsD9EC2YKj1nXs8HsVGRQb1ovtCdmMVLhcO7a69RWWK9Hg0c3xffbJ5r87q34U+dACtSkMXKk1NTVVaWlqjXQ8AAAAAAAhGiI56KSitCLndJtJtqvz/rj5JbWKjdPP4vrUWFjV2e9arqzX5lHRd99xytyjplNHpKqvYv9AoABztSvLt76JHl112WYPOEx+foOLioka7LgAAAAAAEIwQHfWSeIDe8vjoKP3utS/0s+8dpxkvrQq5j02y/+S0Y92kugXv1Uu8umPCwMN0xUDzl52d7Ra/bCgmk1uGiuJ9krwacsl0dczoU+9+9g/nzWn0awMAAAAAAN8iREe9WG/5qb1T9W7AoqLWeV5Z7dWxHdtoZ0Gp3ly7WxcO71HnefJLKvTMh5vd8Vb3Ul5VfcQeA9DcAvQ+ffqqpKS4weeyyeS1a9cQpLcQbTulNWihUwAAAAAAcHgRoqNerLf8rgsHafYrq3TRiDR/5/m0MzL116WbdOnInm6/mMiIOs8TGxXhql2mjspwt4vKKo/I9QPNjU2gW4A+cupsJXZNr/d5fJPJdj5CdAAAAAAAgIYjREe9dUuO1+0XDNSN//eZC8JtIv3Mfp3dRHqbmCjNm3yivF6vW0S0Zie6GZPZQcu35Lmfyyr3T6C3O0BNDHC0swCdqWQAAAAAAIDmgxAdDVJQUqHF3wTo1m1+98K17rbPGX06atY5/XXra6uDgnQL0G8+t78mPPSefyLd6mGsJgYAAAAAAAAAmgtCdDRIXkmF+26d5lbpUnPifNHa3fvvH5Xhr2zpnBin4vJKFZZW6J4fDlZyQrQiPB794cJBriYGAAAAAAAAAJoLQnQ0SJuYSPfdKlysEz0UC9J/PvY47SutVEVltes9n7tofdDE+pjeqfr9hYOO2HUDAAAAAAAAwMEgREeDtImJcp3nvk7zcErKq9QtOc79POvlVUEBulm8Pkc3vbhCD04cyjQ6gFqys7PdYqkNsWbNmka7HgAAAAAA0HoQoqNBrIrlujN6uwVE61Jo0+evZOm34/vWCtB93l2fo5zCckJ0ALUC9D59+qqkpLhRzldRVt4o5wEAAAAAAK0DIToaxALvnu0TVFFVrdGZHbQkREBuk+rLt+S5afOtuSV1nm9f6f6OdQDwsQl0C9BHTp2txK7p9T7P9pVLterVR1VZWdmo1wcAAAAAAI5uhOhosK7J8Vq3s0CTR2XI5tEDFxe1AH3KqAxd/9zygzpXu7jow3ilAFoyC9Dbpx1f7+MLtm9q1OsBAAAAAACtAyE6GkV+cYULyqeOztD0s/ro69wSxUZFuAl0215cXuX2s9tjMlO1OKt2t/GpvVOV2pYqFwAAAAAAAADNByE6GoVNkFtQPndRlob2SNY1zywLud+8JRv18jWjdNtrXwQF6WN6p+qOCwbShw4AAAAAAACgWSFER6NIjIvyd6LbtLnVuATWuvgMTUvWv1dv1w1nHqfJo9JVVlntJta7J8dr6YY9Gh3hcfUwAAAAAAAAANAcRDT1BeDo0D0lQb+7YKAL0m3a3HrQLUgPNCazg2af2199uiQqOnJ/1cuNf/9cVzz9iSqqq/XyZ1u1eW+x8ovLm+xxAAAAAAAAAEAgJtHRaHp2aKO7LhykgtJK5RaV6bff7+sqXnIKy9U9JU4rv87XhIfe8/ejW8j+wMShevbDzYqPjvRPrt8xgVoXAAAAAAAAAM0DIToaVVlFtSqrqvXEko26/OR0931wj2T9vw821ap3sdv2UYhfn9VXewrL/duKyiub6OoBAAAAAAAAIBh1LmhUBaUVenvdLl01ppf+tnSzhvVM0fcHdg3Zj24W23aPV23jvn0/xzepDgAAAAAAAABNjUl0NJh1mFtliwXo8TGR8nqldnFRun5sb+3eV6bC0rony22fHu0T/LeT4qOPwFUDAAAAAAAAwIERoqNBtuWVaPqLK7R4fY5/my0uOn5QV3mrve62R9K8ySdqWXauW3S05qR5Yly0q4ExY3qnqlO72CP8KAAAAAAAAACgmda5PPTQQ0pPT1dcXJxGjhypjz76qM798/LydO2116pr166KjY3VcccdpwULFhyx60XwBHrNAN0sy85zHee3vfaFrnj6E/3wL0s19amPtTw71y0kmhAT6d/XFheNiYrQvtJKF6D/4cJBLCoKAAAAAAAAoNlo0kn0F154QTfccIMeeeQRF6Dff//9GjdunNatW6dOnTrV2r+8vFzf+9733H3/+Mc/1L17d23evFnJyclNcv2tnVW41AzQzdTRGXpw0fqQC4n67p+7KMsF6FNGZWh7fqnS2ifo9vP7q2ty/BG7fgAAAAAAAABo1pPo9913n6666ipNmTJF/fr1c2F6QkKC5s2bF3J/27537169/PLLGjVqlJtgP+200zR48OAjfu3Yv4hoKEN7JIddSNS2n9mvs56YNFxD01J0/XPL1S42Svkl5YrwWPELAAAAAAAAADQfTRai21T5p59+qrFjx357MRER7vbSpUtDHvPqq6/q5JNPdnUunTt31oABA3THHXeoqiq4YztQWVmZCgoKgr7QOKzLPJSyyv395uF8nVvial5sGv2EtGR1S47XtGeXa19Z3QuQAgAAAAAAAECrCdFzcnJc+G1heCC7vWPHjpDHbNiwwdW42HHWg37zzTfr3nvv1e233x7299x5551KSkryf/Xo0aPRH0trldo2Rqf2Tq21PTaq7n9WvvvHZKbqV+P6qLSy0i02WnPBUQAAAAAAAABo1Z3oh6q6utr1oT/66KOKjIzUsGHDtHXrVt19992aPXt2yGNmzJjhetd9bBKdIL1x2AKgt08YoN+8tFJLAupbdhaUuoB8cVbtvnTb3r5NjKtzWb4lTw+89aV++/1+mjfpRLWNi3KLlbKwKI60NWvWNOj41NRUpaWlNdr1AAAAAAAAoPloshDdQicLwnfu3Bm03W536dIl5DFdu3ZVdHS0O86nb9++bnLd6mFiYmqHr7Gxse4Ljc8C71tf+0JD0lLcAqFW45LeoY3Wbs/XjWcdLy1UUJBuAfqN447XFU9/7BYlHZ3ZQbecN0D/++hSd9vYZPtdFw5yFS/A4VaSb2/+eHTZZZc16Dzx8Qlau3YNQToAAAAAAMBRqMlCdAu8bZL8rbfe0oQJE/yT5nZ72rRpIY+xxUSfffZZt5/1p5svv/zSheuhAnQcXhZ8v7lml/vyeXzScPXvnqw/LFyjYekp+tnY3qqs9qpNbKQSoqP0+dd5euHqk1VZXa384gpdHBCgm3fX5+imF1fowYlDmUjHYVdRvE+SV0Muma6OGX3qdY6C7Zv04bw5rqKKEB0AAAAAAODo06R1LlazMmnSJA0fPlwjRozQ/fffr6KiIk2ZMsXdf/nll6t79+6u19z89Kc/1dy5c/Wzn/1M1113ndavX+8WFr3++uub8mG0WgWlFbW2dWoXq1tfW63l2XmaOLKn/vjml3ovoOplTGYHdU2Kc4uLDj4mWff+cIiKyisVFx2pZdm5mrdkowvSLVgnRMeR0rZTmtqnHd/UlwEAAAAAAIBmqElD9Isuuki7d+/WrFmzXCXLkCFDtHDhQv9io9nZ2f6Jc2Nd5q+//rp+8YtfaNCgQS5gt0B9+vTpTfgoWq/EuOha28orq11oPu2MTD353sagAN0sztqjaknTz+rjwnargpm7KMvdNyqzgx6YOFTXP7dc+0IE9AAAAAAAAADQ6hYWteqWcPUt77zzTq1tJ598sj744IMjcGU4kNS2Ma7D3CbHfXYXlrnvQ3sk+8PxmnzBui1Gal3qNbdPHZ2hdiECegAAAAAAAAA40r4d8wYOkdWt2CKgFqT7xETu/ydli4zWpbi8KuR+FqSf0quDC+gBAAAAAAAAQK19Eh0tW7fkeLcI6I6CUu0pLFfnxDiN6Z2q2Khv359JiInUj0/tpdGZqaqs2r/IaJvYKD01+URFejy1zhkbHUEfOgAAAAAAAIBmgRAdjeL2+Wu0eH2OC8Znju+rZZvzXMe5LTA695KhenLJRt3/5nr//nbftNMzXehuU+e2kKhPcjwBOgAAAAAAAIDmgRAdDWYBuAXo5pPsXI2J6aATe6XopF7t9cHGvZq3ZKPrPw/k6z8/Z2BXPf/jk/XyZ1vdfsN6plDlAgAAAAAAAKDZIERHg1V5vXpi0nDXb942JspNl+/IL9XTSzfpujOO04x/rgx5nAXpU0dlqKSiUsuzc905jklJoMoFaARr1qxp8DlSU1OVlpbWKNcDAAAAAADQUhGio0G25ZXotn+t1uJvJsunnZGprXlxem3ldg1NS9H2/JI6j7fgvbC0ygXq1qJ+24QBR+jKgaNTSb69Fj267LLLGnyu+PgErV27hiAdAAAAAAC0aoToqLf84nJNf3GFP0A3J6SlyOv1+qfMD8QWIG0bF+l+tvMUlVcd1msGjnYVxfskeTXkkunqmNGn3ucp2L5JH86bo5ycHEJ0AAAAAADQqhGio1G60H2iIjwqLKvyT5l/sb1AYzJTtTgreD/f4qK7CkqDthV/cyyAhmnbKU3t045v6ssAAAAAAABo8QjRUW8FpRW1tqW0iVZFVbV/ytwWC3340hOsXSIocLcAfdrpvZXaLkYTH/3Av71dPP8kAQAAAAAAADQfJJaot7axtf/5VFZ5tbOg1IXky7fkaWhasq55ZpmuPf1Y/fqs41VSXq02MZGKi45URXWVtueWqvibChebWE9hUVHgqJOdne1qYZpykVQAAAAAAID6IkRHvcVERriw3PrPffKLK9Q9OV7Xnd5bTy/dqF+N66N7/7NOd7/+pfvyheU3jjteVzz9sY7v0k5TR2fo8+xc/e6CAeqcGNeEjwjA4QjQ+/Tpq5KS4gafq6KsvFGuCQAAAAAA4FAQoqPe8krKNeWbxUN9Qfon2bnqmRKvyAjP/gD99bW69fz+2pFf6qbPoyI9yi2qcNPn8yafqKlPfayZ4/vpRyf1JEAHjkI2gW4B+sips5XYNb1e59i+cqlWvfqoKisrG/36AAAAAAAADoQQHfXWNjZaEx/70E2STx2VoTaxUaqoqFanpFj9a8V2vbh8q4ampeh3r32hi0f21Ny3s4Km1kdndtDjk05USXmlOndNbNLHAuDwsgC9vgudFmzf1OjXAwAAAAAA0GQh+pYtWzR79mzNmzevsU+NZia1bYyG90zR3EVZ7vajlw9ThMejr3NLNLRHsttu4bp58r2NQQG6WZK1Rx6t05zz+zfJ9QONqaG93fR+AwAAAAAAtJIQfe/evXr66acJ0VuBpIQY3XXhIN304gq9uz5HPdsn6NbXvnDBeVlltdvHvvsC9VAWZ+X49wVaopJ8e3PIo8suu6xRzkfvNwAAAAAAQAsP0V999dU679+wYUNDrgctTLfkeD04cahyCstVUVXtps2twuXkXh3c/daDXlpRVec5CsvoOUbLVVG8T5JXQy6Zro4Zfep9Hnq/AQAAAAAAjpIQfcKECfJ4PPJ6vWH3sfvRuibS7euTTXs07YxMDU9LUbekOI3t09FVvhQdICRvF0s1P1q+tp3S6t35bej9BgAAAAAAaJ4iDvWArl276p///Keqq6tDfi1btuzwXCmavQ5tYrU8O1eTn/pYP/zLUt18Tn/9+Z0sdUmMc4uIhjKmd6p7Qya/mAoLAAAAAAAAAEdBiD5s2DB9+umnYe8/0JQ6jk4Wgs96ZZV/8VCrdykordCxndrptvlfaPKoDI2qEaRbsD773P76z5qdbn8AAAAAAAAAaG4OuUfjV7/6lYqKisLen5mZqbfffruh14UWxkLwxd8E6D5FZVX+RUU/2LBXU0dn+BcdjY2K0PIteSqvrNJf/rtBp/Xu2GTXDgAAAAAAAACNFqKPGTOmzvvbtGmj00477VBPixbOps5rior0uMDcFJdXuTC9ppMy2rv72sVFH5HrBHBo1qxZ06THAwAAAAAANDVWdESjSIiJrLVtSVaORqS3r/O41LaxGtunk9rG8U8RaE5K8u2TJR5ddtlljXK+ijIqmwAAAAAAQMtEcolG6UNflp3nOs99nejm0Xc36Lt9Ornu8yU1ql6M7b88O0+/Hd9XRWWVR/iqAdSlonifJK+GXDJdHTP61Ps821cu1apXH1VlJa9xAAAAAADQMhGio1H60G977Qs9MHGou+0L0q2m5ZH/fqXbJwzQzS+v1uKsnKAAfcqoDF3/3HL939Unq7Jqf+0LgOalbac0tU87vt7HF2zf1KjXAwAAAAAAcKQRoqNR+tAtMLdA3BYP/c3ZfbV5b7E6tYtVZXW1NuUUa3BasiaPSg9aVNT2t+NsCr1ju9imfhgAAAAAAAAAUAshOhos8ZtFQX2Lh35/QBdd88wyPTX5RH32dZ7O7N8l5KKiPm1joxQbGXEErxgAAAAAAAAADg7JJRostW2MTu2d6l9g1L6ev+okt1jo9/p2VlSExy0eGsqYzFSt+DpP72/Y47rVAQAAAAAAAKA5YRIdDZaUEON6z+f8a7Umjuypm19epcUBC4la//msc/rLK6/eWrs7KEC/cdzxmvjYB3rh6pO0p6jcnQsAAAAAAAAAmgtCdDSYTZDf+toXumRkTz313sagAN230Oitr63W1FEZmjq6l6q8XqW2iVW72EjlFJXp3v8dLI88ivA02UMAAAAAAAAAgJCoc0GD5RSW6801u9zPNQP0wCDdXPr4h6qorHaLidrk+gUPL9VP/7ZM5zy4RDe/slrb8kqO6LUDAAAAAAAAQLMP0R966CGlp6crLi5OI0eO1EcffXRQxz3//PPyeDyaMGHCYb9GhFdQWuG+l1VW17mf7377Xl5VrYtH9vR3qE87I1OTT0nXmu0FWr9zH/3oAAAAAAAAAJqFJq9zeeGFF3TDDTfokUcecQH6/fffr3HjxmndunXq1Cn0YpRm06ZNuvHGGzVmzJgjer2oLTEu2n2Pjfr2PRkLxqeOztDQHskuNI+LjnQLkNr25PhofbRprz7etFdXn9ZL/bsl6cn3Nmruoiz/8bZQ6V0XDlK35PgmeUwAAAAAAAAA0Cwm0e+77z5dddVVmjJlivr16+fC9ISEBM2bNy/sMVVVVbr00ks1Z84c9erV64heL2qzcNxC77U7CjSmd6oLyh+YOFTLs3N1xdOf6Jpnlmnas8u0emu+/n71yYqOjNDYvp11Ynp7fbdPJxeg++pefN5dn6ObXlzBRDoAAAAAAACA1juJXl5erk8//VQzZszwb4uIiNDYsWO1dOnSsMfdeuutbkr9iiuu0OLFi4/Q1SKcpIQY/f7CQcovrdCwtBRtzCkKCsZ9obptm/HSKv9xYzI76LzB3bQ8Oy/keS1It751Oz8AAAAAAAAAtLpJ9JycHDdV3rlz56DtdnvHjh0hj1myZImeeOIJPfbYYwf1O8rKylRQUBD0hcZnQfnewnJNffoTDe6REjRZbrUuoabNbRHS2a+sdveHs++bvnUAAAAAAAAAaJV1Lodi3759+tGPfuQC9NTU1IM65s4771RSUpL/q0ePHof9OlsjmxjPK6lQcXmV8kuCg2/rRa8ZoPsszsrRmf06a97kE93iohbGB2r3Td86AAAAAAAAALS6EN2C8MjISO3cuTNou93u0qVLrf2/+uort6Doueeeq6ioKPf117/+Va+++qr72e6vyapi8vPz/V9btmw5rI+ptSoorXALi1oInhQfHHzbwqJ1+Tq3RFOf+th1qFvtiy9It55161sHAAAAAAAAgFbZiR4TE6Nhw4bprbfe0oQJE9y26upqd3vatGm19u/Tp49WrlwZtG3mzJluQv1Pf/pTyCnz2NhY94XDxxb/TI6PVrXXqycnnyiPvK7v3OpajIXrdfHd75tWt3qXz7fkuZ51+tABAAAAAAAAtNoQ3dxwww2aNGmShg8frhEjRuj+++9XUVGRpkyZ4u6//PLL1b17d1fLEhcXpwEDBgQdn5yc7L7X3I4jY3teiTbvLdbcReu15JsQ3KbH/zp1hPTvtVq8PkfLt+RpVGaHkJUutt3u97F9bjq7j354wjHqmhx/RB8LAAAAAAAAADS7EP2iiy7S7t27NWvWLLeY6JAhQ7Rw4UL/YqPZ2dmKiGhR1e2tagL9nS9367UV2/wBuVWx3HXhIN3zn3Ua3CNZk09JV2W1V+cP7qbfL1yrPl0TXUe6VbwkJ0SrbWyUq3IJtKugTGk9E5roUQEAAAAAAABAMwrRjVW3hKpvMe+8806dxz711FOH6apwMIuJdmoXGzRhblUsT7630W1btHa3f7tvOv3OBWs0d1FW0CS6he7XP7fcLUpqeqTEU+MCAAAAAAAAoFloFiE6Wu5iojUXDbUp8+c/ytYTk4arU2KsCkur1C4uyvWl/27BmlqVLoE96Bauj87soLZxwQuTAgAAAAAAAEBTIURHvSXGRWtvUXnQNq+kZ648Sbe+tjooMH/mypEhO9GNbZ86KsNNpU8elaF9pRWS6EMHAAAAAAAA0PQoG0e9WUXLrn1lGpOZ6t/Ws0NCrQDd5JdYMB5em9goDU1LcbUuB9oXAAAAAAAAAI4UJtFRb9Zb/p3jOmrwMUnyLlijJVl7VF5ZHXLiPDaq7vdrisoq/V3p7ahzAQAAAAAAANBMEKKjQbomxyshJlJ3XjBQReVVYafIl2/Jc3UtoQJ22273G9eJHhN52K8bAAAAAAAAAA4GdS5olIn0xPhoLc/OVdvY0O/LzFuyUVNGZWhM72+rX3wBum23+y1Av+W8Ae5cAAAAAAAAANAcMImORpFTWK5OiXHaUVDqwnCrdglUXF6l5z7crF+NO14/Oe1YRUZ4FBXhUXJCtL7aXaTHLx+ulDYxahcT6UJ5AAAAAAAAAGgOmERHo8gvKVdZZbVueXW1bpswwAXpgez2zHP669pnlunSxz9Um9hI/fHNL/XyZ9t09f/7VJc8/qE8HimOKhcAAAAAAAAAzQiT6GgUCTFRio2q0PlDu+sPC9e6ipbpZ/dRYWmV2sZFaldBmf6wcI273xYQLSqrcvtc/9xy/zk27C7SHfPX6K4LB6lbcnyTPh4AAAAAAAAAMIToaBQRER7tKijVKb06uJD836t2htzviUk93Pfk+GhNe3aZq3nxiY2K0Lvrc3TTiyv04MSh1LoAAAAAAAAAaHLUuaBRWL+5TY9HR9b9T8oqX2wx0eVb8vSHHwxSwjf1LbbgqG0zFqRbxzoAAAAAAAAANDVCdDSKNrFR+uvSTYqM9ITdxwLz9A4JuunsPm5B0fjoSM29ZKi+26ej5pzXX/OWbPTvu6+04ghdOQAAAAAAAACER50LGkVRWaUuPamn1m3f5ybN38vaUytAnzfpRN25YI0WB9xnE+i3nt9fZRVVmjo6wwXpVvHSLi66CR4FAAAAAAAAAAQjREejyC+p0Mqt+eqaGKdbzuuvTzblqlO7WFffEhcdqYSYCD20aH1QgG4Wr8/RrFdWa1jPFC3PztUDE4fqhY+yldqWPnQAAAAAAAAATY8QHY0iMS5aA7ol6brnluuFH5+kBSu2BQXmz145slaAHhikTz4lXfe/uV5WBvP7CwexqCgAAAAAAACAZoFOdDQK3+S4VbL8YeHaWoF5XkndHefRURGu8mVJ1h6VVlQf1msFAAAAAAAAgINFiI5GYZPj3VPidUJaSsiJ89iouv+pdUiI0fM/PsmF8SwqCgAAAAAAAKC5oM4FjaZ9Qozyi0MH4Mu35IVccNTY9n+v3qHPsnP1+KQTlRjHP0sAAAAAAAAAzQOT6Gg0Nm1eVe0Ned+8JRs1ZVSGxmSm1grQbbvdb1Uu976+Tm1iCdEBAAAAAAAANA+klWg0OYXl+mjTXheUL87KCbqvuLxKz364WZNHpevXZx+vLXtLXOhuE+rXP7fc3W/suMLSSnVObKIHAQAAAAAAAAABCNHRaArLKjT4mGSNOraDvj+oqzq1i1VZZbXioiO1M79UA7onaspTH+vW8wfommeWhT0PnegAAAAAAAAAmgtCdDSa5PgY/emt9Zp8SoYWrNgWtMDomMwO6tWxje7+wWCFLnz5Vru46MN+rQAAAAAAAABwMOhER6Mpr6rWoGOS9di7XwUF6MZuP7BovbbnlyghJsKF6qGc2jtVqW1jjtAVAwAAAAAAAEDdCNHRaApKKzTa9aEHB+g+72XtUefEOLWLi9KU0RluUdGaAfrvLxykpARCdAAAAAAAAADNA3UuaBTb8koUFxWpfaWVde5nHenZe0v0y//7XFNHZ2jqqAy3rWf7BCXFR6trcvwRu2YAAAAAAAAAOBBCdDRYfnG5pr+4Qjed1Udt4iLr3Dc2av+HH4rLqzR3UZb7eUxmqganJevzLXmaO3Eok+gAAAAAAAAAmg3qXNDgAH17fqkmjkhTRIRH7WKjwvadW33LroJSLd+SF7Rtzvn9NW/JRi1en6OcwvIjePUAAAAAAAAAUDcm0dGgChebQLfw22dsn46afd4AzXl1tRZn5QSF5ded3ltdkmJVWFbputOjIjzasLtQ+0or3GS6sZ8BAAAAAAAAoLkgREeDKlwCA3Tz5trdktbouu9m6mdje6uy2quEmEi1iYnSss17NfXpj/2B+ejMDrr5nP7alV/qP75dXPSRfigAAAAAAAAAEBZ1LqgXq12pGaD7vLl2lwvD28ZFKTLC4wL0W15dpV+9uNIfoJslWXt022urVV5d7W6f2jtVqW3pQwcAAAAAAADQfBCio14KDlC7sjGnSGfdv1jbcotVUV2txVl7Qu5nQbrH43F1L7eeP4BFRQEAAAAAAAA0K80iRH/ooYeUnp6uuLg4jRw5Uh999FHYfR977DGNGTNGKSkp7mvs2LF17o/DI/EAtStx0ZH6xfd6q1/3JOUX1x24W93L0LQU5RWzqCgAAAAAAACA5qXJQ/QXXnhBN9xwg2bPnq1ly5Zp8ODBGjdunHbt2hVy/3feeUcTJ07U22+/raVLl6pHjx4688wztXXr1iN+7a2Z1a5Y/UooNlVu93dsG6uPN+7196JPOyNTT0warocvPUHzJp/obtv2orJKzV2U5YJ3AAAAAAAAAGhOmjxEv++++3TVVVdpypQp6tevnx555BElJCRo3rx5Ifd/5plndM0112jIkCHq06ePHn/8cVVXV+utt9464tfemlntyl0XDqoVpFuA/utxffTnd7J0XOd26pwYp08273Xh+fLsXF3x9Ce65pllmvrUx+72vEknatW2fHec9acDAAAAAAAAQHMS1ZS/vLy8XJ9++qlmzJjh3xYREeEqWmzK/GAUFxeroqJC7du3P4xXilC6JcfrwYlD3SKje4vLVVBSoeVb8lRQXKELh/VQfkmFyiqr5fVKD7+dpfdq9KLb7QiPR+cO6qopozII0QEAAAAAAAA0O006iZ6Tk6Oqqip17tw5aLvd3rFjx0GdY/r06erWrZsL3kMpKytTQUFB0BcadyLdqls25RTpqfc2ulqWtvFRevK9je7+2KgIDeyeFHZh0cXrc9SrY1s9/1G2C9Hz6UUHAAAAAAAA0Iw0eZ1LQ9x11116/vnn9dJLL7lFSUO58847lZSU5P+yDnU0rj1F5UptG6trTs90tSxRkR43ZW5T6bsKSg94vE2sXzwiTWf/abGue265tuWVHJHrBgAAAAAAAIBmHaKnpqYqMjJSO3fuDNput7t06VLnsffcc48L0f/zn/9o0KBBYfezqpj8/Hz/15YtWxrt+rGfLRz6+JINru98aFqKSsqr3fZ5SzZqeHp7dUkM/QaHT1J8tK5/brmKy6v07voc3fTiCibSAQAAAAAAADQLTRqix8TEaNiwYUGLgvoWCT355JPDHveHP/xBt912mxYuXKjhw4fX+TtiY2OVmJgY9IXGVV3tdZPnFoJbnUthWaX/vq9zixUTFaExNRYg9RmT2UHvfLnbHetjQbr1rAMAAAAAAABAq15Y1Nxwww2aNGmSC8NHjBih+++/X0VFRZoyZYq7//LLL1f37t1dLYv5/e9/r1mzZunZZ59Venq6vzu9bdu27gtHXnH5t6G5WZadqzP6dNQlI3vq8SUbtTw7Tw9MHKpq7/6w3ceC9Smj0jXt2eW1zrmvtOKIXDsAAAAAAAAANOsQ/aKLLtLu3btdMG6B+JAhQ9yEuW+x0ezsbEVEfDsw/+c//1nl5eX6wQ9+EHSe2bNn65Zbbjni1w+rY4kJum01Ls//+CT9fuFaf2hudS1TR2do6qgMd7tTYqyqq6WJj30QNIXu0y4u+ghdPQAAAAAAAAA04xDdTJs2zX2F8s477wTd3rRp0xG6Khys1LYxOrV3qqthMRaK5xdXuH50C83LKqsVHx3pJtEjPR4VV1S571GRoc9n57JzAgAAAAAAAEBTaxYhOlq2pIQY3T5hgH7z0kotydrjAvCuyfFanp3rOtJ9Rmd20I3j+khF5dq0p1gpCdFacP1oZe0uUoTH42pg1m0v0K3nD3DnBAAAAAAAAICmRoiOBssvLtetr32h4entddPZfdUmJlKzXlkV1H9uLGCX1mpIWoo/XPcF65c89oGGpaXod/8z0AXwAAAAAAAAANAcfFs2DtRTTmG53lyzS5XVXq34Os/VuSyuEaAHBulDeyQH3b739XWuL31xVo5++9JKF8oDAAAAAAAAQHNAiI4GKyitcN8tHO+WFK/Csso697eO9EAWnvuC9cXrc1woDwAAAAAAAADNASE6GiwxLtofjiclRKttbN0tQbFREXUG6/u+CeUBAAAAAAAAoKkRoqPBbCHRU3ununA8JsqjmKgIjclMDbnvqMwOWr4lr85gPT4m8rBeLwAAAAAAAAAcLEJ0NFhSQozuunCQdu0rU4THo+XZuZpzfn+3aGgguz1lVIbmLdkYtH1MQLBuIfuy7Dx60QEAAAAAAAA0C3X3bgAHqVtyvL4/oIv2FpXrlc+36Q+vr9OTk0/UDI9Hm/cWKy460k2s3//ml27hUR+bWL/53H6a8NB77udJo9J1/XPLNSK9vQvnAQAAAAAAAKApEaKjUc16ZZXey9rjfl60bpdO7pWqa55Z5m4nxERq6ugMXTqyp+tAtwqXju1iFRnh0avTRsnjkc598D0XstOLDgAAAAAAAKA5IERHvVnlSk5huQpKK5QYH63qaq8WfxOgmwHdkhQf821jkIXjcxdlBZ1j4c/G6NwHl2hYWrJuPqe/f3u7bxYrBQAAAAAAAICmRIiOetmWV6LpL67Q4vU5/m1PTBoetI9Nm+8qKHNd6EsCwvXALvTISI/72cL3Oa+tdpPqK7bkueoXAAAAAAAAAGhqLCyKek2g1wzQQ7G6Ftvv9gkDay0yaguIThqVod8vWKMXfnyypp2RqeXZeTqlVwf9/sJB9KEDAAAAAAAAaBaYRMchswqXUAH68i15Lhz3daLb7eO7tFNxeaWGpKVoyqgMfxe63WcLiFrFy8SRPbU8O1cPTBzqetO7Jsc3waMCAAAAAAAAgNoI0XHIrAM9lHlLNrogPMLjcSG773ZucUWtLvRAFqz7gvffTRhw2K4bAAAAAAAAAA4VIToOWWKYRT9tqvymF1fonz89RcUVVdqaW6JIj0dJ8XUvEmqT6caC9NLK6sNyzQAAAAAAAABQH4ToOGS26OepvVP1bo1KF6timXvJCdqWX6IHF2W5UNy2Pf/jk/TdPh3Vt1uShvZIdpPncdGRWpadqy+25btqF5+CksomeEQAAAAAAAAAEBohOg6ZLfp514WD3NR5YJA+57z+2ri7SIPTknX5yem66ay+kservMIKzTynn2a+vCqo1sUWG735nP669PEP/NsS4/gnCQAAAAAAAKD5ILFEvXRLjteDE4e6RUb3lVYoMT5aHo9cUH7b/C/00CUnaOXWPHVOjFP7NjGa9fIqf++5z5KsPbr1tdW6eESaC9fHZKYqpU1Mkz0mAAAAAAAAAKhpfxk1UM+J9GM7tdWQtBR1CAjKrz6tl+KiIzR/5XZd8fQn2ltUrsU1AnQf298qXmwq/bYLBrjQHQAAAAAAAACaC0J0NAqbSPcF5acf30lz397fiW6sA70ubWKjXBB/+2tfKL+4/IhcLwAAAAAAAAAcDOpc0CgKSiuCbgdWt8RG1f1eTVFZpb8r3cJ4m3AHAAAAAAAAgOaASXQ0isS4aPc9ISZSpRXfTp7bbWN956GMyeygTu3iNO2MTLev9asDAAAAAAAAQHPBJDoaRWrbGJ3aO1WDeiQrJnL/ezMWij8wcaie+XCzJo1KV7W8QRPqozI7aNKoDF306FINTUt2+9oCpQAAAAAAAADQXBCio1FYBctdFw7SppwivfPlLo3pnarBPZL15HsbXXD+wYa9mjo6Q1eN7qWkhGgXtO8rrVRJRZXbPm/JRnm0Uff+75CmfigAAAAAAAAA4EeIjkbTLTleW3NL9Oi7G/TadaO1s6DU33VeXF7lgvIhE5N1z3/W1ZpItyn0659brsLSSnVObMIHAQAAAAAAAAABCNHRqNrFRbnAfOHq7RqR3iHoPps4902mB/LdtvvpRAcAAAAAAADQnLCwKBosv7hcX+0q1PLsXEVEeHTnBQM0b8kmtYkNfo9maI/kWgG6j223+9t9s0ApAAAAAAAAADQHTKKjQbbllWj6iyu0eH2Of5v1oT84cai/qsUXnJdVVh/wfLFRvK8DAAAAAAAAoPkgsUSDJtBrBujGbj/8zleKiJCmjMpwQfrBBOSdEmP1dW6xOy8AAAAAAAAANAdMoqPecgrLawXoPrY9JiJCz3+UrREZ7TX9rD6KivDoiUnD5fF4tCw71y00av3pZkxmB721ZpeO69zOnTcpIeYIPxoAAAAAAAAAqI0QHfVWcIBFQEsqKvXLM49TfnGlfr9wbVAfuk2nPzBxqK5/brmGpaVo0qh09/MLV5+saq/3CFw9AAAAAAAAALSQOpeHHnpI6enpiouL08iRI/XRRx/Vuf/f//539enTx+0/cOBALViw4IhdK76VGGYR0ISYSM04u48iIyIU4fHoobfX11pQ1G4//d4mPf/jk/TLcce5AH1oWrJeX71Dt772hetaBwAAAAAAAAC19hD9hRde0A033KDZs2dr2bJlGjx4sMaNG6ddu3aF3P/999/XxIkTdcUVV2j58uWaMGGC+1q1atURv/bWLrVtjE7tnVorQH/40hO0ZP1ujbt/sb7OLdHiGgG6z+KsHO3eV6bKKq8L0K0/3SperArmphdX0I0OAAAAAAAAoMk1eYh+33336aqrrtKUKVPUr18/PfLII0pISNC8efNC7v+nP/1JZ511ln71q1+pb9++uu2223TCCSdo7ty5R/zaWzvrLb/rwkFBQfrU0Rl6YvEGf3BeVll9wPO0bxOjoWkpbhrd15H+7voc140OAAAAAAAAAK22E728vFyffvqpZsyY4d8WERGhsWPHaunSpSGPse02uR7IJtdffvnlkPuXlZW5L5/8/Hz3vaCgoJEeRevWNkL63fhjtaeohwpLKxQbHakH/r3Cf39laZGqy4rDHp/gKVP29pKgY3y2796jjnEHDuHRcO3atXMLvrYU3m968/O/3qDqyv1vvNRH4a6t7nvBjk2KjY1tsnNwnpZzLc3tPPt2bN5/joKCFvc6BgAAAACgpfB4fWlUE9i2bZu6d+/uKlpOPvlk//Zf//rX+u9//6sPP/yw1jExMTF6+umnXaWLz8MPP6w5c+Zo586dtfa/5ZZb3H0AwrP6pI4dO6ql2L17tzp16tTUlwE0Ky3tdQwAAAAAQEvRpJPoR4JNuQdOrufl5alnz57Kzs5WUlKSWiKbOOzRo4e2bNmixMREtUQ8hub1GOzNqZbEd71Hw3PPY2haR9NjaGmvYwAAAAAAWoomDdFTU1MVGRlZa4Lcbnfp0iXkMbb9UPa3j8iH+pi8BegtNTDxsevnMTS9o+ExtLQKCN/1Hg3PPY+heTgaHkNLex0DAAAAANBSNOnCojY1N2zYML311lv+bdXV1e52YL1LINseuL954403wu4PAAAAAAAAAECLrXOxqpVJkyZp+PDhGjFihO6//34VFRVpypQp7v7LL7/c9abfeeed7vbPfvYznXbaabr33ns1fvx4Pf/88/rkk0/06KOPNvEjAQAAAAAAAAAcbZo8RL/ooovcIoGzZs3Sjh07NGTIEC1cuFCdO3d291t3eUTEtwPzp5xyip599lnNnDlTv/nNb9S7d2+9/PLLGjBgwEH9Pqt2mT17dsiKl5aCx9A88BiaTku97kA8huaBxwAAAAAAAA7E4/V6vQfcCwAAAAAAAACAVqhJO9EBAAAAAAAAAGjOCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAAAIgxAdAAAAAAAAAIAwCNEBAAAAAAAAAAiDEB0AAAAAAAAAgDAI0QEAAAAAAAAACIMQHQAAAAAAAACAMAjRAQAAAAAAAABojiH6u+++q3PPPVfdunWTx+PRyy+/fMBj3nnnHZ1wwgmKjY1VZmamnnrqqSNyrQAAAAAAAACA1qdJQ/SioiINHjxYDz300EHtv3HjRo0fP16nn366PvvsM/385z/XlVdeqddff/2wXysAAAAAAAAAoPXxeL1er5oBm0R/6aWXNGHChLD7TJ8+XfPnz9eqVav82y6++GLl5eVp4cKFR+hKAQAAAAAAAACtRZRakKVLl2rs2LFB28aNG+cm0sMpKytzXz72nkF5eblSU1NdcA+g+eN1DAAAAAAAgKbSokL0HTt2qHPnzkHb7HZBQYFKSkoUHx9f65g777xTc+bMqbU9Pz9fiYmJh/V6W5P84nKt3bFPDy5ar2XZeXpg4lA9+d5GvZe1x7/PmN6pumJ0hu6Yv0Z/+dEwzXxlVdD9ozM76I4LBiqtQ5smehRorngd1217Xok27y12r7+ar7k7Lxio2KgIFZZVatYrq7S4xv2zz+2vOxZ8oUVrdwdt//2Fg9QtOd69tnMKy1VQWqHE+GiltolRUkJMrWs40H52/659ZcreW+ze+FiWnat5Sza6+0L9vRiV2UFTRmXo+ueWa3jPFN31zfWYbXklmv7iCi1en6OEmMiQx5/aOzXoGAAAAAAAgFZR53LcccdpypQpmjFjhn/bggULXE96cXFxyBC95gSrBe49evQgfGtkm/cUaeZLK11AN+2MTC3Pzg0KtALDudvOH6Dfvrwy5P0WpN/7v0PUOTHuCF05WgJex+FZOL1g1Q69tmJb6NdcZgfNOW+Abn41+E2rwNfckLQUzV2UFbT9e307uYB9hr2u1+fUGU4Hhtqh9gt1vy8kX7U1Xx9v2hvy2myfqaMy/LfT2ie4gP63L63Um2t2uW11/b2xa3hw4tCQoT8AAAAAAECLWFj0UHXp0kU7d+4M2ma3LUQLFaCb2NhYd3/gFxpfSXmVf8J1aI/kkIGWsRCtpKIq7P1LsvYot6j8sF4rWh5ex+HZ9HendrHhX3NZew74mrPXbE3Hd03UjH8GB9/m3fU5uunFFS68N/a9ZkAeuN/OgtKQ99v12PT46MzUsNdm2+OiI3XF05+4r+/98V3d+PfPdfGINDeBfqC/N3YN2wtK/dcKAAAAAABw1IfoJ598st56662gbW+88Ybbjqa1r7TS/3NZZXXd+5ZU1Hl/QcC5ANTN6lMO9Jo70Gsq1PEWTgdWv9QMpy28N/a9ZkAeuJ+9KRbufgu/K6vq/jBUfo2/F3YuC9+njs5Qj5R4tYuLrvP4DbuLdN1zy900PAAAAAAAQIvrRC8sLFRW1rcVAhs3btRnn32m9u3bKy0tzdW2bN26VX/961/d/T/5yU80d+5c/frXv9bUqVO1aNEi/d///Z/mz5/fhI8Cpk3s/qlQY/3LdWkXX3folRjXoqr6gSaVGBetvQf49EbbuG9fn6HYJPsTk4a7MN0mv62vvLzqAG+GlVb4Q/y6HOj+hIC/HaGE+nti4fs1px6rC0/orm15pQc83jcVT7ULAAAAAABocZPon3zyiYYOHeq+zA033OB+njVrlru9fft2ZWdn+/fPyMhwgblNnw8ePFj33nuvHn/8cY0bN67JHgP2i4+OdP3FZvmWPP/PofqX28ZEuu/h7k9pQ8gFHKzUtjFuwc5wrznrRN9VUKYxmalh7k/Vlzv3ubqUa55ZpqlPfew6xtNSEur8vb4JcAvxD2a/uoT7e2CPyf6ehNKtfbxmvrxKSzfsCfvYA48PnJ4HAAAAAAA4FE068vud73xHda1r+tRTT4U8Zvny5Yf5ynAorG/4k825mnZ6piLk0bwlG/XAxP1vjAR2FVtYd+O441VSVanbJgzQzS+vcn3MgUHa7y4YyKKiUGt/PVnYaxPctohmapuYOqen7b7vHNdRGaltQr7mpoxO198/2aJfjjte1fLWuv/a0zM19emPg85p+6z4Ot8tBByqisUW7LTw3th3u20hdU22OGmbmEg9c+VIV8vim3K3vxHF5VUu4LdPsdzxP4PcwsSB57BrmzQqXdc/F/rvfWlFtbvO5dl5If/ejO3TSdeP7e2ey4cvPcH97urmsY42AAAAAABoYTzeulLso1BBQYGSkpKUn5/P4oSN5KtdhTp37hL9+dITXC1ERbVXOfvKdWynNtqaW6K8kgpXqWAToWu3Feg34/vqzTU7NKRHstrGxSi/uMJVuCQlROuYA0y/Akfz69h6u20Rzk8357rOb+slj/R41LNDgiqrvSosq6wVrFvovqeo3AXEtm9heaWKyqoUFeHRkqwcrdqarytG99J1zy1zC3L6FhHtlBgreT266NGlLtCuyRbunH/daM1+dXVwuN07VXddMFBt46L8YX+bmCh9mp2r2177wn+usX07aeb4frr55ZVB3eo2HT5lVIae/XCzLhnZU1Eej7qlxKlzuzh3PquJaRMbpbioCM157Qu9uWaX/3p8z4npmhSnBat2uEDe+O6zSpqE6Ej16JCgWa+sCn7ToHeqfn/hIHVLDr0QNQAAAAAAQCiE6Ggwq3644OH39Yvv9dbIjPauI6hjYpxmvbwq5MKENn064/t9XSj4l3eydPV3MrV6W4Gbpu1KuIVW+jq2MHzNjn1qFxep2KgozXl1lT79ZsraFtIMDINt8vuuCwfJI+nXL67wT4tb0HzzOf10QlqySsqrXJWKTYpbsGy96bbAqL1hFeGRJjz8vu754WBX4eITGFTbMRbeJ8ZGaWteifYW738zbN3OAp1xfGd3vryA6fJ12wv02/H9lFtcppLyapVUVGlejesOnDKfPCpdz3y4Wf26JbnfN7xnSq2Je3tTwbrM7ZMuoZ4HXyBv0+qBbwRMOyNTn2fnhvz7Y88d3egAAAAAAKDFdKLj6ODrRB7QLUnTnl2urknxKiipDBlgGdu+Pb9Uf1i4Vledlqm9heWa8c+VbgLXgkSgNbK6k6pqr8orvS5At9eJBdo1g2PjWyjznS93B9WtWJBsr6V7Xl/nf0NqQ06R9pVVusntERnt1adroiIjIty+gYt2WoBuQbW9KebrRx//wBLNeGmlCsurdOPfP9d1zy3XKcd21G3zv9Alj38Y1KF+0Yg03T7/C63dXujuM6ECdLM4K8eF7zaJ7pskD9VXbhPjFngvuH60ng7xPNhte37seQp0cq8OYf/+2HNnbwp8tbuQvzcAAAAAAKD5d6Lj6ODrRLbJcpuOtcoJm2Kti91vfegerdMNZx4XtPAfE6JobbL3Fruw2kLhJyYN9wfANqE9d1FWyGPs9TLplPSgbRaEX31aL53dv6tu/L/PgoJk3/S6BdO+16xvEeD36gjs7XVqH1fyBdX3vr42ZJjtrjctRb07t3WPISEmSvMmnxjUgR6oyut1E+RD05LddXQIs6Cw/T2wN93CheLu2kdlBK2tEPjmQCg5ReX6yf/71E2/+54TAAAAAACAcJhER4NZyGU9w707tnXTopJH8TF1/9PyhVw2kRod+e2+1ocMtCY2Df3bf67wB9GBb0AdzJtRPhaMP3vVSerUNlZzXltdK3T2Ta/b77PXrIXHVsFidSgWpFtgXzMct1DeqlEspB59bKrG9e9SZ5ht57CJeptkn/jYB/4pdZtwt3MFqqzyugDdfr+F7FY9E47V0Bzo0zD/d/VJ+vfPxmjOeQPclHtdrDverslqYnzPCQAAAAAAQDiE6GgUNqm6o2D/tKjXI1nTvgVzodh2mzz1se5kX8BWV5AGHI3s0xeBwXTgFPWBJqp999vrx6a+7359rTolxoWtUbEgfde+MvezTV9bJ3qv1DaadU6/Wq+9mvUuFz/2gbbsLa7zekKF/qEqV2xavFdqgptctxDbetxtYVT7XaFqVqzHvS5xMRH601vrdfafFuu79/1XC1fvcL8jFOtj75wYq7YxUXrxp6e4bnbrdwcAAAAAAAiHOhc0mAVe1mc+cUSau11QXKFPs/fqutMzFSGPmzYPtRCgT0L0/sUMP9+S56ZpgdZia25xrQA3sGIl8OearI7FF4jb62dfaaXb79KRPev8nVtyi9UmNsqF6DaRbl/2Gt5TWBC0X6h6lwOF+knx0fp40143ve5bnNS38OjwtBS3jz2eyaMy3OO2CXQL/x9alOW63AMfW2DNSkqbGBeKW7VMTWN6p2rl1/lB12nntTcATOAxtu8138nUeXPf89fL2Hl/N2Ggew7sDY2C0golxkcrtc3+5wYAAAAAAMDj9drMcOtRUFCgpKQk5efnKzExsakv56jw1a5CN/1pYZjVNzx35Qh1TIxXRVW19pVUqF18tKIiPdqRW6oPN+8N6ke2qVDrRC+tqHILkqantmnqh4MW4Gh4HWfvKdKSrBwNPCZJ5z74Xq0JcAuwl2fnae4lQ/Xkko1B0+oWBt95wUBFRXjcYp4//97xKq+sdlUqyQnR2pZX4t7YCrVY57+uG6UH3lzvptCNLzhuExOlTzfnukVD7fVpveY2gR7IwnGbFg8V6lsYPf2sPu58jy/ZELSPBedWs/L13mJ98k1H+lNTRqhzu1jNfHlV0BttgY/RrrFzYpy7vXlPkX770sqgUNx+563nD9A5Dy6p1bluz6O9ETCuf2dt2VuiHu3jXdh++/w1QfvafvZYH347K2yHPAAAAAAAaN2YREeDWQBn7P2Y8QO6qEtyvAvGLETzBVkn9+qguNhIndhz/zSqhWjWhzzznL7anlfqJmNjIjxN/EiAIzeBbpPjFhCXV3p1xwUD/OGufdknNex1M+30TFfP8v2BXd30tk122zT4zoJSbcsvUc+UBP3qrD76zTeLkgaGy89ceZIuffyDoCDdwmwLkgcck6Tc4grd/MoqLV7/bYBtb2r5wvNQ1SyBE96Bv88C79vOH6AFq7a57aEWHp3z6moNTvt2oVRbSNQWIw4VoBu7LnuDrqra64Ls6mqv+xTL9LP7qLC0Sm3jIrWn0KbHy2oF6Ma22e/q1zVR1zyzTAuuH61t+aV6+NITFBcVqaSE6P09VB6ve/NhzY59ITvkH5w4lIl0AAAAAABaOUJ0NJgt6udbrO/XZx2v3wQE6L6JWguzfIH6Kb066LTeHRUZ4VF0RIS+2JGvIT1S9N+sHH1/QBcCKxzVbErcwtmgyfKA8NoXpH+enafzB3fTrFf2v55qskB85vh+bhI98A0rX43KnqIy9+mQix/9wJ3PfsekUekuoH/+xyfp9tdWa3CPZE0+JT2oduWJxRvc/aEEBvw3nd1XRWWVLuReumGPXvl8q4b3bK8/LPwy5LEWllv/uG/K26qbNuQU1flc5ZVU+INs+zlwMt63kGrON5U2dVXM9EiJV3x0pD7PzvWH+L7n0IL55z7crOeuOkkV9sZBhMd9gsYqXezTNLlF+xdiBQAAAAAArRchOhrMwiwLxcqqqlVcUe0P/AI7lWsG6j4W7M34fh/ZDHpi9yTlFVcQWOGoZJ3bucXlutnVlwSH4vunsb0uvP46d3/1yOurd2pLbknYRUJtuw1S1/n66p2ql68ZpSqvV1VVXv3vo0tdEG4f+rh4ZM9a+/tC5b2F5a52JVQfuy/gv/CE7i5stinuE9JStOLrPEUf4NMkFtZ/r28n3XJefzchb5PoFvRbeB9Y8+RjU/c2Eb6nqFztE2LcGw2+wL9Tu1j94d9r1Kdbks7o01H9uiXV6mH/Ylu+kuKj9PSUEZoZ4s0I321b4PTWf32h7w/sohkvrQqa6L99wkBt3VOktvHR/G0CAAAAAKCVIkRHg1mwdPuEASosq1R+8f5qF2OBli+gC7VIoT88/PdaDeuZovvfXO9Cv9/TQ4yjjOso/8cK/fx7vWsF6D62ffK+Mlc9YpUj9tqx73WxELvO19f6HNdxPjozVT3aJ/hD6qiIiJD7+27feObxYatbLFi++dx++t1rX+jNtbv92y1wt9oZC/RD1auYjNQ2+u34frrpxZW1Fhy232VT7r5jbZstrGrnszcLanan29+KSaeku5qYxyedqFtfWx30hoC7znP6679f7tSAbsl1vhkxdVSGO9Y3Ke9j/eszX17puuBTq7wqKa9ydVUAAAAAAKB1iWjqC8DRMWFrU5xWz9ImLtK/PbBT2QL1cCGWBX0Duyf5f7b6BjsncDSwf8sWoFsAbNUndfG9ZtI7tHEBuk2k18UqRw7m9XVKZgclREf6w2XfBHsotj0qMsJf3WJT2s9cOdJNydt3m1S/699rggJ033G3vfaFbh7fN+R5LRS3NxN++3JwgO471kJ9ezPAt6/9Hgvybdst1t1e4xh7XHaMTbVbgF7z8VgAbttP6pXqqmAO5nkP1QNv57E1G255dZU27S3mbxMAAAAAAK0QIToazGoZ3ly7y9U67CoocyGdr4rBJ1Q4Fai86tv7rb4hcDFEoCWzf8sWANtEtS/0DsdqSGzC+j9f7HAT6VbpYoFyKPY6s85u+36g15e9Lq3SxeqTfjWuj+syr4tNXPsmyq26paRif0/7pY9/6O5fVCNADwy2bdHSmtfsC8Vt3YS6wvsz+3V2lS0W3Pum0m0NBd/0vl2TTYXbPvYmwxWje6lnhwQtz84Le86af4tC8d0fbj9byHR/mB7J3yYAAAAAAFoh6lzQYAWlFf4A0IK/Z648Sbe9ttpVMfg6lQ8UYh2TEh9UA7Hvm3MCR8vr4+rTeikmIsKF3hbI1mTb28ZG6rbz+2tDTrELidvERGls386S1taqVJk8KkPXPrPMVZnkFNa9uKbpnBinwWnJ+tNbX+ra0zPr3LequtpNne8tKnch9Xlz39M9Pxzs7jtQYF9UVqUT09u7ihTfwp7vfLnbheK+c5iaC6Ha3w9rVF+3s8CF6Wf17+xqZyz89z0XSQnRuvv1tbV6322B0Suf/jhkwF1WUR30t6gmX22M73sobb/5hI2F6dYtDwAAAAAAWhdCdDRYYty307V9uya6MOv/XTHCTbNOGNJdc/4VHKjXZNOxNhlrIeMf31jvtrULOCdwNLw+Tj++k+5Y8IULv2vWqVgoPv2sPmobF1Vr4VFbNNPus4C4tKLK9YrPX7ndP6l96eMfuMU5LUy2SfCafOHwqb07Ki0lXsPSUtx+9rqrWZHi2/+9r/a4cPuKpz9xU98npCUfcFrbxyprbMFQO9bY8b7Q23dsXQuhzj63n+79zzpdOKxHUG+7TaB/lp3rvx0Ywu8pLNP/u2KkXl+9Q4++uyGokz05IVrrthe4SXjVeN59E/LPf7hZ153eW1Of/th/n+/8J/fqoKLSKvccd24XK0/da6cCAAAAAICjECE6Giy1bYzu/J+Brlri+u/2VkxkhApKKrWrsEzPfrhZg3ska3hais4d1FW3v7am1oKCk0alu+DrprP66i//3aDhPVPcOYGjgf1bPrV3qvvZesTf37DXhbM2qW0T2BYsW8jtkUezagTovuoU288qTlZsydPMc/oFBc8Wrl/86Ad6+ZpRmlOjG9wXElvgbmFwWvsEd66/fbDZTZrf+toXYff3TY2/tOxr/e6CgXo/K8cfyNcVwC/dsD+A9wmcXPe9mWaPJdxCqLe8unp/H3qN+wMXKg4bwmd2cFPpeUXlKq6oUkpCtOsznzm+n1tg1X7vVWN6KSEmSu3iomTvZlSrWpednK4O7WLcmwX2KYG6zn/7BQMP4b8+AAAAAAA4GhCio8H2lVZqwYptmhEQeL06bZQ/JPP1J1sw9eDEofrJd451/em+8NA3UVtRWa2bz+mn7xzXUUkJhOg4Oti/5bsuHKQte4vdbfu3HhjM+liFSc0A3cdeR9d+J1OXjkhz/eQ12Tn/vXq7xg/sWiuc3784aLILt5dn57p9Lh6Rpu15pS5UDrW/nS+9Q4LeuuE09yaAPYaoCI9G9uqgO+av0cxz+h5UAG8syPaxhUItnI6Pjgz5HBgLsaef3adWwB4YxtubECFD+Kw98mqthqSl+M9vU/62/8BjkjSgW5KblE+Kj1J0ZIRmvbLKX61jj9NqY347vp+7fcf8L0Kef+ZLK3XP/w5x9TgAAAAAAKB1IERHg2zNLdb0f64ICpssLHdVCKMydOnInq7reFl2rgvQjG9xwposoJp1bn91TY4/YtcPHAndkuNVWFoZtgvcXh9Wf1SX6KgI99rILy53k+22AG8g+xSHW3Dzna+Cal0Cw20Lx+11aQHwJ9m5LlQPFWbb+bt/8zq0Sfevdhe6a/1o0163cGhldXWdAbyvtsUCbDvPd/t01Ftrd7v7bJ/HLh9e52O17vGaAmtkAqfSa7JQ3Ffd4rtt9Tl2vb6KGXtOpo/r48J229em1a1Syp7T5z/K1qM/GqbBaSmueifwv5H9DbO/U7nF5YToAAAAAAC0IoToqDcL8zbvKa4VoNuk6ZxXVwdN1VpoZdvLq6oPONUOHI06J8ZqbN9Obgq8Zk2Ihc3nDOpa5/HtYr/9c/3b8X01KbdEHo/HH+7atHlpRbV+Ne54TT4lPWS4HTjRbcdYz7dNhffpmugP9W1y3GpfLNT/1YsrQgbyb3yxK2QAb6//Oy4Y4BYTtUDfguYPN+7V7RMG6lclFSoorVRiXJQiDlAs7lvIM1BgjcyBFjeteb/9jfItdOq7XXz6t58IsAl0WxTZ9xgsVK/5+Hx/w+y53Jpboq6JcXxiBgAAAACAVoIQHfVmE6p5JRVB28LVLPhu/2LscXWe0wIs4Ghkgest5/av9ckN37T08s15YRcHtZA9pU2MtuWVaHqNYNuC5fnXjVaVvK4L3GpKfBPXofgmum2B0SiPdN0ZvXXP62trL/B5Tj9NOiVdvx7XR2WVVdpdWKbYqEjtyC9RTJSn1kKd9tqdN+lEPfT2ev3mpVVB4fOJ6e1dUO8Tbpre91h3FZTVWojYQn/rO/fKe8DFTUPdXzNYT4iN9F/3MSnxLvS3fXqkJOj2GlU1gY/T/sb5/v4RogMAAAAA0DoQoqPeCkr395oHqqtmwUKo6WdFuJDM10McyEKzyIi6J1SBlqywvLJWOOtjC19aGG493YGf4vAtZmmvtEVf7nZT5hNHpLmKkZVb8+T1StvyS13Xd2W1V/kllf76lFCvsV0FpTqhZ4rOHthFS77ao4837Q25wOcd/16j6797nO5auKZW9/nsc/vrzTU7NP2sPq4r3SbMLYz+w8K1tV7bduzNr6zS3IlD/aGzryf+phdXBAXpdm6rdPrjG+tqhfQ2Sf/Yu1+5qfbi8kr3vITqkPctfnowwfoZfTrqkpE9g67bwvS6uumv+U6m65e3aXubVk+Mj1Zqm/298QAAAAAA4OhEiI56S4yL1ltrdwVNjB6oZmFvYbluPqe/bn1tdVAwZ9O0k0alE6LjqFZQEr6uyELiXfvK/F3cpntKvHbml+qqpz/Rn380TK+t2BY0+e060N/O0v1vrg8Oos/p734ODNJt+7TTe6u0osotKmrT4nZ84LGB+nVL0r2vrw05kX3ba1/o3EFd9Z8vduqEtBS1jY1y1TKh3hzzhfI1J7etJ94WGt6aV6JNe4r91TOXPPaBq7yJ8nh045nHa+b4SBeaJ8fHuMU/Ha9Xc84foNk13nCwN+jsubPKlbqCdbv99rpd+vnY4/T7hcGP8UB/w+xvlKvP6ZHsn/i3qXp7U8AeEwAAAAAAOPoQoqPeLNBat73ATYxax7EFZQeqWeiUGKctucW66ay+ior0uMUW95VVur7o+9/4Uvf8cPARu37gSLM+8LpYxUjNHm6rQrnnfwfrlldWBYW9Visy9+2skCG3vUllHeC/GtdH+SUViv+mJsmCY1uA1Pc6qyswrutTJZ9uztWc8/rrX5+vCuoVD3osNRZQLa+scjUuxgJ1+ySLTXG3iYnSjX//3N/ZbtwixKP3X4PdbxUucdER/hB+Q06R8osrai3+aX+T7n/zy6Bz1QzWAxdaHZHevtbzd6C/YXZu658PDOVtmt6m6u1NASbSAQAAAAA4+hCio94sLPJNg/7m7L7adkqJuiTF+Rf/q8nCrAWrtrvQzQK2m8f309Ceyar2el0If8t5/QmgcFSzXvNwdUb2uomOiNBbN5zmOsitIsX6zdvFRmpPUXmtipG6Qu7l2XnqeFase23Z5HRRWaXe+2qPC6ctBE6Ojz5gYFxXwG7heM0p8MBz+RYYrrmAqnWtX3t6pqY+9bE/6LYpblvg1Lct3LH2vN31P4N0TPsE/6dgPs/OC9rHF9xfObqXoiIj3JsWFtQXllW4gNs9N98stGpBuEe1P/li99fsY/ex7dYJb3U2FVVVGnVsqtrFRWlnQanrqqcnHQAAAACAoxMhOhrEIqgz+naW1yNXbdAjJV5PTx2h2a+uDlr8MHAaNDAkm/HSSv8+VCLgaNc5MU53XDBQv3lpZVCQbq+PKaPTtT2/VI8v2RBcddQ7VTPH93Ovm8AJ63Aht+/1dffCtcHd6r1T9a/rRrvXbJvYKPd6qyswts7vcEIF+IHnCrfAsPub4PXq+R+fpK9zS9z0+LLsXD2+eINuPqefZvxzZdhj7fmyvxc2RW9vDpyQlqzxA7vqs+xc3TZ/jXtu7Mt6yof0SNb1f/1Ew9KSXYf6cZ0T1bldnKvLscd1Sq8Oen/DHhVXfPt8+tgbDfb8mZr/HW47f4DKqqq0LbdEHdrGKjrS4z5ZY+d88aenqLSykp50AAAAAACOQh6v15alaz0KCgqUlJSk/Px8JSYmNvXltGhWzTDtueWu2uGVaaN014I1uuykdCXEROir3UXqkhTvAr12sVH69+od/inYaWdkuqApVHBnwR6VCDjaX8c2uZxbVO6qjCoqq12ga4HsRxtrL/LpC3AH1wiurc/c18kd6ECvr7t/ONjVKOUWl6uyyusqZKwCZVGN/nRbNLRmX3hdvzvwzTGrkgl1baGO99WrpHdIcG8M2AKp5819L+yxz145Upc8/mHQc2OfYtmyp1hVXq8L85//KNv1qlvYb9LaJ6hTu1j/35VteSWufmVQj+SQz5U9lpnj+2rwMckqKq9SfEyEkuKideu/Vuv9DXv9j/O9Gm+EWBf9hIffc3/neFMQaPm+/vpr7dkTeq2HcDp06KBjjjnmsF0TAAAAgKbBJDrqzaoLbLLUQrv7/rNOs87tr/eycjR/5fagxQ8fuWxYUPhXVw2FdQtTiYDWMJFuX1/tKtR37/uvP1j+4xuhF/m019lPTjs26HUTbor8QK8v+501Q+hbz++v6WdVq6isSm1ibTo8z9WrWAhsAn+H/c5OibG1zm3BsX3SxCbJ28WFn2KvOUXvO/esc/opr7jCdbjXJa/G/fbc3PLqav+bDOHqYAJDbd+iplaTc8HQ7u74wE/OWNXL8PT2uuvfa9ybC4FvTNjP4Sblb5v/xf6u+kVZ9KQDR0GAftzxfVRSXHRIx8UntNGX69YSpAMAAABHGUJ01JstDBgY2l17em8XDAaGSxasVVRVH3TXsjlQiAY0509nBC6aWbPSwyag7d93QUmFqwApLKs86NdFTFRE0HoD9skOC959i/oerFAh9OxXVgeFvV0S41xdyva8UjeRXl5Zrd2FZUpLSXCfKnlrza6QAb693j/fkudqVupSs4vdzlPtlZZu2KOTe3U4pGN9j2HyKenu53B1MDVDbd+Xuf38AcraXej+G/jO7wvQa74xUdebFHYdP/tub/+nbnhTEGi5bALdAvSTr7pN7TqnHdQx+3Zma+ljN7tjCdEBAACAowshOurNFvezqc/2bWL01OQTVVxW6UIo3+J+FjbZ7eSEGN1xwQDd98aXrmKhR/t4PXzpCf4+ZF/g5GPHAy2NBeS2uGRgoB04/bx5T5HrQg8Md5+5cqT/Zwtvfa+d4WkpSkqIdotjWu2LVZzERUVqeEaKfvKdY91iodbE1bN9guZOHOqC2n2lFW4C3PrCDzWEDhX23j5/Ta1w3qawrYPcJtVD9YZbpcmkU9L1+uoddS7OaVP0Ndnip1bDcma/zmEXXw13bOCbEAf7SRdfpU5xeaXriPfxeDxKbRujDzbsrXXumj+HYm+S2HNjU/n2d83+uwBouSxAT+nRu6kvAwAAAEBrD9Efeugh3X333dqxY4cGDx6sBx98UCNGjAi7//33368///nPys7OVmpqqn7wgx/ozjvvVFxc3BG9bsgFTfMmn+iqXAanpejs/l1caDT3kqEuGA8Mssb27aS/X32yZr6yKmi7hWKBgZNVS9hkLdDSJtBrBuiB0893/s/+xUQDa44sLLdA26bJLbi1aPvJySfqL+9+5RbGvOc/64IXtrSAelSGrvrrJzrl2A669fwBKimv0s59RW7qPSO1jdvPKlHsdRRqOr2uEDow7PVVNdVkIfczV56k215b7a9usf7ztrFRqqz2ukly225Chey+/nPfPoHsEyv2hsO1zyzTg5ecII9nXdA12BT+pFHpIY81yd8shHqgkNu64L/eU6TNuSXaV1rputiXbf52cdL9vyv471LgGw+h3oSoyfXCf1PrEhjQAy0NneAAAAAAsF+T/t/9Cy+8oBtuuEGPPPKIRo4c6QLycePGad26derUqVOt/Z999lnddNNNmjdvnk455RR9+eWXmjx5sgug7rvvviZ5DK3dQ4uy9Gl2nn51Vh/FRke6RQoffGt9rSnSPl0TXYBeczLVd9sCJ+scnnNe/1r1L0Bzr28pq6wKW6liQXpBaWVQgB6qs9s+rfHvldvdG1Kh6kgWW+WJpB+f2ksDuidp+j8+d9t857Q3tPa/HnPd+W0iPSiE753qpsTDhdCBPeZWR1PzEyX2yRGbfv/9wjUakpaiqaN7uX1sSr5tXJTGP7Ak6HyBIbsFyVERHn25c58/mA7kpta/2qPPv5lwzy+u0E1n9dHkU0r9FSsd28XqT29+WetYY5Prdr+d50Ahd3x0pGa8tNL/3Pl+f2Bo7nuufUH4yq35/iqdcF30vvPY/XbfVaN7uf+mtjDpJ5v2KqVNTK16H6A5oxMcAAAAAJpJiG7B91VXXaUpU6a42xamz58/34XkFpbX9P7772vUqFG65JJL3O309HRNnDhRH3747SJ5OHIsPPQFdncvXKs1O/bpb1eODAqnfOqqWLDA6aaz+7qfrWIhtW3tRQuB5lzfYvVEdbEOdJ9wnd22noC9diaP2h/chmLH/GLscfrjm18GHW/nfHDRev+2wADbpLVPcNPqM19aGTKEttoZ+2SJj/W1hwr6rX7GesJ9XeG+oN0C5prcp1K+Odaenxv//rk7py3aGWrC3hdgTx6Vriue/sT9LvvuY5VRE0f2VGllda3pdnvOduSVamhaigvTw03i2+/6/Ou8Wn+jAt/M812zbfM9f/bhmGtOP1bV8rpP2Rxoyt6el2PaJ+iJJRv0m5dWhaz3AZo7OsEBAAAAoBmE6OXl5fr00081Y8YM/7aIiAiNHTtWS5cuDXmMTZ//7W9/00cffeQqXzZs2KAFCxboRz/60RG8cgROq9YMBK1KIpSDqViwcOqs/l1c3zPQkupbbEq7LhZgH+gNJd9r5ECvFatNqRnA1zxnYIBt/vPzU11IP+f8ASqrXOGm4wOD3d9fOChoQtomx0MF/TUX/fX9nnH9O7vboabXbd2DhOhIt29guB84YX7xox/4w33f47dqmMBu9OKKKhfEX31aL7fYqdtWVqXoqAgtXr9bw9NT3O/dnl+q2ef21+xXV9UKuW8+t78mPPReyOc1MDSvaUC3JBfo+67d/hsELrh6TEq8Xl+90/9GgHXHz3l1Va2wvubipkBLQCc4AAAA/j975wFdVZW2//emN9IpoYTeQ0eKgH1EpI8dv5Gq4yDojJ8jghQBlXF0HGcEx7Ew6vcHdSyAgOLYB5SmoiShixApoaT3ev/r2WFfzj33nHuTUBLg+a2VFe6p+5y7z87i2c95XkJIHYroJ0+elIqKCmncuEp80eDzrl27LPeBAx37DR48WMUKlJeXy7333iuzZs2yPU9JSYn60eTm5p7Fq7i0QWFRo3gHAa2BTf6vr4gFf4dDlo7vq+Ieru3kGeVDLm3q23NszgzHeOStGCZc6zoCxE4k18+Ir2fFqvCuL+H9l6xCCQn0k8S4cCXgGguRwoFuFnTzDfEzVm00czy3RK7t1FA5xc3uddyXG5OaqHabxX3cE7jHje54fQ7t+HaIQ8Wo6OVdm0bJU+t2eQjkw7slyOglX6tjwbWO4xrFesSsHMgosHTi291HOMbfuXegiNNzYsIInPZYh2uEgI76EF0SImXi4DYexZOtirgSQgghhBBCCCGkfuO7Qlo94ssvv5Qnn3xSXnjhBfn+++/l/fffV/EvCxcutN0HRUejoqJcPy1atDivbb6YMcY/ALg0YSJHlIIZCFgQ06yAAAbX6ZIvqwoqElLfn2O8hWGeBEKkCPqyER3xAdc6fnvL7NZZ2/q3FViObHEz1Sl2+eiKZBWXBPEWzy4EdFzHyYJS5az3dn3mNprB9cH9beVex8TCog93yZwRXTyuBfcEArNV4VPtXH/w+g6q+GqTqBCZM7yLLN98UAnkWAbxGlnw+PzURzvVGAS+TctSNRbgHp+67Hv1GyJ3rA/h2ngfMV6tTT4qt7y40fZ+GPfTWfc47/DnN6jzTnptq/qM5cbJD2MRV0IIIYQQQgghhNR/6syJHh8fL/7+/nLs2DG35fjcpEkTy33mzJmjolumTJmiPnfr1k0KCgrknnvukUcffVTFwZhBXAyKlxodrHUtwF0sQIxDjIEGrvTjeSUyc1gnEecu5R7V7DiSI4+NSpL5H6S6LTfmCEM0w4/TSZcmqd/PMd7CMKKjRoyFNAtKypUgrPu2jjJRmd2nilQagZgMYfjV9fvVMwHMhUEhRB/JOu1q13grdqnzylEAGLFJlZVOedgQRWOV1W2+PmMbIQj7ORxu+8N1jXtgdX6Aa509orMsn9JfcorL1LiRfCjHrcgo8sonDm4t05afLnyKdZkFpUoEh/C/7O7+0jAy2MPtrseRAISXG9ppvocQsn0VBdUCOiZFdBFW8/01xtaAZjGhsvK+QbJwdarX4sm6zcYiroQQQgghhBBCCKn/1JmIHhQUJH369JHPPvtMxowZo5ZVVlaqz9OmTbPcp7Cw0EMohxCv4xSsCA4OVj/k3AAx6LrOjaRTQqQ0ahCsxLUvdh+XG7s1UQUCjVEKt7+0Uf73+o4ya3hnySsul4jgAPnPjnQ3IQ3Lyyu8R1OQS4/68BzDrY0YDriS0XcX/bqbLFyzQ/Vd9HFzIU04kY3o9RB4V0y9XBas2eEmuPZtGSNNo0JlaFKCBPr5yawbO4vD4VDRKg1CAtRzMW3Z93Jj9wR5ZFgnFaGC9YgLeWtLmiwe19tD3IYwPWdkF/khLUuWjOutim9uy832KLr57cEs+WrPCbmsVYxUOkUqnU4l6Ovj6zgS/Ly9JU2euaWHapcxEmb3sXy3Y5rz0SsqnVJUhnvlL4eyiqRjk0h5654BkplfKhEhASrKCdEtdsI2hHqHUyzd7vrzQ9d3dN1rPWkxe3hndVznqQKvM4d1lu2HsuXxtTvdBHzkpecWlapYGDjQjeOSUZTflpZtW3TVqqiyOW/dXMSVEEIIIYQQQggh9Z86E9EBnKXjx4+Xvn37qkKhzz33nHKWT5w4Ua2/6667pFmzZirKAYwcOVKeffZZ6dWrl/Tv31/27dun3OlYrsV0cv5AzvMTa1Llj0M7yYI1qUpQgnjYqUmkco5aMfP9ZFk9fZBM+NcW6dMyRiYOauW2PiLEX8IC67RbEmLZ142FRLUzHFEiKrLD5FT2Fq8CYRZu8Lkjukp+SZlg/i/mVMQKXNdZhSVKUJ+7yr0wJdzR/7yrjxLun/t0r1s73r33cokJC5QnxiSpiaj03GK1Du1CIc1eidEy7ep2SoyvME046hgSxKTAJW8WqXFdWA9RGe1aMDpJFSltHOl+XZGhAR7H1EKz8bP52HCQQ5CftSJFfdaObeNbKrr4KQqb2rndsfyRYQ63+wzx++bezWUO7qVpcmHl1EHyc0aBisfR9+m9310uxWWe2edGUX7+qK7qjRpfRVfNYCIB14T7xzdtCCGEEEIIIYSQC4s6VStvu+02OXHihMydO1fS09OlZ8+esm7dOlex0bS0NDfn+ezZs5UzEr8PHz4sDRs2VAL6E088UYdXcWkCVy5ExR4topWAbhQPzcX5zI5UuEJR3HA6ohKcTpdoBmGroKRCEmPC6uiqCLHv62b3Nj5Dsv3o/iGSU1SqxFoI3ygc6S1eBcvXpqSf6vPx8vjYJIkODXQJq92bx8jsVSmW2eJzVqZIz8QY+XzXCbd24Lx4puD2fvKjnbZO7bkjung8n3j+IG4jV9zO5Q2HO64zOux0O833aNvB09f82yvbyPHcYuW+vrN/SyW6707PVS5uq3YhTx3Od7StdXy43Ny7mfiJQ7KLSmX1tMGu4qdHc4q8fldZhe5CNuJv5qxM9nCI4/P8NanqmrVgju8iNNBPgvytJ0D0mwRwqls5zn3l0uO6cD643UXCvW5LCCGEEEIIIYSQ+kWdW34R3WIX34JCokYCAgJk3rx56ofULYi1gHg34fJWbq5NiIcD28TZOlI1EKy0uxXZw/g8b1RXaRDkT5cmqZd93QoI5uWVTuneIkZ9hpCN7QtKytxEdY3RXe3KCl+RIqN6NpVB7eJVJnlUaKCt2xpC+pTBbWTaNe1ck1Ihgf4qcuVEfon67M2preOVjOA4eDYheJsd2Jr1p67T7tnENS9cu0M90zj+sK4JSqS2c7TrmBTdrpN5JW5vr+iMdn1fNVGh3seG8gqnm0O/e7Mo9faLr4gVuPznj+6q3gqAYI/zG783Y7uKSsstj+dr4iTY30/d37E9m3m9BkIIIYQQQgghhNQ/6lxEJxcmyIUGZlcr4hOu79JYiVIQ/LTL1SwsVRVVdMo9V7RRRQyfHJskkQY3LiH1ra/bgVxwDfqvsQ9DVD+aUyzZRWUehUaNz8LDwzrKvFUpKmsccSx2YFIqITpEtm3I8iisOap7U6/7gqLSClX814h+hiGSW4nzOg/deJ1W90hHnuCaF5oEdLsCmxrcHyMQsB95b7s6lvF++hK428aHy8qpl6vCrsh5T8sq9Ho/kG3/4f2DldP+YEahq1AyomPw9oHxPDpSxq4/uIquisOjePK0q9tLpcPJPHRCCCGEEEIIIeQChSI6qRUQvoHZ1QohDRnR7/x2oGzanylJzSNVQcDJg9u4CXIAkQgzhnWWAH+HtIhjvAGpP/nnyLdGEUq4wiFcmyOJjAIzCmvaAQF4/8kClXVuLjRqBEVCOyZEKkd3ZIj9sIw2PG4qSArwGVnpEOOt0O3HRFWHRhHy5t395eufMlT78Qxjfeu4cHlj4wEPcV67x/V1Ggus4njx4UGu8cD4bPtyf/uKQoGAjfMYRXT8Gw71R2wE7oToUGkp4fLT8XzlQEdEjB24ZmTAY/LC2F7tgtdvFRiLp4Iv95ywdJzj2pErj4LKuqgy+g/SYXCeH3/JVm3kRCEhhBBCCCGEEHLhQRGd1ArtCLWKMICYlFtSLh8mH5GZK5K9xjnAndvilPuTkLrmYEaBzFqR7Nafn76pmyog+vznez0EZiz35SyGwAwR3Zu43SgyWAa3jZfS8golsl7bqaF8Zsg91yAqyTZyZd9JmeHspKKRjE5o20il9vGyZvpg1bb37h3o1T2ObHFcp1WBVYwDi37dzeUQN7+dYsa8HvcR44gVWYWlSrQ3Cs+IvLESuI3baLd48uEcj/uhwTWZBXSAa8A1Lr6jl7RtFOG2DuI8JitwP433R1/HuP4tVa0H45sGa6cPVn9oUZQV3wUhhBBCCCGEEEIuPCiik1qhHaEQoZDxrAUliEQQuJ5Zt8tDnLKKc0CERJkhx5iQuuBYbrESbA9nFam3JlAAUr81cTinWD748YhtwU2Ird6AwLvlQKYqnGt8JuzEbYjRC8ckiUiqm5COiCRfxSsP5xTJxMGtVFSSPpdtpNLekzJnVYq6VjjsvbnHZw3rrCa85q5KVcWEUQvB6Mhf9OFOeXJsNzUB4auNxvUQ8sdf3sqVEW8GbwRAlMZYA/Hc7IJHsU6AZQcyCiQ6LEjKKiolNMhfVk8frNqMeKlhv2TL42t3usRtCN46L93uLQNkzJtd48bYGuwDV31YUIAUllpH9YCC0nLBCIfjHswslLLj+artKGCKwqkRmAQId58EIIQQQgghhBBCSP2CIjqpNRC1kOF8LK9YZtzQSYIC/CTAz0+O5xZXK84BQtbG/RkyLKnJeW45IadJyyhQb0zYFcHs1ixKnvt0r+W+EKIh4AJzxIkWRfH7qg4N5bKWMTJv9Wm3t524DSf0nJUp8sSYJHloaFUWOdzsMeFBku8j87xpVIhkFpSpYr0TB7dRUUlxYUG27nX9PPpyjyNbPK84UG7vn+gh+utiqRCvMYGGyQg79zdE87YNw+W93w2UkrJKKSqrkGWbD3oIz/q4EKZxPzBZN29kV3lsdap0SohUgnd6brHkR4WqXHNE5iREhcjm/RkS3yBYXt3gfl8xgbHyvkFyPK9YRaygAGl+SbntRAbObVUA1Bhbo7dHZIyxKKoZ5NTf+s9NahIE34sW2vV9u+PlzcqlricKCCGEEEIIIYQQUv/wbhkkpBosXLNTRi3+WglT8z5I8SgSaAaCnRaQlNu3pEI5TAmpCwe6WUAH+AxhFUK3L4EZbuJpb26Ta5/9Ssa+8I1c+5evlHsa0ScaZHVDXB/RvakSXV+4s7cM7drY47waCMd7jufLsL+tVwLskx/ulIpKpytGyQqItHA8/27Zd7L065+l0umUID+Hcj97A9fnyz0O13RwoL+l6K/vFd4qwYRBq/gIeWJskmqPuX2YGIgJC1KTEuNe2azuEyJQMB4YMY4PAHnxj32QIrf3S5RtaVlKtP7d//teRi/5WuZ+kCIOh8it/9yo2vAvk4AOMKm3cPUOScsolJHPfy13vrJZwoKrHOh21wTB3jwuWd1/HWllhTGqZoOhT+lzvP71ATXxgCKoyHnnOEgIIYQQQgghhNRP6EQnZ8TxvBJXPrK/n8O2cKAxMgEZxg/+qqOs31sVVREY4CfZhWWMMyDnnayCUpeAahXrAdFUO83tgKPamBGuRXCIohBIdb9uFBkiV3Zo6CqKCSHd63EN4r3xeIhNeeT97UqUNYq1cDk/9+keV1wSZPHZI7pIcVmlTLumnWVRVDiiIaBb1TYwHhvrvYn+WA6RX5MYFy5/ubWnur+5xeWqWCqc9I0jQ1SuuL5f5mgUtK9FbKh8nHrMLRoFbQd2gjfAMXB8u7dg4IxHwU+9bfKhHO8Z89UsbIr7iGx8RPsY+4GeCDBG1ZjHR7Tp3qvaut56OJpb7DoPIYQQQgghhBBC6g8U0UmtgdM2zeByzT3lQDcKchAm77mijVzbuZEczy0Rh8Mh/917QglPvRKjZen4y+TrfSfkqo6N5KcT+cwGJucVXYDStvhmuzj54w2dlIvaKFq71rePl4iQACWIm8Xp/1qIsLooJqJISiu8O9zN7nB9PLiueybGKIFWu8iNedx39m+ptldiskOUeA33tjmuBNf71uY0tS/ajM9+4nCLYTEKwf1axXptrzmSBYI2fnSOOcYLRKjkFLlPShijUfA9LJvSX4nmiIrS9xT3CsvONJZGr8ex4ILH+OMNROmYCQ/yV0VJ80vKJDYsWArLqiJ3Zg/vrL4LXCuy3O0y0s1txLaItIGwv/9EgTy5diejXcglx6FDhyQjw3oCzIq4uDhp3rz5OW0TIYQQQgghhBihiE5qBYSxGe9tVwUGNYirAFqQg6CEqIbXvv7ZLVPamDe95It90qdVjBzMKJSpy75XUQkUkMj54FBWoXorAgJ4i5gweWrdTssYkKBP98gTY7upnHLtPtYC+n1XtZPbX9rkVrBS920ssxJhAYpcokCnL/e3GRwPfm87Mdks0sIl/8zHuyzd2w4RlTOOSBTtCIej+ndXtVWRTGZxHvnq3kDWuBkI5xgnjA7t5VP6W+6vJzKe/c9uNzc57sWwrk3OSiyNXo9tcU0QwL2B/mEc87IKy2TOymQ5kFEor03qJ7NWukcBYbLl8THd5N7/953tGwzmNuKz0aFu9RYDIRe7gN6hYycpKiyo9j6hYeGyZ/cuCumEEEIIIYSQ8wZFdFIrIBBBGDMKgWFBfsq5CwEMwhtEIAjoG7zEL0AM1BELgAISOR8czCiQWYYsdOSUWznNwWe7TsjDwyrk6Vt6qMKeELLDgwNUjvWk17e6OY3Nfdsowpqfne8OZinR2LgfQFHO8YNaucWAaKyOZ6Z5TKgSw+HgVhEjNteF6z2cXeRqP4pbtooNE0jwxrgSgMktZJnbif5Yj+gbq4k2c9TNN/szLAuPessn3344R1rGhnm9bsTAoC6DXVFT48SEFrJxj6pzTZgM+GrPCVmz/YhsS8uWVdMGydxVKR774Z7OXpksi8f1VpMr3tpg9Vn/2+otBkIuVuBAh4A+8O6F0qBxos/t846lycaX56j9KKITQgghhBBCzhcU0ckZxWC8tSVNXhl/mYQG7JXSCqfcd3U7JcJpcclOwDM6LxFPsf1QjmsdBSRyrouJzjYVE/UVA3LgZKFkFmRL78Ro5QSvcDqVAO2tb1sJy8ZnxyoPHOJuwwbBbu52jfF4+LdR5DaKsv/ZcUwJ+HBFX9G+odfriggOkJVTL1fiPI6tnzlMYuEZxISBXldUWiHTr2nvukajI/+pm7p7PK96ssAM3lRZOXWQzF+T6nYcb/nkC9fskHUPDLGN1cFy5Kjrt2Cc4nTbDvdr6tXtZNJrW90ip/T2Vtc0f3SSZBaUSml5pYqtwoRhq7hwiQoNkIoKp20+PM776PAu6hjG6x98KrdeT46YM9ObRYdKypEc5cj39hYDIRcrENBjWlSNMYQQQgghhBBS36CITmpFZEigEnsQvfL3z/aoHOYFH6TKd2nZLlEwLMh799LCZdOoUNmVnuu2jgISOVdkFZZ6TO7YxYCgj//2yjbSvlGEzFuVIjPfT3atM0e3mDELyzob3HguYx645uPfD1GucLMT3Hg8c3FLK1EWYu7vrvI+OQB3edtGEa627T9ZoGKZUJsAy41EhYmEBvnLk2O6SUFpuWo7IlwaNQi2nPDSkwVmsN9HqUdlRPembpMHxsKkVvsczyuWPw7tJA5B3Iu1OG2cmJh6VTvx83OI0+mUxNgw5VJHHQaI31o8d8jP6j7+a8JlqgBqjiHG5ok1qXLX5a2lZWyoPP/5XuVA14Vnw32MbXnF5bL4jl6q8DKOiX7UIDhAjuYUqcx3RONkFZSpa8Yxdx3JkXWp6bL1QKarT1XnrQNCCCGEEEIIIYScHyiik1oBZyqK6y3ffFC6NI2SRpHBckf/ljJxcBsVkYCifXCzegNilY4zuKJdI/mz7HGto4BEzgWHswrlcJang9xYDNec0X08t1jmWER3mKNbjEC0TTDk+huzwadd085rhEiTyBBLJ7hVgVJsk1lYqor6WhWy3IjoFJMjWoPllU6nHDhZoPLejcK0XW0CtKG6b4hgos2Of361X9beP1idd4MhUgf3XAvVENeNxVpLyp3y9U/HpUditMptxzpsvyb5qNt164kJ/OCYk1//Vl3Pol93kxHdElzCfYDDoSYdUPz0qY92Wr41U1LhlBuTmigB3Vh4Fsf1fu0BlvcK0wQzTW9BIH5m3qiuciSrSMornWpMxdhq9RYDIYQQQgghhBBC6gaK6KRWQBzq2ypaOidEyl8+3uUmIiIXHXENRWUVXvOJEauhnbPv3jvQtc4uBoOQMwFuaxSwtcIq1kNndEN0/boasUTG/gt3tl02uLHwLiagtGAcExaoxHctvPoSq/X6k/klSii2u67V0wfL/A9S3VzrcG+Pv7yVfJhyVLb8nOlxfWejNgGeYbvYGTjtvz2QJT0TY9QYgOtvHBmsstzh+jaOJxgrIFpvOZApSU2j1LVi/WcPXqnc7tUpsoo2IJKlYWSILDXlrmOsMgroZiEf3wnuw7LNB137WU26GO9tTLjnPUM/eHSl52QMxsd5H6RIr8QY2ZaWpe5HYmwo46wIIYQQQgghhJB6BEV0UmuC/P3lsY93WIhCGSrvuF/rWFUgsWrZSTeRfc7IrvJRylF5fO1O5RzFj3Z3tojxXkCQkNoA13Z2UZnsOJrrIYDqGJA5w7uoH8SaoFAlBFpEFXnDmKdujl3R5zU6wXEuCNSoJWCegDI6wHXECoRiHbFiFlazC8uUe9kOnMthyDjPLiqVkAB/Ka2olNyicrm6YyPlCreiJrUJ7NpqFTuDa1wwOklu/Pt6N9f8H4d2kE0/ZVg6/v3EIX1axbjda7j0vbndgTE6J6uwTB5650clkN89uI1EhQWqWJXCkgqPtw+049xc7HXT/kzVZtSCWDZlgCxck+qWvQ4B/Ymx3ZS73YxdRry+xkdv7CKB/g7lRJ85rLPX6yKE1JxDhw6pYqTVZffu3ee0PYQQQgghhJALC4ropFZANEMshjeH7uTBbST5cLbMurGzlDsr5ZfMIlfe8JglX7sJaAF+fm5uWrs4CUJqCwRe9D+7YpLIy+7fJlbWpR5Vy7V4bpeXrmkVH67epEC+uH6D4qfj+S5BGUVIdbFIze39EuXpj3fZOsARPfLI+8luoquVwI4oFzjYP5g2SGVsbz2Yqa5PnwuRLf5+kNGr8swf+2CPm+t6iI9c9+rUJjBG1Vi11Sqa5kBGgdv5cH+u6NBQnv74dKSTEUzCTRjUSsVGvXBnbxXlgvsdHRbotcgqxhoNvkecE/en5x3R8sx/dqv7b4xm0W8fWLnFEcby9j0D5eMd6RLg55Cn1u10c9Lrse3xNTvkmVt6eEw+2GXEa5CX3q9VrHRvFq1idgghZ1dA79CxkxQVFtR437Ky0nPSJkIIIYQQQsiFBUV0ckauXiPmGIQmkcESFhQrJ/NKZPPBTBVVYCW6w+XpZ9Ipz0acBCFG4Fr+bNdxJZbr4pPGwpbIPsfbEUu++EkJq1rH9BbdgeUlZRVKVEUhTitBGUK2FqoBzju0a2M3p7P52YHDvEeLaPnuYJZLbMYzgeKm80Z2Vbna6y2Kiu44kuM6F65z9vDOMuxv61XG9ofbj3rkfuNzpU2ue3VqE5ijauyeX/MzHJHvLkrh/MdzS8QXn+86LmUoENoiWvadyFdRK4vGdpP/7jupInR0jnp6TpE0iw6VHw5lu0Ty6LAglUcfGugnrxmEcuP32zcxpqo9p/qFMZMd92pCXrEaxx4Z1kme+3SvfL7rhGU7rRz8vlzz/g6H/HyyQLokRKm3BH46kW/59gEhpObAgQ4BfeDdC6VB48Rq7ZO+Y7Nsf/8FKS/3nGAkhBBCCCGEXHpQRCdn5Or1FYOAeIP5o5PkyLYCJfIBoxiJ9Q8N7ShHc4rPKE6CEF/AAb37aO6pfujeT7UIvXDtTumdGC1No0LleH6xmuCxc67DxT1+UGvJKSyTFrFhtoIyPjudTrnnijaS1CxKPSNdEiJ9Pjtok1l8v75LY5n5/nYPMVy3C7nar3/9s7x1zwD5z45jcjS7WInwEJitahPY5bpXtzaBt4gSb8+vOS8dorgvEJHicIi8uuH0fcK9+9eEy05NEHhGRr2+8YD89ZO9bvd09vAubo53Y0Z9QnSIbNuQZfs9QFjH/fIl+Fs5+L1lxF/TqaFEhwfJyxv2y6wVKa7lfCOHkLMLBPSYFu2rtW3esbRz3h5CCCGEEELIhQNFdHJGrl7t4LSLQUBeMNyzT47tJo+tTlUin3Z5RoUGSoOQAJn02laVI21FdeIkCKkOEHMxofPk2h2qD8JNXFBcobKxIcaeyCuWt387QLmP/+fVzXJz3+bKwb1w7Q435zpArMhnO4+r/OpfdWmiXN8QjHcezVXOZ6zPL65Q/RsFdCGuPzS0kyvCxSha2z07+rNRfIfYbBbQjdvjuBCAJ+SVKMe0BhnoNcEq290q9zy/xPvzaX5+jceAmP1dWpYsXLNDjQdWWfUaTGYczytWArpxPe7d3z/fa1mXYcHqVBW3YnSLYzu8LWBE5+HDNY8oFrvvAefyFe3jzcGvM+LNEy245t9f10GeWmcf78M3cgghhBBCCCGEkLqFIjqpFXBV7nK5equcpFZxEFpIzyspl+s6N1ZuUh2fsXF/hnKB9kmMccsurkmcBCHVAUJ2VmGp5BWVy9Sr26lim//ZeUwV1YSIijciJgxqLfcv3aryrH/JKlIOZqy/7+q2qtAjBGHkijvEIZ/vOibbD2XL3UPaSrPoECVwpmUWqGKTC9akerxtgeWFpWWWESLenh2s/8N1HeSvn+5xy2m3w1h4c/Lg1jJt+TY1QdA8xruTOS4iWD7+/RApKq1w5ZYbRVu73PP5o7t65L0bCQsK8HmMD+8fIoWl5arop5XjH/dpzsgucsSiBoOvcWfKkDZSHXT7vU1QTL2qnRqz9PcHYd/K3T/Ei4MfjvLHRyepKBpjjjomFuzqS/CNHEIIIYQQQgghpO6hiE5qBQQdOEkhGMJd7kvsRsZvo8gQWWpy3EJgnHljJ7n5xY21ipMgxBvIOS8oKZe5q1LcBFIIs9OubqeKON63/HsluDpt3MYdm0TKEx+6O5QhlM4f1VUVIW3YoIlaFh0aJI+sSLZ8G2PhmlR5Ykw31zJjRIxR+LaivNLpOqYvJzRiWyBqN4kMUdcDFztIPpRj7/JuHy9hgX7i7+8nreOrJgSqm3s+d1WqPDayi6RlFbny3HWOOPLZA/0d1ThGijx9Sw/p2zLGOqs+r0Rl1bdv1MCj7b7uHdpipkoAj/MQzH0dCwVa8b0B/F45dZDMt5gwQUa7N8EbxVBf/+aAW6wLiqV6g2/kEEIIIYQQQgghdQtFdFJrYsICVZQFhDvEVngjIsRfJr++VQlkcHQG+vtJWUWlcvGmZRSpOAyjGGUVJ0FITUjLKJAN+07K2uSjthEdw7sluIpq6jgUo0vcLmoFYvCcVSlqAim/uFwtKyitsHUTQ0gvLKvwiBDB8VvEeneJQxTX+CpyuudYnoqT+XTXMeWkh1j88LBOcts/N9m7vEd0kTFLvlZtwnOH6CXEv+QUVcW2VFY6bXPPsfzR4Z1lXWq6Ry2EOSO6Kvd/62pkp2OiA1EniC4xHke3Z/7qVElqGuWxr69JBbTfjJ0Ajngpb+D+aMd6n8RoCfJ3qIlETFbkosiyU9R32SwmzGNfcxTOol93k3kfpMqnO49X6zr4Rg650Ni9e/c52fZ8n4MQQgghhBBCNBTRSa2BwH1lh4Yq8xxCHIQziIVmsByF+CBAIad5cLt4aRgRJPtPFsi+EwUe7tPW8eESFugvCSymR2oJokNmrkhWfcpO2NaiOSKGNOh/Rpe4r6iVyYPbuATO3FNiuh15xeVuhSXxPOhj2z07cIlHGCJRdNsguZqd9YhWwrOEeKQ+rWLUcmwz4dSzZ+XyTj6cI0Wl5SpzW7vI1+89IcfzS1wFOSHKWwn7OBbuT3ZBmTz4q47SvXm0vPTfqngcXAveUkF0SdW98e6kziwoleAAhzwxJklNRuBeRoYGSExYkPp+kGX/1Z4THhMIviYVHFC4TaBw7EepR9UECKJyMFkAissqvB4L7nr1nbSLl9kjOkt6XrE0iwpVEwUNI4I9InA0hzILPYrB6skB5PJnF5ZJbFiQ+q6tJhr4Rg65kCjOzRRUAL7ttttqvG9ZWWm9OQchhBBCCCGEmKGITs4IZPxC4HpiTapyniK2wigGQhxcOKab/HQiX4lxyKaODQ+U4c9vUO7zeSO6qu2MQuWbdw+QksAKaSnhdXJN5MIX0LMKSquVIR4eHKDEZJ3rjX8bBeeIYO9DZHiQv0vgjPTxNgbWa7e1Mcpj99FcJajOXpnitly/jYG2afFdt+2tewao4qHGXG0sx3rkdE8Y1Mrj/EbRHuC4EOSf+Xi3hyCP51LnxZvR+8GhbzweXO9YrtuB+4/24dn3dR+rJiCc8tS63W7jB64b9wzjzI1JTWRA61i3aB5MKmBc8ROHWz65nlRQ9nADEKrnjewqT364QxUc1ZMSr339s3yflm3p1sd1zRnZVbILS2VgmziVi37nK5vl9n6JcnmbOAkK8JPwqtQaDw5nFcqM97dbFgydtSJZTV60OxVT85RF3+AbOeRCo6woX8TplF6/mS0NW7av1j7pOzbL9vdfkPLyinpzDkIIIYQQQggxQxGdnDFwma5NOSabD2QpwWfW8C6SU1gmERAVnU4pKi1TkS+FJRUqX7q0rErYgrC0cM0OWTN9sOSXlMt9y75XBR0R/RIWyK5Jag5iMyCy/u+vOipxNTwoQJZOuEy5iCGYmkVhxIgs+eKArJo2SO0LJ/Zbdw+Q8GB/CfBzSGigv9fCmRWVp0XamPAgr29jYD1c1RBOEe2BnGtjEU+75cAovqMth7KKZOqy790c4SiIqvPIkaPuKwPcLqpGP5dv3zNQPt6RrtzqRoe2bcTNvgxBqriOxwEHMgol5UiOEsDtnNY4NsTuf2342ePe4XqRpb74jl6ue3Fj96aqCCwEesSn7DqSq5z3mDgwTiq8ufmgPHBdB9UPjPnq4YF+KobqrgGtJCosUEVLTb+m/anomkp5fEySlFc4Vd8IDvRXsVPKrf/ZXnWNdpMIRsFf98WDGYXVLhiK/bz1AUIuJCIaNZeYFtUTuPOOpdXbcxBCCCGEEEKIhkolOWPX7+GsIvVviD+TX/9Wpl3TTsW2bDvl7DQLbkbHKtyjP58sUNu8MbmfPP/pXikoqZBEi1xhQnxxIr9ExvVPVE5js7va6JLWsRwQiL87mCUn80rkhS/2eewDcfW1iZfJhH9t9RDSsf6b/RlKGIfQid9wlMNhbH4bA8ux3pyNHR9+WiTFbzvB1CywQiy3E3PRrlHdm7rE/7e2pMk79w6UOStT3NoFF7VdVI1ys+cVq+d4yuA20r15lPg5HEoE9xVxg7gYTbOYEPm/TQdcju9K5+kiqUbHeHRooIfI72rL3pNK/Nb3BxFSekIBIvOyKQNk1Y+p8tyne93u+dyRXWXcy5vUPTPy2YNXyrWdGqkcc2StW33nnZs0kJwAP3l0RbJaDyF+vY9JBLQH7cL3hHbivNmnomKqWzDUWx8ghBBCCCGEEEJI3UERndQaCIJwiU643D06Qgtmw7sVu8Qmo2MWrlB8htg0/c1t6jPEPYh8i8Z2kyB/PwpJpFYTOhCNl1o4mo0uagjAEEunXt1OthyoKh66+IuqwqJW+4zo3lRmD+8ss1akWGaQX9WhoXoWlAAaGihzR3RVOdtws8PJjsiYRpEhqn14XoxubLN72RtGgRWxSMvvHiAZ+SUqlx353tppX+UkT3Vd6//+qoM8vmaH9G0VKzOGdVL1CYDRrW4Fnkt9D/q1jpUFo7qqOgZhhox2u/30ZFnyoRzXMYyZ7KBZdKisST6qli8df5nXY+rccqsJBRT4/PPNPZQojlgYFDnGvZ782lYVuaLHHO3SzykqlbLKSnlijftEC9Bt/dPYbipTX3/W1wS8TSIY3eWYKGHBUEIIIYQQQggh5OKAIjqpNRCLIAj2aBHtFvegc5vfmNRPCY/2GcrxanmAoypQGMJnfmmFdE5gFjqp3YTOjBs6WcapAPRPrIcIiriPya9vVWIs8OWshjhujAUxZpBD4H3onR9Vcd1HV6ZYiuS6feY4E7N7uTpYifFmp70qKDqotTp/75YxMnNFinRuGiV/+miX6zm1KhhqRAvA2P6+q9pJWHCAvP7NARlvmjSz2m/QqRzxMUu+ts1kX/fAENfnsGB/r8fEGOLLsa0nIn46nq8m57y59A9lF9k6378+NQ4ZJ1WMYrhRUPfmLo8MCZTPdh23LVYKt3xIoHeRnRBCCCGEEEIIIfUD/g+e1Bo4LQEcsHDlQhQ3CmZ5qligtwzlk6qgX4XTaRtvQEhNJnTssss1yBJH5BCEVWwLQdSXKIr1EMqxH3LIjfvDbQ1BvWNCpHIu24nk2YVllnngehtz5IgddmI8ni08Y3jWNBD+Ic7re4LJA+MziHZX5ZF7gutq1CBERTNBwA4O9FNxNJgQQLSK7X7t46Vhg2DljEdMk7fvA+sg8mvsjonl4T7c70YQ8YIcfLwFgMKy+Le+Du3SD/S3qQRqMw4Z71V13eVoB4rG/nFoJyWYm68JkxyPfZCqvlMN/o1JAMTooCCrcR0hhBBCCCGEEELqDjrRSa2B09LoPEdxxuKyqqKHCZHBEnJK+PIWfwDX8JQhbVyfGW9AajuhA5E0MtT7kGYWQH0JonqbRpHBHo5io9saYrW3iI+C0qoJJTuqO3mkJwuqk0cec8qtHRlSJcSaJwt07JLe13hd4we1ltte2ii9EqNlybjeEhcepMRd3Oe+LWNkUNs4WbBmh3y687hrPwjiyH5HzvgnO4/7dLpD5NcFU7/YfVymXd3Osi0PXNteQoL8Xec3Z8mbKSitkCWfVxUBtXLqf5eWLQ0jgr22zTwOGe+VFtSt3OW4BxDPNQ8N7SjllZXSMzFGTTRavcmg41/ONO6HEEIIIYQQQggh5w6K6KTWQCyCyAORULl6SyslI79UAv39pLi8UnYezVJiky+nry6S2DsxWglrhNRmQgcu7G0Hs2wFTu0a1ww69blpVIhyUFuJ09gGGeJ+DpHLWsUqkVoLocgl/yjlqOr7pRXe+7gvh3x1J4/02x926GfNKObq59Q8YaAnv3ROeURwgOSXlLsJvCgOjMgR1CswitJaMJ91Y2eVRY724zwQg+ePTpKS8u3VEpuxPSYgMgpKXfnzxnucWVAqTSJDVFyOlbgcHuTvVqgV16CEaC+Z+ABOb9t+0j5ejUNwj+toIOO9wgTC6B5NZcFqZKq7t+mpm7p7COIv3NnbdoJFT6CczbgfQgghhBBCCCGEXIRxLkuWLJFWrVpJSEiI9O/fX7Zs2eJ1++zsbLnvvvskISFBgoODpUOHDvLhhx+et/aS00DUgZAF0UllFjuc0qZhuIpRaBAcKAvX7lTuS1/CeEWlU+YM7yxPjO1GxyWpFRBkL28T5+pz5mgQ7RqHoxigz84b2VX6JsbICVWc0z2OSO8z7er20iQqRJZtSpNhSU0kwM9PdhzNlWWbD6piof/8ar/q+81jvPdbPAM4pxVDTO7l6rz9YQeEZ6OYa3xOrWJYdE75a98cUIKwMaoG6KKrZlEa4u6sFcnKoQ6XddtGEa7z6cKfv+7VTBaMTvK4bqv2tWkYoX5uTGoireLC1cQGfl/RoaFHzrw+P0TnD1PS5dpnv5KxL3wj1/7lK+VW9+bUx1sx+PHWTxaOTlLXgPHIGMOCe/JDWpbENwiWz3cdlweuay9v3zNAPrx/sHzxv1eqa06IDvUQxH297QCXPb6bsxH3QwghhBBCCCGEkIvQif7222/Lgw8+KC+++KIS0J977jkZOnSo7N69Wxo1auSxfWlpqfzqV79S6959911p1qyZHDx4UKKjo+uk/aRKMENBxbLySuWofO6TPdKpaZRc36WxPHNLDwn085Oo0ABZNLabisSAwxTO8+/TspSgibiIjfszZHi3BAk6VWCUkJoCITYowM/DXW2Mz4C4+eJv+qi+CtE7HxEwwf5ybafGIuKUKUNay+9/1V7KKpxKGA/wcygX+n3Lv1fHLSqvUFnfP/6SLXOGd1GFSbEcedvJh3K8uq7hkr7v6nZS6XR6xJVgeW3e/jADsbp1XLgsHJPkUYgTzykE6oFt4mTOKndRWk0wjOjiVgQU4BhXdWjoNaZGR5GYMRb+XHxHL7UdxgejYx1O/qyCKhc5lkeoOJ5AJchrvIniWD7BVOQ0u6jMrf3oBxDN9bgTExYoOYVllv0kLNBf1WcoLC2XrQcy1WTgnBFdpayiQg5nF6v+kHIkRzLzS2XD3hOy6KNdbvceEwMipXI0p1ju6JeoRHqMc8mH7fsGlq/ZflS10RusFUEIIYQQQgghhFzCIvqzzz4rd999t0ycOFF9hpi+du1aWbp0qTzyyCMe22N5ZmamfPPNNxIYWOXIhIud1C3+DocUO53y0vr9Mq5/S1XgUAtvELL+NeEy+TD5iEdGMTKTi8sqlUgJse75z/bIrBu7SPPYsDq8GnKhggxwo7vazNCujWX8v6qEb/Q9uK6N/RGi529e3eIWvaJzvSGUQ+gMDwqQ3okx8t3BTPnH//SWW/+5SS2f/uY223xxuLELSspl0mtbLcV9LF89bXC14jq0qxwRH0YhHY7p8Ze3khGLN7gKdpqztPXxb0xKUOKzsQ1HsorcrhvPLa4HBVXPVNw1XhcEc8yVQex+dEWyikvRYjcE/qC8EokKCZTGkcFqvywfhTXNUVHa9a3bbxyLAN42WDCmq1pv7CfG7c3fH7Lag/z91DiFdv79872eRZJPOeNv7JYgM99Pdtt/yuA20r15lPpsPjb6HMR8uNi9wVoRhBBCCCGEEELIJSqiw1X+3XffycyZM13L/Pz85LrrrpONGzda7vPBBx/IwIEDVZzLqlWrpGHDhjJu3DiZMWOG+Pu7Oy81JSUl6keTm5t7Dq7m0gbO0qKsCunSNMpDhLITnfAZclefVrFKzILrs0OTSJm5Ilk5V5n/S2r6HPtyaZ/MO72/GWNmtlF0La90WoqxEECRkf7BtEGSZeNs1gJ1blGpVDjtxf2aOo11XArc3RC5Ucz3m/0Zrhxzc5Y26hNUOb7LpUFIgHrGzGCSwOiWxnXgmo2FSmsr7poLZuJcyCTHuezEbp25XuYja94claJz2PHGgHksAoismbsyRcVHzVyR4lqur9dqnAJ4U0a72u2+QytnvN6/X+tY1V+QIX8wo9CjuGhNipUSQgghhBBCCCHkEhLRT548KRUVFdK4MaIUToPPu3adfk3eyP79++Xzzz+XO++8U+Wg79u3T6ZOnSplZWUyb948y30WLVok8+fPPyfXQE5TVFphKTB5FZ32ZcjEwW2UeITCjIPbxctzn+61jYggly7VeY7RZxCp8eWeE9KowenooPScIkmICpX/23RACbbLNx90KzCqgYBpFo0TokLkqXW7LMXV+atT5fEx3STWhwN+bM9mPq+vpk5jHZeCuJNf/+Mby20gpKfnFsuCNTtc7UeRSysQrYR74ycOJTTr5xZi9JmIu1YFM41jgp14jbY/tjpVZgzrJMun9FfOdWMMFO41XOXm7xHrlt89QDn/vY07jw7v4nZd3sYp3S8aR4b4LJJstR77Tx7cRkX5pOcUy9Rl39vff4fDo4CqMT+eEEIIIYQQQgghl2CcS02prKxUeegvvfSScp736dNHDh8+LE8//bStiA6nO3LXjQ7WFi1anMdWX9wol+m722XCoKp4CDO+RKfwIH+ZOayTnMwrVQX2APN/SW2fY6eIfLj9qBKCNUMQmzG4tWzanyml5ZXy8A2d5PaXNlmex9hf1eROeaWlgKzF2ILScmkWHWrrgNdCM9zgcMNb5XufidMY8SjeOJRV5NZ+OKCtssIhTsO5/uY9A6S0rFLyS8rdxF1gPM6QU07xjIJS2X+yQGWZRwQHKPEa7nh8jg8PUhNi+pr1eRs2CFZiPs6L69bFXo1g29v7JcqCD1I9YqD0RMgjwzp75Lir7PrSclWs2BvZhWVqggDiNs7lqxqD7he+ioTarQ/wd6gitHbOfv0mw7v3DpTZwx1qUtKYH08IIYQQQgghhJBLVESPj49XQvixY8fcluNzkyZNLPdJSEhQWejG6JbOnTtLenq6iocJCvIUG4KDg9UPOfvAZfrV7hNKQA/095MmkSEqqkE7RasjOqGwI/ZFQb/IkKruyPxfUpvnWLme393uJqADiLCVhqiWSfmlbvnfbuc51V+RMT5hUGs5kW8fAQNwHLuccojjf76pu9pmw76T8vANHVXch8PhcDmq+7aMsXUa43ogQkMo16K0ebvIGj4rKIyJnPfFX+zziKdB9MuHyUflr5/sVe5vfX1WMTVt4sOVU/zTncddx9D3TEeU4Prvv7a9j4zyKlHcGEXjK14Fbvk/3tBRTZn0aRnjUSQVNRoCg7yPO+Eh/qodOlrGV2yN7hcohgoHvLmP6XNbveEAGkYEq7Ybnf3myYzosEBVlPStLWmqKDPFc0IIIYQQQgghpP5QZyI6BG84yT/77DMZM2aMy2mOz9OmTbPcZ9CgQbJ8+XK1HfLTwZ49e5S4biWgk3NLZmGprEk+4iZ0DTaJYhCVvIlOH6ceU2IW9nt8TJJc17kR839JrUB0iVU/A+ijdw9uo0TThg2CXE5oczxIbHiQLJ1wmTSPCZWj2cUqzsUbUaGBHjnleJNCu4jBzvQ8WfnDYfn6XYOTu12cfHDfICWON4oM8ZkjrvZpHy8LRydJTFigS2D1mgNvEXfidIq88MU+W3G6T6sY9RkZ63gmUfjTHFOD8w3rluAmoANs6zRMVqBN917Z1qsobp7gqF4M1El5xNFJGjcIkcdHJ8m+E/kucR+TBNHhQfLtgUzbGBrcF9wHTCbAFa9ja/CdGF3vGhzneG6JXNY6Rh1/4uBWUilOt2Pjnky9up0qEmu1P3Lrjc7+0AB/ub1/omXWPoqNwuFPEZ0QQgghhBBCCKk/1GmcC+IZxo8fL3379pV+/frJc889JwUFBTJx4kS1/q677pJmzZqpPGTwu9/9ThYvXiwPPPCATJ8+Xfbu3StPPvmk3H///XV5GZckcMmiQJ9ZpIKQBn57ZRspq3BK38QYGdOzmcqPNjtGIRZBbNf7zVmVKovGdqN4RGrVHxFdYgdcvwnRIbJtQ5aHaKnjQcb1byl3vrJZicYQWCe//q38cWgHJV5/dzDLIwIFrmTkgPx0It/lEjf33YMnC+R5i8K6EGvnrU6VJ8d082jridxiKS6tkJnDOsu0qyHIB6gJgoff3S6PrkyWEd2bypUdGirh3s4Fj+uaP7qrjHh+g9s9uKZTI+nWLEru6N/SYxIB4jTeKjGKvY5TGelGsXjB6CS58e/rbWNh8MxrIMbj/lUnc7wmMVCI0dH3+vVvDriuHZMkC1anyvdp2dYxNO3iZOGYJFmwJlU+33XClRGP6108Dtu7Xy/u47Sr2ysRvKS8Qrn0cd0Y3x69sfOptlSot2hw/Ze3jXObXNDjXE5hmZuzf+V9g2Th6lTbQqaPjezq9foJIYQQQgghhBByCYnot912m5w4cULmzp2rIll69uwp69atcxUbTUtLcznOATKQP/74Y/nDH/4g3bt3VwI7BPUZM2bU4VVcmqisY5usaAhYENrmrUpR4hQEpz8O7ajiLIpLK1U8BRyy5ggHiOy+xDNC7PqjNyD2Pm4osOnmwHY4ZPbwzirbe/G43nIsp7gqq3vCZZJ8OFvuGdJGAq9yyPOmCBQ4mhtHBsu05dtULAvEbAjbZrHXLlMdy7HeSHp2keSXlsu8D9wFVrjCUTBz3Mub5N4hoXIoq1A9R3lF5RIR4q/e4sCzk1VYppzweL7SMgqld2K0mqDScSpPr9tlmTGun0X9/Gmxd9mU/q56BxCJ2zcMl+OnIm6s4llwvJHdE9T5cAw8/6unD5YDJwukJmiHvx068sk8iWAU6+1iaP726W4loIOwQH8lvGM/TPohL/9hh1MKSyokNMhfXcfa5KMqz/zV8Ze5zj+wTZz8+EuONIqsKmCbV1yuCtgivmbK4Nbi7+8nuUWnxzm0Qzvjq+4zJi3s+0V5pVN+/CVLIkKsY3wIIYQQQgghhBByiRUWRXSLXXzLl19+6bFs4MCBsmmTdVFAcv7wVtAQghEE9O9OuUEhtMHBCeD8nLrse9t9WVSU1AY9MWMX4QHR0zYeZO9J5WL/3f/7/rQ4HlUljvdKjJZrOjaWP6/baeEmP6liPXQUCYRcRLoYBU+4lL1hnESCm/5AZqGlcx1COBzWyMpuERcqG3/KkMZRoRLg51Bib3ZRmQT6OyQhMlimLvtOTSpgIgDCO/brmRhjmzEO9DUYaxigbZkFpcqRr0X4WSuSVe65t8zyx9fsdB0Px0DRzsTYMJ+iOdz/WuyG81vHyZjBcqPIjomLp2/pIVkFpaqoqbH95u8c52gWG67+jWtC9Asy0a0iVf7535+kS9Mo1zpklq+cernEhgXJkZxijygr7Nc6Ply2HMiUpKZR6r5ptLMfEzbob1kF3sc5XEt8g2BZs/2IpBzKkfmjkzwmaADehsC2ucXlEhkaIJ2aRHo9LiGEEEIIIYQQQi5QEZ1cmHgraKjdoHB4moU2X4VGw4PZJUnt+qMWKq0iPIJ89DvjGxBmcRwTO95cwzqKBE5oiNcQ0bW4CaHWG0YxGPuGB/tbFp3UUSmIpElXAu5RDwEXwu9bmw/KG5P6yc0vblTH+3RnunoOI0ODfMapmAtjGj8bRfMeiTHeJyUMsTCIf4kLr5pU8JbdvudYnsxakeJa9qvOjeSJsd3k0RXJbkI6BHQsNwrKxvx4iOS+wD3V1/T0x7ssJwIg/MOVfvtLm1znRV5+48iQqoieLzwnOvTnuSO6qDx9jf4uIaDff017mXFDJ/VvbxSXV6oIrOHdEuS2folqUtJcbDQto0Bmrkh2a8eBPw33ef2EEEIIIYQQQgipOVQsSa3wVtBQY5WD7M0tXB2xkxC7/ohIFWOEByZkCkrKVZ9D3IY3zJM7RnEcLu/qCvAQ3I3iJgRs2/7ePl4VFv3peL7kl5RJcKC/Ku75j//pLS1iwmT7oWyZbog8uqZTQ7m1T3PBke7s31ImD27jyjTXx0eBzEUf7ZI5I7rIzPeTpWPjSLn9pc2u7G9vGGsUmGsWGJ9lnG9w23if9wTjw1M3dXcJv4hdMRdLVecZ3EqSD+coARyTChCrMWmAezJ7eBdVrBTfY0RIgJosMQrocO8bj1lVyNi+QCjWd0mocmt7y2mHcD/pVETQorFJ0rtljBLr80vKpaSswmtET2lFpXK4o0jyNz9lWMbePDk2yWvBZXyvuhjukZwi+e2VbWXPsXxpEBogMafup1lAJ4QQQgghhBBCyLmDIjqpFXYFDSEMNYupErms8s3t3MIQjqZe3V4qKiGZEVL7/qjFSgjYP6RlKUHUm5htdmBrdP/19faEcX1YUICbuGnrjlcFOrvKziO54nA4JCosUJ5Ys8M2rxyg8KlZODVuo4V/XD/c0J89eKVkFJRW6xog2gf4O2T5lP4qHgZ1Dcw1CzRYVljmPaYG2ePmaJvwIH9VjDO7sEw57vGkf7H7uIrN0ef54L7LVUTNjHd/dLsXEMbnjeyqcseLyipcOeGqNoNh/MH9Xjl1kMxf454pb5wUePmuKre6r/oLEcH+snb6YJm7KlVmGlzyb98zwOt+BSUVKpIHRZK//inDMvbm8bU7T7nmne7X2T5exl/eSrVTF8N9ecN+N5c+xthZwztTQCeEEEIIIYQQQs4jFNFJrYEjFEIZhCyIdaFBfhIc4C/Jh6rcoFbCnS5YCLfwI8M6yS+ZRWo7iJiTX98qfVrGyGKT+EZITfsjHOFwed/et4XK8fY2eWN0XBuBG/q0u9neNawFeDivkUtuPL6xv0PgRpsiQwLk+4PZMvzvG9R6CPzI5faWVw6qk2muhWE4t5GDLsfzXddgN4mAdqNAqvGZiw4LUk5tnbUdEuDnKhYK4JT2dryEqBC34xkjV8z33gjuDyJczE5yfJ63OlU57XGdEJsfG9VVMgvdC8qifR+lHlUxKMaCorrAJwqtJsaEqjb6mliA43vuB6ke37u/n/coFkwC6AKiA9vEysI1Ozy2wTpkpr91zwCZmF+q2gIHfqXTKSfzStX3ib5kVQwX7ckpZO0IQgghhBBCCCHkfEIRnZwREMqUWHY8X3Yfy5MWsaEyZ1WqEiyRC20ltEFAgmgIzHEK6w250oTUuj8a0MJ6QUmZPDmmm4rbgMgcEuQv2w5mWTqukYHtdFa9FbHjSI7879COKifdToDX0SWI3jBjLHD5zr0DlQvZKCZ7ixUxxspUZxstDDc4VbNAxy7ZTSKYI1fsBG91jAmXyaTXtqrrqcnxzJErxnYbJwCwL7LAUZAYEwvmPHicU18njjV3VYr84boOHvfjn1/tV21bapp0gPAOd3jz2DDVJ+CIxzJzu/R1BPn7Wa7bsO+k7aQKlmM92H+yQN7ckuZ6U8Dcx5Sjv6RCmkeHysI1EOvd+9ZjI7uqa7EiPMR71j4hhBBCCCGEEELOLhTRyVkBYt2x3EAlTGn37W+vbCPzRnT1EIjgUh9v4/4FcBETci6FdbA7PVcaRoZIr8RoD3F8wqDW4u9wKDH1nivaypTXt8rt/RKViAsRvmFEsHJml5ZXyuppg1X/ByVlviJCAjyEWV+xIr7WA+S/I2c75UiOEoYRyWKOuTE64kHzmFBpEhlSLcEbkU2YUtBZ6/oZx2dExxSVVijhHvfBfK/NkStWEwBafD+cXWSZIa5ja8oNcU/Yd8YNfh4Tdca2QYjGhIm5bbpPPGURSaXbcjzvdHFQIy/9d78sHtdLUH3UeF1DTuW7I55GT2hgPdzleqLATHRYoMf4qK9tweodtvsdzy1REz3GoquEEEIIIYQQQgg5d1BEJ2cFCFItYkJV/IMWsv76yV7lpIQQBFESYiCc6jD43v7SJsu8ZaOLlpBzCcRVo7Bsjv54fVI/5VhGP0UxSqOYqYXWBEORSxQI/WZ/hpfCufHisEgCqUnmurdr+Sg5XTm4uzeLlrkrU2TOyC7SMi7cI+bGTuz2JXgr9/eprHVfxzGS62NSDMVEdX56cVmF/PXTPbaxNTNu6OS2/GhOsSsSxrgPisxe1aGh2/djhbd7Yzc+qQie5dvk4weGyC9ZRarwrO43Ot/dGPNjfFPACPpQaKC/ZRFUAKf7hEGtLNdhogNvNcxZmUIhnRBCCCGEEEIIOQ9QRCdnjXKnU7Yfcs9eNkZZYDkyjYHZ/WsUlrSrl5BzSVRolVBqF5MSe8qtHBV2OhLGm3gMsdhb9vrsEZ2VK9mMt7xyoxhr5zzW21TFizilT6tY+XTXcSkur5A//bq7ii+xc+PXVPB2Za3XgEgfk2IxhraVVbhH5hjBcjj/zfnj009NhKBoKdZXV9zX2N0bHYVjdKkDvIEAl3tJRaU0jgyRf3z1k2XWu92bNtVxu/uiY5MG8lHKUXWeWcO7qIz0CEa8EEIIIYQQQggh5wyK6OSsASfvsbwSVTAUcQMOh8OVZQzR3CgsWQmNcOouHJPEPHRyTkBUCYRwCMUoYNkgJEAW/bqbNGoQ7JG9DSezcTKnOiI0xGJzIVGju/1odrG0jg/3EGa18A6TulEkRyzLglFd5UR+iYqBualXs6pCl14EW7ia8daHnDpWWmahus7qPlO+BO/avCViJ0ZbTZoVlFa9yWIH7oVRyE6ICpVXx1+mrhH3KLFp+Bn1ifhw98gXHYWj247zIht+yef7VKwNPqsiyTd0koOZhW5vMhid7C1iwiwd/HZud02jyGCP/PWq2JjWyvWOcVUXWwUH/jS8RtdPCCGEEEIIIYSQ6kERnZwVDmcWip84ZOuBTHnu071ugs+a6YNl9fYjLqEPopOfwyG/vaKtzBzWWfz9HJJdWCrxEcHy1Ec75dHhXaRZTFgdXg25kLESRiFWPmzI+ob4+a8Jl8mH2494FHSESNrqlHu7tmKx2d2O4zaLDlWip1mYRdve2pImT47tpkR3neENl/Wwv69X20BkX775oPxxaEf1cyiryFawNWaoI2qkJoV6ayJ4VxcrMdquCKkvER/FPpWQPf4yWfLFXiVkayA2LxjT1fUGgS/sCqiirYh5sYp7gWt+9soUl6htfJPhh7Qs2zcFvkvLkis7NJS2jSKqfb+xnzgdMqxbExXroidkULDZIQ65vG2cTBnSRhV7JYQQQgghhBBCyLmFIjo5K6Llf/eekA+Tj3pEMUCgnLcqRYZ1S1CfrYoG6kKjL3+0U7o0jZKDGYXKVUpHOqkpdsLo1KvbyXcHs1zLMJHz98/3WmZvo6AohNPaisXm80MMnX5Ne0mIDJEDGQVKKMZ2EPnzisolLNhfwoP8VTa4sc//+EuWaieyvXOKyuR/BrSSzPxSadggWKYu+75aGer4d00K9dZE8K4J1c1l9yYqQySPDQ+SFVMvl8fX7PDIEoewjSz4UT2byaB28S4h3ApvBVRx7TqjXd8T/W/k3htd4R5vEzgctm8KfNQyxu24vvrMw0M7yV8/3S2f7zrheS/ax8szt/SQkAA/VdhW31NCCCGEEEIIIYScGyiikzMGwlijyBCXqKUjDnq1iHbFZLSMDZP5o7oqAd1KaId3FrEE2Kem7llCfAmjFU6n6pN68gb9zC4LHdvXtv9BuF18Ry85nleihG88Cyge+e3BLJdjeMm43hIW5Cc/nShQmdqIKMEzciw3060YJjLbt6VlubXzL7d0l6M5RV6Kl57OUNdZ6WN7NqvxNVS3EGlNqE4kjp2Ij2sZP6iV3PnKZnn7twO8FOPMkIeHdVITdxCZ7c7nrYCqt+/fLjNex/ismjZI0jIKPYrUYr3dcXG/Hx+dJPtO5Lvtl1VQ6iGgG8dWRPVgUgHfjdnhTgghhBBCCCGEkLMLRXRyxkBY0hESEHks3ebt45WIPu+DVMtjQBA0ZkjXxD1LiC9hVPcvq8gTK86k/xnFYgj7097c5mrXtGvayYm8YmkRGyZrTW9uQChGZnpZeaWcLChRbcTE0ra0bCXC4tnq0KSB3PbPTbbFS+eM7CpjlnytXNsQnd/ekibxg1uf0TWcb4wiflZhqZqMMIrR+cXec8RRj6FjQqTXiRBfBVTtvn9vcTNoW0Z+qUx+/VvbbXA9mBgx569HhwXK698ccJs4eOHO3m77ehtbHxvVVWXqt2lIMZ0QQgghhBBCCKkXInpRUZF89913EhsbK126dHFbV1xcLP/+97/lrrvuOpttJPUcCEuZBaXq33BJWrrN956UeatS3dzAZiAaxoQFytc/ZdTYPUsuXXQGesapPmiHUTg3Rp5YcbaiMczCPhzEiGN5at0uyygZMOOGTvLrf2x0CeMQTnWxUgjE3oqXwr0MARoO5Re+2CcLRl+YhXq1iI/vdvqb29zE5YgQf5/74z57mwipbQFVc9yM0Rmu2h0aqCZKEO9iVTQUEwJaZDfmr5sd+DhP+8YRsnr6IDVpgMKplU6nPPfpHsuxde6qFDXh8tD1HX3eG0IIIYQQQgghhJxjEX3Pnj1y/fXXS1pamsp+HTx4sLz11luSkFCVd52TkyMTJ06kiH6JAcEHkRTLpvRXYo+dSI4sYRTIsyM6NFASokJk99HcWrlnyaXH0ewiefyTnUpIfHV8X6/bGoVzCM52kSi1LaBZHcezFvKtzmu1XH82CrXmgpZGsA1E2nUPDPEaZ3KhYBXvgokEOO2tssnxnSYfzlFFPIMD/WXLz5kSGRqgCoIiOudMC6gaM8yRsW/lDB98auIDbb69X6Ir1goThOHBAerYmFzBuXEcfE9om3bgY0ISf18fXZns1h/02wWb9md6CPTmNy0IIYQQQgghhBBShyL6jBkzJCkpSb799lvJzs6W3//+9zJo0CD58ssvJTEx8Sw3jVwowF255PO9Ko/YHEFQXSA8NYsJlWM5xRese5acf+Z+kCqbDxX5FMYReYGccg2cwksnXCZ+pkKQ5gKa2uUOMdwcwVEdjI5nuJabx4RKcZn3KBk7gRRC7I6juT7z0HENmIy6WJ4hc0Y73N4LxnSV2StTPOJsJg9uLQ5xyLP/2e2Wm47x5cmx3dS+OE5+SZkaZ55Yu0NFvxiF7sTYMK/3DkVgb+yWoAp//nndTo/vYsO+DDVh88r4y+Tpj3d5COzLpgyQO1/Z5HpLAcVKKyudqn9gmZ+feAjoAJMGleKe7W/EV0QRIYcOHZKMDOsJPCt27959TttDCCGEEEIIIRetiP7NN9/Ip59+KvHx8epn9erVMnXqVBkyZIh88cUXEh4efu5aSuolx3KLZeaK04KPr5gMCOUQkiA0afD5ibHd5EhmoQQHBbgKKxLii40/ZYhfcJhLGLfKCoeoDME0u7BE1v1+iPg7HOLv55C48CBVBNSugOaR7CKPQqXGCA4jdmK7djyjsCja9ud1u2SiD8dwgB/Srd3RkS1216jz0J9et8ttEuBiwZzRfjy3WEZ0b+oRZwMXOtznVsL2rBXJMu2a9nL7S5vUMnw3b0zqJ4s+3OkmStt9xxrEBh3OLpKkZpG2BU47N42Sv3y8y7Idj69JVW/toLAsCsrCnf5LVqE8/9k+JZQjwsXbmwp2jnNfYy+5tIGA3qFjJykqLKjxvmVl3qOyCCGEEEIIIeRSIKCmeegBAad3wSvn//jHP2TatGly5ZVXyvLly89FG0k9BhnMRsHHqxu4XZxs/yVbeibGKCHRKH4tXLND7uyfKI1Cz04WNbn00Fnh91zRRv5wXQdxOkUahAbItoNZcuPf17sc3lok1aKsleAMUdwsoANEcCCmA87o6ort+P3VnhOuWgHo//bPSLwS4hFNg+cDIuv3aVkSFugv36ZlSe/EaMs8dLjsQ/z9LooIl+rQKDJEBrWNk0dXpLjFuiyf0l/++sley30gYM8Y1sn1GVErT3zo6STX3/HTt/SQ/OJyj4kR9CsUB+2SEGnbPjjb7WOtMuRQVpFMXfa96y2JqVe1le/SstRnX4VTrRzn6E8YR6/t3NjrvuTSBQ50COgD714oDRpX783B9B2bZfv7L0h5ufc+SQghhBBCCCGXAjUS0Tt16qSiXDp37uy2fPHixer3qFGjzm7rSL0nt7jc7bMvp+yYJV9bFtwDED7PVhY1uXRJahYlf/10jyq0CLHTTiQ1CuG+CoKa98d6XfjSl9gOZ3mvxGiZ+X6y12cEk0xzRnaRP320Uz7fdcLtTY2bejeTFnGhckvv5jJ7VYqHcxru80vtDY7EuHBZOKarcnTryYTySqfXfYwCtTehW33HeSXyUWq6q0go7vPjY7vJog93+Mwg9xWtYlyPvoOioZgYwbkaNgjymEQxFipF7QgjGFsxKYnJFRYWJb6AgB7Ton21ts07lnbO20MIIYQQQgghF6WIPnbsWHnzzTflN7/5jcc6COmVlZXy4osvns32kXpOZEiApRtYO2URVVBQUq5ckgcyCmwFdJCeW6wyowmpLpe3jZNNpzLRAfqddnyj/3kVSU8J4VZkFXqPL0D8iy+xHfnlWYVlKt/6zv4tbR3zEH4bBAdIaJC/fHsgUxWONDuo561KdYn+3iJoLjVQMPT1b1JdBUJ9FZeNCPGvttB9MLNQTcJgwgPfF87x6Ipk6dEiWj7ddcLrWzfIXveGOXoFx5g8uI30vCNa5n+Q6hYTg3PoNuBNhIiQAJfI3iI2VD5OPabWeRtbCSGEEEIIIYQQcmbUKER15syZ8uGHH9quf+GFF5SQTi4dYsKDlFPWCMQciJdLv/5ZNuw7KZNf/1Y5KVHs0BcQBwmpLvNHdVUOYaO7WIuavkRSLYSbgbu81Me+EK8Boj7sgDtcF4i0yqvWjnlkdA9/foNc85evZNWPR5RgiiKTVqI/gGDetlGEioXB70tVQAe4dsTl6D6ghW0rME4dzy2pdoZ4i9gw9TbD8s0H1eQMwIQJ+hjAmAYHuPl8iGdpEROqonms0NErZgL8HWoCyJyzjv6D5XOGd5a5I7vKpNe2qjEVcTAhAf4ytmczFWPz2YNXer0eQgghhBBCCCGE1B5WIiNnROPIEHl8TDcPIR1CEgQmCE0AIlTyoRxbgWvIKWHJTtgkxApEmMChDQFx5dTLVXZ1dUVSLYSbgVj9zf4M+77aPt4VOxRpcwzQKDLYJeibxV2jY95KMNWirRE+G9Y0NfSB6zs3ksfHJKnxxAjGp8dGJanoHQ2+E/N2GnxXH6emKyf6uP4tpW9ijGudnpzRbxRAaIcz/IU7e6uioHCqP/fpHnl8bJLqK+bjGsdFs6veW0HRpOZRMu7lTa7JFEwcNGoQ7DahQgghhBBCCCGEkHoQ50KIlWv36XW7lDD0yLDOUlRWISGBfioH+pmPd7siBuDenP7mNp956XBVElJTN7J2Y/90PL96RW7bx6s+CpHUWDRSu8u9ZfvD/a63hZgOMVPHiRgpKK5QjnII4r0TY2Rw23i57+p28s1PGeqzXdSMXd42opGI7z4Anrm1pyp6jJoNiJzCGzPOSqcqBqq/K3zHH9w3SOatTvX4jnXGuB6/jFnjxqgW/daN3g+Cuv6MtxkevbGzHM4uckWvpBzKsYxegcjv7/B+jb9kFrkJ6HjT4VJ+C4EQQgghhBBCCDmfUJUhZwREnbUp6eoH/PM3faRZdKj85tUtsmzKACUeIdMZv8156boYIMTOn08WSN+WMSwsSs4Io6htX8AzXu67qp0M+/t6l5iJfRALAlcz3OXe+qpVnAiKiBqFdBwvOjxQnR/OcqNgjvNf2aGh1+swR9FAoA3y54tDNXlDBj9mnjflyReUlMqMGzpJoL+fGoP0d2wUutF3HhnmcH2viTGhSvTGuGYlvGvWJKfLfde0V9Er4LUJl0nDyBBVZNYs2k8Y1Fr8/Lyr6K3jw9XbFpd6Dj4hhBBCCCGEEFIXUEQnZ4QxExqu26bRIUp8glB15yubZOmEy+RRfz8pP5WVb3RuGkGmL52V5EyB+Ayn+FwUZ9x70iWET72qnfj7OSTQ3yG70/Nk0utb3dzAEMAhhENkNQrx5r6K5XebolZ0nIgWZ+Fsh2u8sKRcXreIbFm/76T87qq2Xq/DGEWjBdqcIriQw8/wDl3amB3rB08WyKyVyfLbK9qqjHE7UCAW3z2iYpZ8uU/mjewqJ/JKxOFwSGFpuaQcyZGUwzmqH5RWVEqjBiGqr4UE+KlJE3znReUV8r///tFyYgb9dMXUyz3EeQ2WR2B8jQrhGEkIIYQQQgghhNQBFNHJGWHMhNa554g0ABAVUTTx7d8OkI9Tj3mN1kAhPuRbE1Jb0jIKZOaKZNmWli33XNFGHr6ho6uQ5Mb9GcqZ/spdfWXWihTL/XXxTmRL27nL7SZ6jOLskewieeidH2XC5a08ikRqkLmuxVWr56Fhg2CVsW0UWVdPG1zre0OsgeCNMWny4DZet0P2+NO39JBHVyRLp4RIeexUBAyy0HVMFd44eO7Tva59MN7dM6SNzB/dVeasSpGGEcG2k4gAovoTY7upcxiFdAjoC0Ynyf6ThWoyskVMmDSODKaYTkg9Zvfu3TXaPi4uTpo3b37O2kMIIYQQQgg5cyiikzNCu3a/PZgl13dprERIhBJowRyi0aGsIq8Z03NGdFEuYUJqy7HcYiWg674FMfOl/+5XEzsD28TJ1R0bqrz9Kje3Pbp4p3aXZxeWSUFpuRSUVkh0aKB628JXjQAUr4QL/o5+ibbb4XmA83jBmh2Wmesjnt/g5pTHM8aoo7NPfkm5+v19WpbtJB/ufUJkiBrbPt15XH2vWgjHBMfs4Z1ti8QCCOkjuiVIdFig7Tl00dmKSqf85VSee05R1VsNYYH+snBNqny664Rbm3T8ECGk/lCcmynicMhtt91Wo/1Cw8KlsOB0TQ9CCCGEEEJI/YMiOjkj4IaEO/dgZqEqMArn7brfD1HxEwCCEbKcvWVMl1VUSG6JU5rW9cWQCxaIjmZxUrt+8bPugSHKYW4sPGpFUICf/HQiXxUahXA+e1WKEsSrK15CaNXbGyNZzKBtR7OL1Vsb5ufhZH6Jh4DOqKNz+yaNbX6+4d7vP1ngkVeP/fCmjd3bDTjW3YPbqCz0Q5lFbuOiOa7naE6xNG4QLG0aRkhBSbnklZSrvvjpzmPSpWmU3NG/pTp3SKC/Ev3nrUqRZ27pwX5BSD2irChfxOmUXr+ZLQ1btq/WPnnH0mTjy3POedsIIYQQQgghZwZFdHLGwJ275PN9rugKmMqz8qsK9gEU7YMYBXHRHGWA5QF+DuUWRgwGnZWkJvz4S5Y0beTn6odG8dlIbnGV49iYd24GYuaHKemqjy76dTf5cPtRj7gVY3a6lXhprBEAQdyb8/jbtCzLaA+4lj978EpX8UsWkTx3GPuDeZIPbx5g4kUXKNWCu3FyRL9p443CsgoV7/PGpH5y19Ittpno6FP4vkF5pVO52yHAj+vf0qM4rUt4zy2W3cfyJTI0QGLCgiyLqRJCzj8RjZpLTIvqieiEEEIIIYSQCwOK6OSMOZ5XIt+lZcm0a9pJ78QYySksl+axofKfHceUUxMgO1icVUUV3bN+u8rwv2+Q67s28SpOEmLFna9sEb/gMDUZAycxxEgrIT0ypGqoQ9+yyjvXoiT21xnYxr4KsRWO5EaRwZJfXKFcw8XllS7REjEucKFD/EQxXTiF39qSps5l5W5GodPJr2/1aCeeiZhwiqHnC3N/0EK1dv8bvwctuJsnR/CmjTcglKNPbth3Uvq0jHETwzHxA1H95bv6qs+VTqfqS06nUx3/oes7yjP/2W0bFYP1t/5zo6vv/L8pA87avSGEEEIIIYQQQshpKKKTMwLu8cNZRa7Cema35PK7B0h2QalkF5XJQ0M7qrznX7KKpElUsBKfTuSWyCvj+0qgv0PlqkOIpIhOagrecoDwCEHS7O7WwrRG552jr2UVlrpiXCCMLx7XWwngKDhpFE+XTRkgC9ZUFZM0HnfR2G7icDhk5vvb3YqIDkHfnzJA0rIK5ZEbOktJeYVyqaMoJAT63KIy6Z0Y7VFA8smx3Sign0cgWBeXVcjsEV2UgF1YUiFRodbufy24I0bFGMvi7Y2Dazo1VL8xsRIe5C+/6tJYhiVly+Nrd6rlVuMmhPp5I7sqgT0owOEW+aOjXDA5ifM9Mux0LQljXyKEEEIIIYQQQshFKKIvWbJEnn76aUlPT5cePXrI888/L/369fO531tvvSV33HGHjB49WlauXHle2ko8iyj+cWhHeWrdLku3pEN2Sc/E0+7LIe3i5bHRXeWJtTvkc0OhPIiOi8f1koKS03EYhNQEiIi/u6qdmyAJYfrxMZ7CNARR/Px8Ml/mrkxxE8AhiA7t2tj1GY5ks4Cuzwd38YfJiH1xX4fP89ekKgEU7dECeWJcuOv8uoAkombglKcD/fxPAOoisObMe7uJPEzAIIc8o6BUHhvZVRUChQh/c+/mMndVitvbDdd1aiSzhneWOatS3N9EaBcnK6cOkqKyCnnmY89xE8d4bHWq3HNFGwny95dtptgf9E/91kVWIcdLQgghhBBCCCHkkhDR3377bXnwwQflxRdflP79+8tzzz0nQ4cOld27d0ujRo1s9ztw4IA89NBDMmTIkPPaXuJZRPGBa9tbujC10KhdmwARGY+tSpE+rWLdRPQqEdIhj49NOi9tJxcn/n4OWXv/IPETP3E6RHILy5QL/FhusSrWmFNUJpFwGqNwaEm5zF7pLnACfE4+lKPETvRLRLjY9e9GkSEeArrxOHAQ6+cA5zLGFUEwp2hetxOARgG9Opn3xgkYM8jRP5hRqN660bnpENa/tplg+cN1HWz7Dtr1v9d3lAWrPSdv9Ge8dVFe4azhlRNCCCGEEEIIIeSCFNGfffZZufvuu2XixInqM8T0tWvXytKlS+WRRx6x3KeiokLuvPNOmT9/vqxfv16ys7PPc6uJsYjiifwSr9shhsAIhKMZwzqrf3drFuUWU1Bq2paQmlBcWiH5JeUqIsMcvTLhVOY58qnhOJ47ootsS7MeOxC38cF9g2TBmh0qA726fdvbegi0jCuqXxOAVtTme4Io/8j7yW7HRB0Iu4gV9M3pV3sXwMvKK9VYqXPTe7WIdhsrB7WNk69/YoQLIYQQQgghhBBy0YvopaWl8t1338nMmTNdy/z8/OS6666TjRuriqVZsWDBAuVSnzx5shLRvVFSUqJ+NLm5uWep9SQyJLDahfXMwAX87YFMee7TvW4xBWN7NjsHLSUXOtV5jlGws8Lp9BDQAcRMSJY6Mx1C6fzVqZYZ6gBCe15JmXIkH8kprlHf9rY+79TEE6kfE4B2VOd70sVkcazQIH/p0SJavjuY5Sps62uCJSzY3+v64EA/JaDb1ZsY07OZKl5LLk0OHTokGRnVn0TB232EEEIIIYQQQi5QEf3kyZPKVd648en8YYDPu3btstxnw4YN8uqrr8oPP/xQrXMsWrRIOdbJ2QfF9+DoRWE9ZJ0jqsUMxB6sN1Ne6fRwaUL4RBbwYi9RCuTSxNdzDKf5E2OSpLCswjZ6xRivAuDyhTvdjojgQCWShgT6qeNbuYqP5xbXqO83ODXxROrHBKAdvr4nqzx1Y1Y5hHRfEyx6H6v+iuUAkzxWk0L4PP+DVLm9X6JLXNf7kEtDQO/QsZMUFRbUeN+ysqpiyoQQQgghhBBCLrA4l5qQl5cnv/nNb+Tll1+W+Pj4au0Dlzsy140O1hYtWpzDVl46QOhGEb55q1LkoRs6iqxzumX8IlN64uDWMm35Nrf9IDpu3G+fBczIC1Ld5/jZW3tIQsNYSYwJlRZx4aoIozd8uYONrvbyikpZm5Iuq7YdllfGXyYL16S6CekQ1vu1iZOE6FCpFKeb0AlBE7UAIKhqMOGEiSdSfyYAjYVAq/s92eWpG7PKIWwnH87xOsHyxe7jMv3qduInDrdtdN/B+oFt4mTphp9l2jXtPOJcsPzhYR2lS0KkEuytJivJxQkc6BDQB969UBo0TqzWPuk7Nsv291+Q8nL7eCpCCCGEEEIIIfVURIcQ7u/vL8eOHXNbjs9NmjTx2P6nn35SBUVHjhzpWlZZWSWKBQQEqNeV27Zt67ZPcHCw+iHnhqbRoTJ/VFcpKq+QG7slKGcvhB6IOsfzSiQ8yD2yAALR7BGdZewL39gek5EXxIzdc9wyLkwcAX5SWulU4qYvh7HZHYyioWY3MMTxh67vKDe9uFF6JUbLgtFJ8tWeYzJvVFcpq3BKfnGZOk9MeJA4K52ybNNB6ZUYo1zupRWVkhgTJtsP57gcyVqYfeqm7pwcqmcTgCgiahTSq/M9ectT1287IIald4toGdWjqcxbleomkmOCZt5I9KUKNdY9MqyTPCxOySosk5iwQFUsNLeoXG0b6O+wjXPB8iPZxTJ12feu5ei35NIBAnpMi/bV2jbvGKN/CCGEEEIIIeSCFdGDgoKkT58+8tlnn8mYMWNcojg+T5s2zWP7Tp06SXJystuy2bNnK4f63/72NzrM6wAIlyhut+qHw5ZxF3Cjr5h6ueQUlUtEcIA4HCKVTqdLXLSCkRekutz0j43iFxzmEkAX/bqbrcPYHK8CMXPX0TyXAI7Jn6jQQGkQEiAP/ftHlYfeKDJECkvKZVC7hpKWUagcyBBRcQ6IsJhEeuaWHmoZBFH0XbiYm8eESr9WsW7LKKDXL/Dd4Ts2f3fG78mYex4ZGijx4UGSX+J9kg9RVRC4X16/X75Ly1bO9AmDWql1zaJD5WhOkdz+0kZ1XPTJ+69pJ/ERIfKnr3YpEV4XEoULPS48WP722V7LOBcw44ZO5+TeEEIIIYQQQgghpJ7FuSCiYfz48dK3b1/p16+fPPfcc1JQUCATJ05U6++66y5p1qyZykQOCQmRpKQkt/2jo6PVb/Nycn7IKCiVTgkN5I/v2sSz7MtQzsq/fbbHJfwgmsAuY5qRF6S2QDh/7INUeXJsN5m1ItlNSEd/m2CIV9GOYwiWEDOzCkslp6hMxQzp+JYFa1I9HOrLpgyQO1/ZpI4NFzNEWIiuVgI5RfP6j913Z5d7jn6DNxPQb+wmAts2DFd55Trayuggx6TizBs7y9IJl8mk17aq/jW8W4LaRgvoRuf5u/cO9JrxX1rNeCJCCCGEEEIIIYRc4CL6bbfdJidOnJC5c+dKenq69OzZU9atW+cqNpqWliZ+fr4LtJHzD1ya4hQ5kVvidbv03GI3IQhZvhCKgFFIhzOYkRfkTPhk53ElUpodxqFB/urfr03sJ5GhARITFiSNI0PUPuhve47lKREd+dIjuzeVx00Cuu6ryEVHH538+rdKSGd+/8WJXe45vvO5q1JkzoguMvN997eiAJzl2YVlbrUhjKhitjnFSiTHRM24lzepfqi3NxcSPZHvfWxF/yOEEEIIIYQQQsglIKIDRLdYxbeAL7/80uu+r7322jlqFfGGdmlOHtRaGkbWLHMeDk44giEYzRjWSfKLK6SwtFw5OFGkkZAzIbeoTNo0jFDiNsRQTOLsPFogDofDVZCxb8sYVxwL+vLC1aedw6+O72srgkJIR5/VML//4sRb7jmE9EeHd/aIDYLLfM7IrpLpQ9hGbBD6kUN2qzHQWOwWxUONzvUgf+8TyC1iQr264gkhhBBCCCGEEHIRiejkwnVpPvirDpJ8KMejOKNRWDLmUGsg+kAsgvMXxR7h7F059fLzdAXkYkZn6h/KLJSZ7293E8Sv6dRQ3rpngBJJdx7NlfyScvnuYJbKrtagOKg3MOljPhe5uEAGujeKSitcbzsg0io0yE+Ng2OWfK2WG9EZ5xDIIZgnxoapSCtM5uisdI1RUAcYO+3GVixHAduP7h+i4ojYFy9cDh06JBkZ1hN3VqCIOiGEEEIIIYSQ8wtFdHJGLs0Af4c8vnanK57FKPYMaRcvc0Z2UcKSHdGhgfLN/qp9KAKRM0Vn6h/OKpQZ7293648QM8f1bylPrasq4GgUI9F/dV46ioJ6IyLE3+1c5OIj0sdYhLFK56kHnCyQWSuTZXd6nhLQW8aFqbFv/b6THhnn5j6HIqRwrmOyEZM9mFA0Yoy+MvfZiacy/ldPGyw9E2PO+j0g509A79CxkxQVFtR437IyxvkQQgghhBBCyPmCIjo5I5dmVkGZWzzLpEFV8QQhgf5KYCw+5dg0Rmno6AEITU2jQ9QyCpKkNiy5s7fszix3RbQgrxwczCj0cO+a86Y1+jPWA19vVhzPLXEVJmUe+sUJxiJzXIuxdgMmD/FGDr5/vLkAAR1FZ1GMdltathK+K8UpvRJjvPa5R2/sLCEBfjJxcGuptHCeG8fWqVe1kwqnU8rKK9V2WI71jBS6sIEDHQL6wLsXSoPGidXaJ33HZtn+/gtSXs4YH0IIIYQQQgg5X1BEJ2fk0oST0hjPArT70pvjt09ijMwf3VUJQL0So2Xq1e3UMaLC6uCCyAXLfcu+lyu7Jsra+wdL7Cln8E/H8yW7yFNYNOdNG0E/xQQQmP7mNlv374IxSaqYLiaGKKBfvOC7RWb+I+9tdxPS0QfGX95Khv1tvStXH/UcMKECAV33Fy18D0tq4rXPQRT/3bLv1Wds3zcxRkZ2T1Bv9+i3fTAubkvLkp4tol3CuRG+wXNxAAE9pkX7am2bdyztnLeHEEIIIYQQQog7FNHJGbk04S43u3a9OX79xCErpl4uH6Wky97j+dIiNky5NSe9tlWJUhQnSU1BbMaclSnyl1t7StSpNyXMsRhWedN2663erMDx4P7NKyqT7i0YnXEpgKKzGI+O55VIWmahWmZ0gGP8g8i+cHSS+Pk53MY7PanYtWmk13McyipyieLGSci10wfLkZxiySkqk0YNgmXPsTxLAZ1v8BBCCCGEEEIIIecHiujkjFyaVpm9RsevuageYl7w+6X/7lcCVUZ+iWtbiFLIW6eITmrKhn0ZklVQKo0jQ9SbEp/tOu4xuWMlrBv7aIvYUHFWvVjh9maFEbiEyaUDxiKMSSh8bAXGLMS5FBiKzRoJ8vfe55C//8KdvdW4qOOuMJno53DIna9sdm2LMRZv7Bj7MyOF6l/BTxAXFyfNmzc/Z20ihBBCCCGEEFI3UEQnZ+TShMBUUFImT47ppsQkOCcrTkW82BXVQ670q+P7ypYDmXJNp0ZqO+2wZL4vqS25xeUqyiWnqKpQ43WdG4vI6UghuIgHt4tTgrvG3EenXdPOPg+9fbx8n5YtTSJDKFxeojUgrCgoKZeoMOtIFXPGOfBWbHTphMukVWyYHMsrdi23ejOiVVyYNIsOZT+shwU/Q8PCZc/uXRTSCSGEEEIIIeQigyI6qTUQcMwiDortIaLAW6zLevXZISN7JKgijthOi0nM9yW1JTI0QI5kFUl0RKCUlDslOMAhT4xJkoOZhVJQUiGxYYFyS5/mKvpF51yb+6jVmxUA4vv8UV1lxPMbpF+rWIqXl2gNCCswZkWEBHhM0Oj+hAlDxFghdshX3JW/w6He8gkK8PdwqBsF988evJJ9sB4W/ERW+caX56h9KaITQgghhBBCyMUFRXRy1oCAnp5bLAH+DuXa9VbIEYLSw8M6ym3/3KQc7QD7QIwipKYMaRcv23/Jlt4tY+T2lzapNyQAhM3Hx3QTp9MpseFVkz465xpvTYQHB7j1UbPrF+vxZkWLmFD5cvcxtQ3flrh0a0CY0Znk6FdPju0ms1YkuwnpvROjlWP8sVFdpKzCqfoXnOh24yLO8fPJAleUi3aoLxnXW3YczZH+reNUfywpr5CDGQUSHRpIMb0eFfwkhBBCCCGEEHLxQsWSnBWOZBfJjHe3K3H8D79qL1OvautRBM+uqB7iCSAUjb+8lcxekSzzRyepuBhCqgP6ztSr28mWAxny2AepKidaZ1hD0Jy9Mrmq6OgpsbGgtEIWrNkh6/eeVG5fM8Y8dKyfuux7dY7h3RKUSz0ylG9LXKo1IIxCujmTPDEuXPUzZPMjWigyJEBiwoNUTr+RbWlZXs+HyR0ju9PzpHFksCzdkCFPf7zHtRx9cvo17aVlbJgkcLysV+zevfucbEsIIYQQQgghpO6giE7OigN9xntVAjpIahqlRMw3JvXzul9wgL/6DRFoxg2dZNJrW5WDuKR8u3IL02FJfLF4XC/Zk1Uhk1/fqvrMXz/ZKzOGdbItOurqq6fEUKtio8ZiuOFBASqnGpEaPVtEy9GcYimvdKrjsH9emjUg8CYCIly0A90I+phZNK9pPIyxT6Ivov8t+nDnqRis0+g4mBHdm8qNSU3YH+sBxbmZIg6H3HbbbTXet6ys6u0ZQgghhBBCCCH1E4ro5IyBsKRFSQBnOdy8X+45YVukETEbEKGu69xIPkpNV+7M2/slKgcw3J44JkUh4otpy7eJX3CYq9+B/GLPNyDgDLbqq+bCj96KPo7p2UwJ8DgGXMhwJ/ONiUu7BsTZjodBP0Of1GAyJ6+43ENA16DfInaI42X9oKwoX8TplF6/mS0NW1YvAiZ9x2bZ/v4LUl7u/c0tQgghhBBCCCF1C0V0csbkmjKitZMSxfCW3z1AHLLLLScYQtGEQa3l75/ukTkju8qwv61XojvEIA1zp0lN0f0uKjRQFXOEqK4LM0aFBlj2VWMh0W1p2cpt/JpN0cf5hqgYCKCI9+AbE+RsxcMg13/8oFYqk1+DtyHM8S5m0M85XtYvIho1r3aOOoqREkIIIYQQQgip/1BEJ2eMOZ7A6O7NLiiVnokxMnFQayX2QOjEeghFEM4fuqFC/nFnH9l6MFPFZGgQl0BIddEOXgiRP/6SJTNXpLi99XBr3xaWfVUXEv3tlW1kwagkOZZbbOv61cVwNXxjghhBxA/6AyZqkJsff6qQrRV4g+HpW3rIT8fzJae4TBpGBEuDkAA5ml0si8f1VhM/mODRY6Y3sJ7jJSGEEEIIIYQQcm6hiE7OSjzBkPbxrpgM7e6FuOPn53CLxTBzOKtIiZ+IcxnVvamK0+jbMkYdk5DqCuiYpHlr80G57+p2Mun1rW7rVXHRFcnKNW4VpQEhvazCKfM+SJFx/Vt6PZc5KoYOYOIqrGzI2ge+In/yi8tlyhvfqrHyr5/ucXv7AePp2umDJbOgROIbhMjyKf0lu6jM9WYFxlj0W/T943klaswkhBBCCCGEEELIucO7xY2QagLxEoIOgLiDqIKHru8oQf4OmXZNOxWv8cKdvVWRPHyGWG6MLICAtHBNqswZ0UVFZtDdS6rDu78bKLNv7CIJUcEya3gXJaCj/5kxusYhbELgNHJ5mzgltvty/UaEnO63gA5gYi5Wq9GRP1ivt4PzHBOG+0/ki5+fyNv3DJTXLeKDcKyFa3eIv7+/zF+dKt/sr+qbxWUVcnnbOHnrngEyPKmJPHpjZxnQOlYyCkpd5yGEEEIIIYQQQsjZh050csZAnJz02lZVBA+55oggaB4TKn/5z26Zfm0HJRqZizTCfQnnMFzoXZtGquWI0Zg7sqsksFgjqSZpGYUSWxkk6TlF0iI2zFJAN7vG4QyGKx39NquwVErLK6XC6bQsNGoEsTDHc0tcnyHE840JYi5WazV5owstN2oQLKUVlRLo7yfbD2VLk6hQ2/igLk2jZPFne9TbEeZCt+iLc0d0lb99ultu6ttCFdiFG/2Nyf3P2XUSQgghhBBCCCGXMhTRyRmDDGCIREaRB87zzk2j5OmPd1kWaXSIyMIxSTL87xvk/yb3c60rKCk/r20nFzYP/vtH8QsOU1noxrxyK4yucTjS84rLXTEa79470KPQqDleA29JjHt5k0tA5xsTxKpYrdXkzYn8Elmz/Yh7n2oXL/dfa198Em/oAAjo5jEUb00sXLNDeiRGy6sbflYTmN5iswghhBBCCCGEEHJmUEQnZ4y5WCOAGx0ikJ2wAxEImcB9WsaoInwaZP4iloDiJKkJKPo57FATGdIuztLZa3aNH84qlIOZhS5xMijAz+VAR6FR41sVUaGB0iImVCoqnfLKXX2VGI9jsY8Su/HPCPrP06tSPCNb9p2U313d1nY/X2Mo9p8wqJVaj75KCCGEEEIIIYSQcwdFdHLGhAT6qXgBCOOnl/mr/F5vwL0+b2RXKS6rcp9DxFyTfFR+/CVbuXztCvIRYsXja3fK2vsHy7xVqW6FQyGg//mm7urfyKTOKSqV4AB/lcuPH/TDoznFqjgpgNiphUtdtDS7sFS6t2DxRuKJVbFaDZYjvqVXYoxrUkYXB31rS5pEBAd4jJ1G8T2nyLvLHccz/iaEEEIIIYQQQsi5gSI6OSPgGp/3QapMGNRanKcESAiTEJYQl+ENCEhlFZXi7+cn13RqqLJ/4QLWhUmRW023L6ku6DcQu3XeOWI0tGu8oLRCpr25zS27GnEaiG5Bnwvwc8h0kwMdhRyRkY71q6cNrtNrI/UXXawWY5bV5E1+aYXsOJKjlsFZrouDjunVVL4/kCUzhnWSibkl4nA4lLiOSKFeidHSIMT3n2ddCDcxNkwVbCaEEEIIIYQQQsi5gSI6OSMgVn6687h881OGS4CMDQ+Sv3+6Rx64roOtyxIO349S05XjF3nT/3t9R5ny+lZXYUhdkI8iOvHGs7f2kNiYaJf4GBIYoPqMsd9gomfGe9s9ij8iDgNAdE85kqOES6voDBYQJb4wFqs1Tt6A2SuTPYqDYqJx1X2DZNWPR+Th95Jdx0Ec0Zrpg+VkfrFkFZRJYmyo1zFUF8Jdl5quCjgTQgghhBBCCCHk3EARnZyVonrGwqIoKvrN/ky5q6BMZt3YWRZ9uMslWBojMuDwBRA3K51Oub1fopuICTGKkOoUFkWfWjq+r/hXGXPdgLBpFtA16Jf3XtVWujWLku7Noi0LirKAKKkO5skbHR/UqWmUR3FQTDguWJ1qkZOeoeKIbuzWRGauSFFC/CvjLxOH7LYcQ9/afNA1luoJSEIIIYQQQgghhJx9KKKTs1pUDw7LQH8/JRL9c/1Psi0tW/0bBfDCgwOkoKTcFZFhFH0gJpmL48HNSUh1QP/xE4c8PjZJ9p/Il7jw04KmnuixA7nTb25Ok4eGdpRHb+wsIg5JyyyUyJAAadsoQhpHhpynqyAXG+h7VsVBq1MwVE8AjXt5kxpDf3dVW/Hzc6gYrOBAPymvdMr4Qa2lvMKp1uNNDEIIIYQQQgghhJwbKKKTMwJOSbh14fSFgI6MaX8/h5tIpH+/cGdvmbrse9tjGYvjMUKD1BSIj4eyimTj/gzZ/ku2yqkOD/KX0EB/n7nS2PfhYR3lw5R0JUb2bRmjHOgU0MmZTjKiaK0ZX4VAjev1Wz74QeFc9Oe5q1LcIl7gTMfYSwghhBBCCCGEkHMDRXRyRsDt+9iorvLYqhTpkRijYgt6JcYoEd2uCJ4dej0jNEhtM9ExgTO4bbz0ToyRr/acUAVDD2YWKpHRHJ1hzJUGxaWV0jsxWkbfN0gaNQhm/yNnDCYCj+UG1nosNFNQUiF/+nCnR0a67tvXdW58Ru0lhBBCCCGEEEKINd7/J09INXCISJ9WsTK8W4IScyBmWjl4dRE8K4a0i5fmMaHyyR+ukMV39JKE6NDz0HJyMWSiT3ptqyqqCCducWmF3I74i9e2yprtR6RH82h5a0uayo1GHzOic6V1DIbDITLptW/Fz+GggE7OCuhHLePCVHHQ6o6FxokdMw1CAlRuuhVWk0SEEEIIIYQQQgg5O9CJTs4Y5E9/fzBL+rSMccUPHM8rVsKR0TEJsRJCJ0R343I4z58YkySJceF10n5y4QMBEf0Korhx2cK1O+R/BrSUR97bLm/eM0CO55aoDHQ4fY3Z/BDYN5wq3MiCtuRs0iwmTP706+4yc0Wyq8AtJnbemNRPFn20y63o7ZB2cXLf1e1l0utbPY6D8dQPnZwQQgghhBBCCCHnHYro5Ky4LZE/fTCjQH1GNnqjiBCZMayTTMwtEYfD4YrbWL75oDx8Qyd51N9PDmYUSqC/Q47nlSgBlJCasuTO3rI7s1z1LUzMTBrcxm09BMpZN3ZWMReIwbijf0tZtvmgm2sX4iSKit7x8ib1mQVtydmmeWyYesMGhUILSsqkQWigPLFmh/RoES0TLm+lMtCjQgNVhnpmQYn0Soz26KNPjO0mR7KL6vQ6CCGEEEIIIYSQSxWK6OSs0DQ6VOVRX9e5kYzrnyhPrdvpFjsAh+XKqYPko9SjcvtLm+T5O3pJypEcV9FRiER/vrmHOg4h1eW+Zd/LkK4t1BsOcJUXl1W41mEyZ9Lg1lJeWSlFpRVy54BWsv1QtvRrHSuTBrVWwqV2pGcVlFY50lnQlpzDyUb8QAj/47s/KpH8010n3LbBGxFzRnZWb+YUl1dKblG5RIYEqBgXFBPt3DTKNt8fxZgJIYQQQgghhBByEYvoS5YskaefflrS09OlR48e8vzzz0u/fv0st3355ZfljTfekJSUFPW5T58+8uSTT9puT84fyEF/bGRXmfn+do/cXnyevyZVFR2FWAmGdm0sXRIiJSTQXznVcwpL1XIK6aQmaEERgnmL2FB54c7eEh4UIFFhgfL0x7tcEzXGHPTpp2JcNNgH6+aP6so8dHJOQZyQXX75+n0npaJSpFXjCLflu47myme7TsjG/ZlqwggYj6GLMRNCCCGEEEIIIeQiFdHffvttefDBB+XFF1+U/v37y3PPPSdDhw6V3bt3S6NGjTy2//LLL+WOO+6Qyy+/XEJCQuSpp56S66+/XlJTU6VZs2Z1cg3kNPml5V4L38EBrAvnQUCfuux7lwPzpl7N5Mm1O1RsAYVMUhPQt6Ze1U4+Tj2mRPNp17RTxUbNYqVRcDeK6xDfMcFDyLkmt8h75r5VJn9ucbnr36lHcmTGDZ3UvzERFODnUE51FmMmhBBCCCGEEELOHX5Sxzz77LNy9913y8SJE6VLly5KTA8LC5OlS5dabr9s2TKZOnWq9OzZUzp16iSvvPKKVFZWymeffXbe2048ySs6LfbYAScwMqwbNQhWkRvagTlnVYrcc2VbySiocqQTUhOCAvzkspaxSkDvmxgj29Ky1b9fHd9XOc2XTrjslLieLb1aRLv2w6QOxPftv2SrIrmEnEsiQ71n7ltl8iPSBWMlXOhbfs6UUYu/Vj+Ixvrrp3skyL/O/5QTQgghhBBCCCEXNXX6P+/S0lL57rvv5LrrrjvdID8/9Xnjxo3VOkZhYaGUlZVJbGzsOWwpqS5hwVWiuB0onofsahTO23MsT4lCWkhHYci84nKpqHSep9aSiwn0nfH/2qIc6HDlLhnXW/178uvfqjceJr22VX1Gnys/1cfwBsTkwa1l99FcFYfBNyDIuQaCOGpAWIHlWG8mJjxI5gzvLP/6+mfLtyvmfpDqisMihBBCCCGEEELIRSainzx5UioqKqRx48Zuy/EZ+ejVYcaMGdK0aVM3Id5ISUmJ5Obmuv2Qc0d4kL9y9lqB5V/uOaEEdLjRH1+7U4lCiNYw5gVTRCc1fY7Rt5Crr0XFx9fukKM5RZaCI/pc24bhsmb6ILmxe4K0i4+QZ27pwTgMcl5AQdsJp2KtjOAzlmO9Vb2J3i1j7LPU956Uk/kU0QkhhBBCCCGEkHPFBf0O+J/+9Cd56623ZMWKFSof3YpFixZJVFSU66dFixbnvZ2XEmFBATL96vYyxCQQwfE7d0QXFbOB7Gm40ZHnC1HIGK0RHODnVvCREF/PsS4Wioggo6gI4dEK9LmyCqd8teeEzHw/WcoqnXSgk/MGJgqr3saJcUUN4bceF+0y032Ni1ZZ6oQQQgghhBBCCLkICovGx8eLv7+/HDt2zG05Pjdp0sTrvs8884wS0T/99FPp3r277XYzZ85UhUs1cLBSSD935JeUS0l5hcy8sbP8sdIph7KKpHlMqPxnxzEZ+8I3lkKQdl7qgqNje7JALKnec7x4XC/Zk1XhmpQxYuXo1RzMKJROTSLVvyk+kvNJZEig6qvGwra+MtH1ft6w248QQgghhBBCCCEXuBM9KChI+vTp41YUVBcJHThwoO1+f/7zn2XhwoWybt066du3r9dzBAcHS2RkpNsPObcuy98t+15CA/0lv7hcZVFnnooZeP6OXm4FHnUWOtznxmzq+Ai6gkn1n+MuCZGyeFxvtz6l9gmwH94C/R0ukZ3iIzmfYHy7on285TosN49/yDr/6Xi+VDidMqQG+xFCCCGEEEIIIeQicaIDuEvHjx+vxPB+/frJc889JwUFBTJx4kS1/q677pJmzZqpOAfw1FNPydy5c2X58uXSqlUrV3Z6RESE+iH1w2V5Ir9EIkIC5NpODSU6PEgVdDQ6L+E6R4HHNzcdlICyfOkbVyY/H0qX+aO6MlqDVJtpy7eJX3CYW5+CK71Pyxg5nltsuQ8mbCfTqFoAAQAASURBVPDGA2KEKD6S8w3Gtz/d1F0eeW+7/HfvSddy9EVjcVun0ymp+w/JnHe/lW8PF0lEVIw8P663Wo4izHb7EUIIIYQQQggh5CIU0W+77TY5ceKEEsYhiPfs2VM5zHWx0bS0NPHzO+0o/cc//iGlpaVy8803ux1n3rx58thjj5339hNrl2VEcIDctXSLvPe7y2X2imSPgnjrUw7K7k/fluxvV8nSn05nWXfs0FZ+N3W6mliJjj6dlU6IL9DHMFI8NrKL9GgRI0eyi5Swbux7ENDnj+6qCo82iw6l+EjqhKbRoerNHBQDRZwQ3obA2Im+mJ2dLa+//rosWfx32btvv2ufkLgm8j9bRst9v50sU6f0l5BAf4kKPb0f8c2hQ4ckI8O6OKuZ3bt3n/P2EEIIIYQQQgi5cKhzER1MmzZN/Vjx5Zdfun0+cODAeWoVqS6IG4AYlFtcJpGhgbLo192kssIpM4Z2lKKyCllvEtCL9n8nmR8skiNlJXJzP5FFw0ViwkWyCkTe27JfHvrfP8jcOY/Kv995T4YOHVpn10UuPNDXHh3eRSoqKuWP7/4ot/dLlEmDWqvoFsS7NGwQrDL7547oKjFhgRQfSZ2Bvmfufx9//LHcestNUlhYKDddJvLEjafHxne3HJP3P3tJFnz1uiweNVO+WfygtG3Et69qIqB36NhJigoLarRfWVlVHBkhhBBCCCGEkEubeiGikwsXuH1nvLdd1ptiCRaMTlL/PpxV5CGgn3hvvtzQ3SlL73ZKE5PZ/Jb+TknPFpnySpGMGDFc1qxZSyGd1IjD2UUqygWRGeaCo2unD5a48GBpFBlSp20kxAwEdIx5Q7s55ZUp9mPj5FdKZd178+XjkV1k6m/c38gi9sCBDgF94N0LpUHjRJ/bp+/YLNvff0HKyz2LYRNCCCGEEEIIufSo08Ki5MJ3oJsFdICc39krk6V1Q3eXZGVxvnKgQ0D/4EFPkUiD5Sv/UKnEJLgyEW9ASE2ASP6vr3+WSYNbu5YNaRen3OcU0El9A2McxjqMeRj7vI2Nq/5QqcbQR6ZO4NhYCyCgx7Ro7/MnPC6hrptKCCGEEEIIIaQeQRGd1BpEuJgFdA0K35VXOFUBR+RSg/yUz8RZVqIc6AH+3o+N9S9PrlSxBm+88ca5aD65CEFfQ59DfAuy0FE8FAxpHy+Lft1dmsZUFSElpD6BDHSMda9MqazW2AinelERx0ZCCCGEEEIIIeR8QRGd1BpkoHsjLNhflm74WSYOai2Xt42Voh9Wy0397B3oZhJiRH59mcgLS/4uTqfz7DSaXNQCOvoa+hzyz0F4cIB88ocrZPEdvaR5LAV0Uv/A2PaPF55XGegcGwkhhBBCCCGEkPoJRXRSayJDAr2ud4hD+iRGq1zqjtEOKc5IV4VEa8JNlzll956fJDMz88waSy5KFo/rJS/c2VteHd9XeiXGqL7WKzFaudFBQUm5+DkcLCBK6nVWN8Y4TDDWZmzctPOgHMstPmftI4QQQgghhBBCCAuLkjMgPiJIFRFFBrqZwe3ixOFwytSr28niL/bJy5/vUMtjwmt2Dr19Xl6exMVVxcIQolm2OU02HyrycKNDTEcGevLhHIkLp4BO6i/5+flnNDbe8vznclWfLvLk2G6SGFfDgxBCCCGEEEIIIaRaUEQntQbu3j/d1F0eeW+7m5CO/OmFo5NkwZpU2bQ/UxV3vKnLALnpRZGsgpqdQ2/foEGDs9x6cjHwzM3dpUCC5HBWlZAOB7p2o0+9ur0Ul1VIZKj3NyYIqUsiIqoKMNd2bHQEhaoaFLNWJMv/mzLgHLSQEEIIIYQQQgghFNHJGdE0OlSev6OXKjKaV1wmDUICpaKyUgpLy+XzXSfUNos/36dye0Pimsg7W47JLf2rH1vw3laHdOzQRmJjY8/hVZALlYzCUmkcGy7b87MlLiJYuiREqv4IMX3y61uld2K0/OXWnnXdTEJswRs2HTu0lfe27K/R2PjOFoeExDUWv5CqCUYI6YQQQgghhBBCCDk3UEQnZ8WRrjOnj2QXyYGTxeJwONy2wefQniPl/S9ekfTs6hXQO5ol8v5Wkb88e7/H8QgBo57/Wq5MSpTxl7eS6W9uk8LSCrf1EBbzi8ulcWSdNZEQr2Bs+93U6fLQ//6hRmPjiq0ikVeP4thICCGEEEIIIYScB1hYlJw1cgpLZca72+Wb/RkSGeI5PxORdK04AoNl0ssOKXfXOj3A+rtf9ZOwsDC56667zl2jyQXP+r0n5V9f/6xig6zAGxKE1GfGjx+vxropr/hVa2yc/IpDjaURSdecryYSQgghhBBCCCGXNBTRyVkDkS7r952UpRt+lqBAP1Vc1IhfSITEjpopHyc7ZPSzDuWmtALLx/zVT233zrvvS3R0NayZ5JLm630Z0quFdT9BxBAh9RmMcf9+5z015mHs8zY2jnrWIeu2OyR29Cw1pmrM4y0hhBBCCCGEEELOHoxzIWeN3FOOX0RqTPrXVnltUj+ZtyrFLav3uuuvl6RfdZC50ydKi/tLZOxlIrf0c0pMeFWhPGSgI8IlLCxU1q59X66//vo6vCJyIVFSXumx7Ir28RIfURU1REh9ZujQobJmzVq59ZabJPGBQvn1ZSI3XXZ6bHx3i0NWfCsSGhomV9//hPwU3M5NQJ87smudtp8QQgghhBBCCLmYoYhOzhqRBsfvL1lFcts/N8pTN3WXWcO7yIGTBRIc4KcKPi7dkC0J974m+Smfy5ofPpB3N6e79kMRUWSgI94gKiqqjq6EXIhEhwZ6COjofzqvn5ALQUg/mHZI3njjDXlhyd/l38//5FqHIqINrholLQcMk1l3DpRGkcGSX1wh0WGBUlZRKZNf2yrrZ1w68S6HDh2SjIzqF1PdvXv3OW0PIYQQQgghhJCLG4ro5KwBxy+Ey//uPemKd5n8+rcy7Zp28kNalpsjHTEEkX1HyfDbJ8qCoS3FUVEiDRo0kNjYWBbKIzVmULs4KSqrkGVT+qvJmpiwINUfKaCTCzHa5f7775fp06dLZmamHD6eIU/854BsOlKqxsasclHjqu73vRJjZFtaljx9Sw+5lAT0Dh07SVFhQY33LSsrPSdtIoQQQgghhBBycUMRnZw1IFg+ObabPPL+djfBfMeRHJkzoqssXJPqtnxIuzhZOKabtIoPr6MWk4sBCIkTB7WW6W9uU1FCiLb4y609KaCTCxoI5nFxcernrwkt5JH3trsmKI39/v5T/d7P4ZABbS6NXHQ40CGgD7x7oTRonFitfdJ3bJbt778g5b4qtxJCCCGEEEIIIRZQRCdnldKKSumZGKPEHWRU6wiXO1/ZJLf3S5QZwzrJL5lF0iI2VJxOkdwiuAIpopPasXhcL9mTVeESEgEmarIKSqVxZEhdN4+Qs0LT6FB5/o5ecjSnWPYborGM/X69QWC/VICAHtOifbW2zTuWds7bQwghhBBCCCHk4oUiOjmr5BSVyeLP91muw/IuCZEyddn38tY9A5QQFGXKsSakJkxbvk38gsM8lucWl9dJewg5V+DNCgjoGD8JIYQQQgghhBByfvE7z+cjl1BxUSsgnIOCknJ59j97JMifXZCcfSJDOD9ILr3xlRBCCCGEEEIIIecGKpjknBQXtQIZvogg0L/X7zsps1YkS04hC72Rswcy0WPCmYdOLr3xlRBCCCGEEEIIIecGiujkrEcO/Omm7h5Cjy6ChyKj+L10w89qOQrlncyniE5qx8A2sR4COorbMg+dXMzj6xCb8ZUQQgghhBBCCCHnBmYekHNWBA/iODLSQ4P8pbisQnIKy6RL0yi3Ynggr7isTttLLlyeGNtNyv1DVAY6IlzgQKeATi728XXOiC7yS2ahW/FmjKs7FtxQ180jhBBCCCGEEEIuSiiik3PmmMQP+Ol4vgz723rbbRsw55fUkkaRIRIZGVnXzSDkvOLvcMjk17+t62YQQgghhBBCCCGXDIxzIXWa44vlWE8IIeTMx1RCCCGEEEIIIYScfSiikzrLScfnp27q7nKsE0IIqf2YSgghhBBCCCGEkHMD41zIec9JRwY6IlzgpqSATgghZ2dMJYQQQgghhBBCyLmBIjqpk5x0QgghZwbHVEIIIYQQQggh5PzAOBdCCCGEEEIIIYQQQgghxAaK6IQQQgghhBBCCCGEEEKIDRTRCSGEEEIIIYQQQgghhBAbKKITQgghhBBCCCGEEEIIITZQRCeEEEIIIYQQQgghhBBC6rOIvmTJEmnVqpWEhIRI//79ZcuWLV63f+edd6RTp05q+27dusmHH3543tpKCCGEEEIIIYQQQggh5NKhzkX0t99+Wx588EGZN2+efP/999KjRw8ZOnSoHD9+3HL7b775Ru644w6ZPHmybNu2TcaMGaN+UlJSznvbCSGEEEIIIYQQQgghhFzc1LmI/uyzz8rdd98tEydOlC5dusiLL74oYWFhsnTpUsvt//a3v8kNN9wgf/zjH6Vz586ycOFC6d27tyxevPi8t50QQgghhBBCCCGEEELIxU1AXZ68tLRUvvvuO5k5c6ZrmZ+fn1x33XWyceNGy32wHM51I3Cur1y50nL7kpIS9aPJyclRv3Nzc8/SVRBy4dOgQQNxOBxSX+FzTMiF/xwbcTqdkpeXV6t98/Pz1e+cIweksqKyWvvkHT+ifuemp0lwUPBZ3577nL996mu7ar3PsbSqfXJzL6hnmBBCCCGEkEsNhxP/k60jjhw5Is2aNVMRLQMHDnQtf/jhh+Wrr76SzZs3e+wTFBQkr7/+uop00bzwwgsyf/58OXbsmMf2jz32mFpHCLEH8UkNGzaU+gqfY0Iu/OfYyIkTJ6RRo0Z13QxC6hUX0jNMCCGEEELIpUadOtHPB3C5G53r2dnZ0rJlS0lLS5OoqCi5EIFbqUWLFvLLL79IZGSkXIjwGurXNWByqj7D57h+wmuoH1woz7ER3daL4b7zGuqWi+kaLqRnmBBCCCGEkEuNOhXR4+Pjxd/f38NBjs9NmjSx3AfLa7J9cHCw+jED4e1C/c+WBu3nNdQ9F8M11PfXx/kc1294DfWD+v4cW7X1YrjvvIb6wcVwDRfSM0wIIYQQQsilRp0WFoXjpk+fPvLZZ5+5llVWVqrPxngXI1hu3B588sknttsTQgghhBBCCCGEEEIIIRdsnAsiGsaPHy99+/aVfv36yXPPPScFBQUyceJEtf6uu+5SuemLFi1Snx944AG58sor5S9/+YsMHz5c3nrrLfn222/lpZdequMrIYQQQgghhBBCCCGEEHKxUeci+m233aYKjM2dO1fS09OlZ8+esm7dOmncuLFaj8xjP7/ThvnLL79cli9fLrNnz5ZZs2ZJ+/btZeXKlZKUlFSt8yESYt68eZbREBcKvIb6Aa+h7rhQ222E11A/4DXUDRdim83wGuoHvAZCCCGEEELI+cDhdDqd5+VMhBBCCCGEEEIIIYQQQsgFRp1mohNCCCGEEEIIIYQQQggh9RmK6IQQQgghhBBCCCGEEEKIDRTRCSGEEEIIIYQQQgghhBAbKKITQgghhBBCCCGEEEIIITZQRCeEEEIIIYQQQgghhBBCbKCITgghhBBCCCGEEEIIIYTYQBGdEEIIIYQQQgghhBBCCLGBIjohhBBCCCGEEEIIIYQQYgNFdEIIIYQQQgghhBBCCCHEBorohBBCCCGEEEIIIYQQQogNFNEJIYQQQgghhBBCCCGEEBsoohNCCCGEEEIIIYQQQgghNlBEJ4QQQgghhBBCCCGEEEJsoIhOCCGEEEIIIYQQQgghhNhAEZ0QQgghhBBCCCGEEEIIsYEiOiGEEEIIIYQQQgghhBBiA0V0QgghhBBCCCGEEEIIIcQGiuiEEEIIIYQQQgghhBBCSH0U0f/73//KyJEjpWnTpuJwOGTlypU+9/nyyy+ld+/eEhwcLO3atZPXXnvtvLSVEEIIIYQQQgghhBBCyKVHnYroBQUF0qNHD1myZEm1tv/5559l+PDhcvXVV8sPP/wgv//972XKlCny8ccfn/O2EkIIIYQQQgghhBBCCLn0cDidTqfUA+BEX7FihYwZM8Z2mxkzZsjatWslJSXFtez222+X7OxsWbdu3XlqKSGEEEIIIYQQQgghhJBLhQC5gNi4caNcd911bsuGDh2qHOl2lJSUqB8N5gxKS0slPj5eCfeEkPoPn2NCLmz4DBNCCCGEEEIIuZC5oET09PR0ady4sdsyfM7NzZWioiIJDQ312GfRokUyf/58j+U5OTkSGRl5Ttt7KbHzaK4M+9t62/XLpvSXjfszZPHn+9TnQe3ipFdijPr87r0D5eYXN8qr4/tKVGig9G0Vex5bTi4E7J7jtKMnpNQvRHKLyyQyNFDiw4MkKizI8hg5haVyMr+0WttqtqVlydgXvrFdv3Lq5dIzMcb1+afj+XLts1/Zbv/Zg1dK20YRZ3QuXMe0N7fJ+r0nPba5on28PH9HL5/XZceZtN+Os91eX2PNRw8Mkc4Jvsf2I9lFMuO97W7tQnv+dFN3KSqt8HofMFZNfv1b9e937h0ot7y40XK7ade0k2ZRIbIm+ah8vS9DLVsx9XJ55j+7XZ+NYFycO6KLNIkMkZ1H8+T5L/a6bYf1065uJ1sOZMqWnzNl4qDWcv+b26RvyxjV7qbRnn8D6wtn+2+x+v7e3S7r91V9f2FB/rJ0wmWy5PN9ahnuPZ4pff+w/u939JJ/ff2z2z0d3C5OnhzbTTIKSt2eP/P+Roa0i5dh3ZrIrBWn34ozHg/fi+4fRl64s7dMXfa9W/8xYrfc2Le99X08nxjfqjtm+XqWdHuMf6+XT+kvXZtG1nqMIYQQQgghhJALlTrNRD8fzJw5U/0nXf/88ssvdd2ki5LcojKv63OKyqRXi2jXZwgT+nN5ZVWiUEl5pRI6CKnuc/yfHcfkQEaBHM0ploMZhfJhSroczS6yFNwg5EIYhcB07V++kulvblPLvREZEuh1fQPTeghY3sjzsr6658JEgJUgDf6796Ra703QhlAOcfCnE/nq89lqvx1n0t7ajDXVaSOu2yyg6/Y88t52ySny3iaMVZpwL2MWxrhGkSFuQmyAv8NSmAVYjuEwq7DUQ0DX6xd/sU+u7thI/RuC8KTBrV3tvlT+Fqvv793t8l1alhK7IfZionbJ53tdojruvfH+4T6ZBXSwYV+GzFqR7PG3x7y/EZyjcWSI5Tocr1FksOW64AA/j/5jxG6567qr0fdrMmb5epZ0e9z+Xjudary1G0MIIYQQQggh5GLlgnKiN2nSRI4dO+a2DJ/hYrNyoYPg4GD1Q84tcPZ6A+KBWSDQn7UIBRd6eNAF1SXJecLuOf44NV22/OeA6zMck63jw5Ugpp2Sx3KL5cDJArmjX6JyiH6fliVLN/yshEcIqY+PSZLo0EBLZ2V8RJByJ2NbM1iO9WciutfmXLUVur05r7WD2Vf7w4MDlAhfEzf/2RbmfY013u5xdYX9WTd29rq/FkNBeFCA7fcGzONeVoH3680vKZdKp79Xod3470mDWrvaXZ85m3+Lj+eVKAFdO8vhkIaQvt5wb8z3HSKwfhPKSvgO8POTIe3iXMfwJWh7W19YUqHEfYwzhaUVrrFp2y/Z6t8Yb3z1KyvCg/199v2ajFnV+bttvl5/h0NuMLjXzWMIIYQQQgghhFysXFBO9IEDB8pnn33mtuyTTz5Ry0nd0iAkQIa0j7dcp8UDs0CAz4PaxkphXrb0jC6V4LJ8iQqliE6qz6b9meo3RHOIVhAUC0rKJT23WDkk4Up/6N8/yLhXNqsYhUmvbVUOSohv2AdCKtydO47myuGsQo/jQyCGQAShyAg+P3VTdw8BWQtYVliJ7t7Opa8J8QkPXNteThaUqmuKCA6osYjs03l9yk3qrf14vr89mHXO3fy+HPSYdENkhhVYjvW+3LG+hH1/P4ftfTCKodgmOizQto80jwn1GPf0mzfextL84nKVGV5RmCPlOcfUb2MNcC3MVkfsvRjJLirzcJab74P5vheXVdjeT5BZUCJTr26nvl+r/c14Wx8W7O82zuCYmMCDqI5+0TIuzLJ/oV/Z9W08f8dzS1zts1qP57c6Yxaej4MZBRISgIkD3/1cXy/ahlg2b2MIIYQQQgghhFys1KlimZ+fL/v2nXaG/fzzz/LDDz9IbGysJCYmqte/Dx8+LG+88YZaf++998rixYvl4YcflkmTJsnnn38u//73v2Xt2rV1eBUENAgOkIWjk2T2ymTl6tNo8WDNj4fl+i6NZfX0QZJfXCFSmi+r3/2XfL30n7L8QJWTeNVMkbZt28j06ffL+PHjJTr6dPwLIXYYs46NTlOIRhDFvkvLdtsW2b6hgf7y4v/0UYJmRaVT5f72ToyWP/26uzSPDXM7PhyWyO2Gexmuae32tHJgawELopLRCWolusMhn1WAjPZyiQwNkJiwIHWup2/poeI88orLpbyiUr7+KUOJbwCZzz+fKFDPlZVT2U6or06kCtrmrf24l5iEMN7L7i2ilcs/PadI7WvlTK+pm9+cXx8eFKBcxwvX7FDiMbZ/656B8tgHKW5jDQS+uSO7yq//8Y10SYj06o71JexDRLe6D3o8Qw658TuNChPLPgK+T8t2+77wJoTd94drKMnPlX//3//J8Vf/LsUZ6a51IXFNJLTnSIlIulYC/E4X4vQl9l6MYKLE7Cw33wcIwLjP61MOSn7KZzL17Wly6NTfGvP99AuJkLCgALnlnxuVOI/JOPQdCMw6HsYsWCdEhaiM85BAf9fbLeif+A4hduP79XM45MP7B4tDHCoiaPW0wW5Ct7l/7T6aq/LZZ69M8Xj+FoxOkptf/EbtB8xZ+fj7i+NiXEFMCybg8EZFaKCfKtyKSQZMLmJcqXQ65ZmPd8k3+zPV2FkpTrfjwZE/Z2RX+flkgRpz8Hxn5pfK5MFt5MdD2cr1j+MZr12PIYQQQgghhBByseJwmu1Y55Evv/xSrr76ao/lEFBfe+01mTBhghw4cEBtZ9znD3/4g+zYsUOaN28uc+bMUdtVFxQhjYqKYmHRswxcosfziiQ8OFC5KOEUhKgBIeNwZoHcf10HJQzgP+pF+7+TzA8WibO8RG6+TOSmfk6JCUfMgci7Wxzy/laRsLAw+fc778nQoUPr+tJIPUQ/xy1+/2+5f1h32wKAxoJ4doUFIZSNH9RKCVr/e31HVaQRkRrVjSuxQovAdqJ7WkaBzFyR7NaOazs1VCIwnpP1FsJt6pEcVUxyd3qevDL+MvnLx7vdBD4Ie4vGdvOYBKhNgVRz+yHaDvv7epcD2u5e2kU7wK1uFgzR3sdGdRXIwXGG+2wVO2MUr7WQvnhcbxUBhTcJEHMB4RL76Yx1b0VLcX1w0dsJ+3o/431AlE2Qv58SQzHO2U2kmDl4skCO5BSpLHPcK33vXvv6Z49JgOujjsl9k+6U4qJC+fVlIjcbxsZ3MDZuEQkIDpEJc56XdTlN3Po32v3G5P5yoXAmf4txT/edyHcrwmlVSPQ3LbJl/gOTpLykWG7qZ30/HYHBMuTeRfLob+9wO16LmFB5Y3I/mbPSfbIG48V9mFB6fatbVAv65/vf/SJ/vKGTqs+AdRCZ28aHS8v48BqNE1bLAfos3gaB0I9JBAjZ+DuLeJsbk5qoZ8E4ruAeQPB+4QsUW3XvaxNOPU8Ax+udGCMRwf5q0gpC+eNrd7quD8/q/FFd5ZfMQnlp/X4PAR/X3igiSLq3OD2GEEIIIYQQQsjFRp2K6HUBRfRzA8QLuNt+8+oWueeKNnJt50ZK1IIDrk18mDxqENBPvDdfbujulKV3O6WJhdk8PVtkyit+8nGyQ9asWUshnXgV0f91zxVu4pcZiEhYbxbZjEAImnFDJ3lq3a5qicJnApyiD/77B492VKd9t7+0SQmwyzcflC5No1xCGsTkplEh8pf/7JZZw7t4tBeTXIhhseOzB6+Uto0ibNebRXhvbbUTr7UwmF1UKiVllfLN/iqHPYQ6fZ/hMEYBWCvXvFEw1qx7YIhbPnNNrstK2Nfu8oSz+H3/+EuWfLnnhCoGCnC9Qf4ONdEo4lDCJYTSbd98KeNv/7Vc380pr06ptB0bJ7/iJ+t+FLli+l+U8AshtE/LGOVEbmUj1l5Mf4vRj07kl0h5hdPtu9eTE69/fUBNLuFvzUn8remB+2n/t2bSyw75JMVPWo1bKGUJVS5vo5C+5M7eEujvJ3lFVXUA0O8XGgRmDYTmBaO6yuxVVX/rjMufOktjiLc+6+fn8BhXfI0p5ufpj0M7yKafMtwEd+N1DEtqIrNWpFge68kx3WwnCwghhBBCCCHkYoAB1OSsgHiEgtJyGdAmVkVknMgrVcJDbHiQFJVVqv/EVxbnKwc6BPQPHnRKgE2NNIgdK/9QKWP+6ie33nKTHEw7xGgXYkt1CwB6KyyI/oksdYhKiHIwRhXMW5Uiz9zS46xFFSDCxUrU8tU+YMyB/nzXCbdtEMHQIzFGiWxmEbs2kSre4k+8tdUYD2NEf35sdaptNvucEV1sY2eMRTS1aArevXegElWDA9xjNXwVLdUxPRkFpSrSBz+FpeVSWFahhNqz9X1HBAfKXz/Zq37shP64oHIZMHGcDO3mVGOft7Fx1R8qZfRf/eS/r86WnNuGqWvAxAyiNy4kEb02GN9S+P117d0KgeI7x4TCsin95eZuMXLntbfKDT1wv7z/rcHfotF/dcp/3l4gCfe+pqJdNL9kFcmoxV+rSBNkqueVlMtMCxEZoE1HcopdbxsY3eLIH0dEUOPIkDO6fm/RUruO5nqMK77GlD9c18HVRox3DRsEydMf77G9vgmXt7I9VmnFpZfNTwghhBBCCLm0oIhOzhgIToh7yCkokxk3dJYFa1Ld/uP+9j0D1G/k0jrLSpQD3U7U0GD9y5MrJfGBQpWJf//995/ryyAXIAPbxlW7AKA3sR2iFyZ84No09l0dVQCh9WyJqshAr81kAERCb6IYxERENGA94h10priOpfGW1a7d6sbtvYnwvtpqJ177ymavcmfbo4U67Tp+Yu0ON9csojbeumeArN97Qjo1iZSyCqfsSs9VefNWAiausaC0wiM+5my+gVCdCYzXXn5VCgsL5ZUp1RsbX5lcKS3uL5S75zwrkX1Hufrq1Z2q3O4XI+biuC/9d/+pPO/Tk0x4RvAz8dFnpLioSDnQq30/HyiR/JTPXffTGH2CyRktNnttY1GZbY2Gs+VI17ULqjOuGNtrFvYhmgcF+KmIGD3phLd2vOHt+n0V6yWEEEIIIYSQCx2K6OSMOJpdpKIKUGQtIjhAMgpKlJt3W1q26z/mDUIDBalBRT+sVvnnVq/VW5EQIyoX+IUlf5fp06eraBhCjHRrFiWNI4Nl0dgkaRQZ4lHsDjEXEJSBN7Ed4tLja3Z4ODn158dGdrXd11gEszo56pEh1sOur8kAYzFJI0ZxDMUR4ZqFq/rDHUfln1/tV9vA4d2nZbTMHtFFxS4VllSoCBgIuHhOzREqupAh8r8jQjxFeF9thUO2NkIb4ly8kRgTJv+acJm6BoiUxqxqgAKkeKMAkRRGRy2EUBRsTIwL9yrMmp3xdpnqNe0L3iYwsN0/Xnhebrqsyhld3bFx7GUia374QBr0GanGRqu3Gy4mzBMw2nmuC4Giz2Hypqi0XJypH9b4bw3u/yepa8V56n7q7+jxMUmqqC0Y2CbO63HwXBjfFjGy3kufqskYYrctihNbtQfYCvvt4tVyXWvAF96e++KySlXrwfyMkYuftLQ0OXnSenK0JsTHx0tiYuJZaRMhhBBCCCHnAoropNbgP/MHMwtlzfYjHoXGjP8xr6yslFnXNJN7/5wuN99Zs3PcdJlT/v38T5KZmSlxcd4FDHLp8X+bDsjlnZvLh8lH3RzJ6IMQk1vFhklokL/0axWrhFe4Qa2c0Je3iXOJS1aOTTsB26oIpi8XM4QviLpmARhFeK2W6+vZsO+k/KpzY7fl3sSxqVe3lZ7No6XSKfLKhv0y8/1kjzaCh21E5EdXJrsVrYTgq6MkvN1Lb/Ew5lgYM+FBAbaubdyDj1LTVXsQ2WF1n/C96QKeRrDtrBXJ8uebe0hRaYVLgKysdHp1xlvF0tjhqy88fUsPFeUDxzAET+2Oh/i0e89PsrCGL9vc0s8p725Ol8riPPEPvfjre1hNwODvi+73b949QNU+CCrPl+z0w3LzrbX4W7PpsPxnYjcJCIt0i0pBnBPeRkEki90ziucBz7DxbRGrsSTLFBVUkzHE27YhAX7qGTH2fbRHZ59bCvv7TkqlOKuem8/3uba3mpBBdM7x3GLLe4fxZuP+DPlHWpb85daeZxxbQy4sOnXqLEVFhWd8nNDQMNm1ayeFdEIIIYQQUm+hiE5qTXZhmTz/+V5b9y7+Y/7WljRB5dp12w6oZTE1NKnp7fPy8iiiEw9+M6CVvLrBUxzCZz+HQ54ckySZ2aUqsiM6NFAWje2mMrk/3XnctS1EowB/347NJ8Ymubksa+NihgiGCJI5I7rKwjWpbmLcziM58sTYbjJnZYqbiAxxbv6oKid8eHCA/KpzI+mYEKmEOdQdCPB3eLz9ocWxEd0S1PNnvj81zSDH9jNOXZMu1PmUF3e1nfDsK9okOixQOeAh4Jsn5hCrg4k5de9tYl+8xd3gXkPEHv78BtcyiPHesDuPx3Y++sKiX3eTR95PthQ/S/Pzz2hsdJYWiVwCIrqvCZiIkKq3GAoLCs74b010WCRqvrqBEuzZhaWycEySzF3lnuuP/vnQ9R3lb5/tkS4JkdUeS2oyhvja9sFftVfPCNDPDt7GQUQL2l6dbHTUMxnVo6ly3puvb+Lg1uIQz0kEfH5oaEe54+VNavzBM0YR/dICAnr/SfMkMsE6M7865B49IJuXzleTihTRCSGEEEJIfYUiOqk1KCRqFyGA5ZMHt5HruzSWP320S749UqSWZ1XpG9VGb9+gQYMzbi+5+OjePEpe2bzbch1EIBQGHPfKZpPg00n+p39LVUASwnpESIByhwLbKIZ9J5WT2eiy1PESVm5TxMmYc9SNItjmnzPlmZt7yGOjukpJWaVL5MePXeFADYTvmSuSPbLbzbEM5kKctckgN2Ygm53Z3ooc2uEr2gTrD2QUuAq8YtIA8SxwyBqvzS5WwldmtTk32ioCw4guXuoLX1nvBzMKbcXPx37V4ozGRkdQqKsPXMx4m4DBtR/PLVG//7s954zu513/L1n8Qw+6xbksWLPDNfGGPoFncPbwzpJTVK76Pvrn5Ne3qr4dGujvcyx5dEWKLBzTVYnS3x3MsmyP+Xkz9jGrMScqNEimvPGd3N4vUT07EMQRs1ZWUSnlFU71Zo658K5xsgguftf1De8is27srJ7FIH8/dX3TlldNYOG8M4Z1kvziCvVGSoOQAJn02lbXMe1qPpCLGwjosYkd67oZhBBCCCGEnFMoopNaA+HPCv0ffGRV4z/ZyhUcGikhcU3knS3H5Jb+8MZWj/e2OqRjhzYSGxt7FltOLhZKfYimZpEYDkqn7HLFlAAIbxCdVOxBNZzMWkRHvISd2xTHGturmdv+RhEMglO50ynzPkh1E9m0O1m7vbX4jqKfBSWlEhMWLIezi+S3V7SVmcM6K4Est6hcth7MlOWbD7piGaorKvvKIDeL1eaCoXZFDr3hS3w35qnDQWtVCwGiHhy9ECS9tdfOrayBuGgXX4HliO+oDr6y3u0mKyCUVo7oIh07tJX3tuyv0dj4zhaHhMQ1Fr+QBi6n/sWM3QSMvnZMUGE96m+sqMXfmncN91OD82DyrGdijEtEx7OLaCQ8qwtHJ8mt/9zo2h4TPejb6JveiwCflJ9OFMhr3xzwmklufN50H/NWuHTxuN5K0AbY5ql1u7xGrVmhrm9FsrqGge1ipWPjSBnatYn6jAgkPBMVFRXSsEGQrE2uqrtgPJZdzQdCCCGEEEIIudDh/3ZIrYFr1oz5P/gv3NlbLYcQFtpzpLz/xSuSnl29AnpHs0Te3yryl2fvZ1FRYkmQD9HUSlQ1O7Tx+e7BbeSPQztJRn5VEVI7jC5LxEvYuU3x+bEPUmWxIY7BKLTec0Ubec1iP3OMg85A3nk0V5ZNGaAEPXP2OwTEHUdyZFz/lhJgek58icrhPjLIIVZXp2BoTYsjehPfIdJtS8vy6rSHm3b53QPEKU63aIljucWW4rp+CwFuZfc2l3lEYOjzYXl1RXRfUSPG78HoIoZbGLFDN//mbnnqsZk1GhtXfivy+9kPyOTfXqHaWd22XsiYJ2DwpsK3B7Nc/UIXGo255z556c9za3Q/V3wr0uCqUR5/a9C/rCYo8MyUVVaqqB5MrKFuQmx4kFRUVsrckV0kLdN7RjQmuDCpholm8+SX1fOm+5i3wqUALnlMtNmNS/oYxklE83MOdqbnyoIxXWX2yhS34+A5QhzVX/+zW8b2qXqLwpibHhNes0k1QgghhBBCCLlQoIhOak2jBsEexQXN/8E3ikcRSddK3ob/k0kvl8gHDzolwIsJtrxC5O5X/SQsLFTuuuuuc3sh5IJl+6EcJdwYhWWNnThk5dCucDolG/ErFhNDRhBdoIF72liQ1Mx6UxyDFsEgol7buZE89+lerzEOQMe/INd4wRp31zrQn3XhQOQyG68fhQDtvLg6g9ybu1dnkFsVDDWK5uFBAfJdWpbKUtauVF8FVq2ACP7oimSf4h/O8fJ/f5Inx3aTQ1lFyumNsSblSI5Mu6ad2tYopEP4mzuyq4x7eZPbcb9Ny1ITEDo+Bv0Cx0G/eXtLmiooeaZRI7rgpHmSERMB+PecD1Jk/clWIgHBNR4bH/39vRIdffHnoXubgIGQ/lHLGHXvdaHRAc0GSGhYmEx5pUhW/qHS5/2c/IpDAoNDJCLpGsttrN7oqIr6cciH2494TGxNGdxG4iOCvV6H/ttoF7tkft50H/PqcN97UuaO6CI9vWxjPB/65vjLW7k95xrEK5kFdD2pgHoOGB/gpF9+d3/JLCiT9JwiadcoQhXrJYQQQgghhJCLEYropNZAyEChxkfe3+5yg5r/gw/xSMcl+IVESOyombLuvfky6lmRV6c4JSHG2hUIkejjZIesXfu+REdXw0pILklG9kiQOxtEyuxV7mIP3MjjB1mLQ1YO7SZRIVJYUiFf7jlhG++BYyI7GOKxFvJ8OeGNcQxaBOveItrDEW23n56gahQZ7LX+AEQxPHePDKty0eIapl/TXho3CFZOZ6PAqzOdeydGy/6TBco1/vQtPVT2eG5RmYQGIdPdPYPcXDBUO+TNxQeNbnFvBVbtQFzOBh/Xqdsze3gXSYgOVRMf2pk8oltTdZ+fubWHOhbeHEC8BK7xybU7XJMTGgjZyIp+4Yt9buOWrwKpZrAdBH3EYJiLh2L5/NWpHpOMEPv1vzk21h67eKBNHd6TESOGy+i/+skrkytt7ycE9E9S/CTh1kfV92CF1Rsd+C7nYwLEbsJnUGuPIpzVmeDT/QYFdpFJHlFQ6nqrA5NSeCvFG3iO4W73RlhQgJqYaxoVIje9uNEy2sXbmINrQi46+vrDN3SU4rIKaR0frvLgUTgZBZJrGvNECCGEEEIIIfUdiujkjCitqFR5sQ/f0Ek5QsODAtziCrD+hq5NZPuhbHl87U6RNn2k4U3z5PM1f5LEB4plTF+RW/o5JSa8qrAbMtAR4QKXJUSi66+/vq4vkdRjWsdHiDMgSEZ0b+pyEreIDVUi9bLNBy3FIYjhRgELgtZHKemqv2p3sFW8x/zRXVX+8dv3DHQJRDE+hCJjHIMWwQ6cLFBZ7hBRzcVIddE/7GeMf0ERP29op2xRaaV89MAQCQ30U23T7dQiY0EJolaCZM7KFJXrrNGu8TYNq0TEJpEh0q9VrGVmubFAqq+oCHNxRF/4KkqINwE+e/BKt/ZYRcNEibiy6zWzhndRxze6xfu2jJFWsWE1LpBq5mh2kWzcnyF/HNpR/eA7xHfaMCJImsWEyfzRSVJSvt1tktE84Rh6amz85INF0uL+Evn1ZSI3c2ysFlZ9YOjQobJmzVq59ZabpMUDhTLW9LcGGeiIcAkNDZMpj/9dcuO62E6eNWoQop5XY1HOgV7eQtERURMGtVbFQ41vRVi95YGJIIjaeFslLNhfINmv+vGwK2/c+FYHRHJveItc0pSUVagxMCq0oer7iLAxFx0t8DHm6DHpl8wimbrse7fCzeaiyoQQQgghhBByMUARnZwRcOZCSIAghP9IvzbhMuuiZ+3iZOXUQZJdBKGqr3xz+zBZ8tJSWfPtSnl3c7prOxQRRQb6+PHjJSoKUhgh9uw/mS+tm4TIVR0aKmEXAinErp+O58mMGzorsdroBB1sEMPNgpaa+EmMVu5puJAfGdZJCUURIQFKfP50Z7pLaK1OjIc5jgFABDueWyRhwQG2ud9vbUnz2M9cENPOKYtcZvy7VXyEpcgIAXzam9s8MsPNrnFvmeXGAqlmrKIpzMVIrdDRMOHB3q8TIqOx6OrZLGhaW9EPbT+YWSgrfzjsMfGCtwEiggNc595zPN+1HnnonhMp7eTlVl3kxPefyKZ9H8s7zx90bd+qdSuZueB3MmXiBElMaFirtl4KGGOG2vUeJNt37Zc3/u//5K/P/VXe3XzYtV1Mk6Yye+EDMmzsbfLSpnSZ2L+lWm7+DvFGy20vbVRjg37TYkCbWIkNC1LCt9UkGCgsq5CH3vlR3rl3oMwUhxzNKVLLIV4b3/K4plND9XdU94ljuSXqWIgZ0uczPp+IUavOmGO3Dc4XHR7kte4ArjUqzLsYr8cko0sfY63DsVsWju5azW+LEEIIIYQQQi4cKKKTM0LnPOvYFmRLWxY925ehMp0hWE5+/Vu1LKTnCAnuMVz6JQTKH65sIR0TG0tsbCyLiJJqM+r5r+WqpETl0tQCaVFpmUT1aa4iNPCWxERT1vWTH+6U/5vcX0WSIEM75XCO2hcC1uieTSUjr0Se/2KfRzzMxMGt1FsWVu5yc6a4tziQmLBgmbXSOvcbPR/xH3o/LYTBWe8rGgK/d6fnSr82cbb3y5sAXl3XuNEhX538aF/OWGM0DERluzidwWehaKG3yYGaFkfVZBeWyfOf77XNcX9yTNX3iR8IrwD9qHVcuLyx8YCHkLlk4hC5PyRCnn9+geRkZ8r/fbVLvj1aLJUhDeSNXIcc/c8BeWxUuBSXVdaonZcCxr6k34hC3YJht02U28bfLYW52XL0ZJY0jI2WJo3iZdFHu+SbQ8XywK86SEZeqTxyQ2cRh9MVt2QUvFXsjoh8MH2Qmlx78sMdHlnoxjijFrFh6vwncktk6vLvZfX0warYsPH5g6CNyT5zvQM9ubd880HXmx36+cQkUnXGHKttMI7NHNZZHlttXV/BTxzy1j0D5D//n70zAa+qutr/upkHCJmYIcySkAQQFRBiFcWBGaxDhVbAqRaxttYBZB7UtlZr69BWrdX+P1G/+jEJiC3aWpFJcSCBMAsRCFNGMo//593Jvuy77z7n3HsTZFq/5+EJuffcc/Y5Z+99c9619rt2HKOw4CDLOUcW6cX+Mg8XebyH8ztSWEFhIcF+1UNgGIZhGIZhGIY512ERnWkSyHpDcTJkz8JbONjlsvVRfWBYQ9E/SUavRCEWvL4lh2Z1DqeaU5VeNgwMY4eapQmBCUIaLFPW7Twh/pn45fBL6MG3v3KvmpBFPn8xvBdtPZBvCAJBiKqnBWNTjdnl/tiBwOLIboxIEVoV6CG+vXnXQJqniXCq2CYz6i/rEkcvWviQOwngMiPWTkyWgTMr1MxUu2Kk2C+ytOeuyHKfk5WdDkQ7BBfO5Nxg8nn3pThqaVWNaKtqY6VmJ5dV13jNl/06x1oWioWQ+fqUy6miqo7+b3sRfVUYRsGRp8X32wcm0WP/t83js4EUcb3QUG2G1AKuutc9rlN0WDD96h/f0I8GJnmMf7DknkHuQK+OEM3riZ75cKdl0OS+H3QX2eKwTEFfaNsqQryGDyJD+1RlDZVW1opVIyWVNaJIp13BYOxDX9Xhy5yDbZ6+OZ0O5pW5C+8iKHCipNJy/sE895irNw1IiqNPdh+jxePTafbyTK/VPCjS+/t/7aJpw3rSlgPe+8LxMG8tGpdG+WVVHOhhGIZhGIZhGOaCgEV0pkkIoW9COn1XWE6/WbuTJjUuibeiuq7evQRePtTLzL2fXdNDeDVDLEtKiP7ezoE5/5FZmgBC2h0Dk2y3h5ClFnmUpHds5SGo6QLa7NF9jEKQU4azCoQzJyEbVgtSeIJYVlBWTYtXbacnRqRQ7tAKIT5HhgVRTW09FZVVU58Ordzj6FObjHInARwFAnPySmnhqh20Lvu4UaS1s7BRCyb6UowUgvLkIV1pw7480Xb8k9Y6sIVBe+GDjgz0MymgW/m82xVHlQEB3M83pw4U9hcQV/XM8gn9O3oVY4b9i5WfNoRMzIUd4iLpqxzP4pOmPqu28+93D6KLFXWVhdN1grib3D7GuA0EYDuwAsCuyC/G6K8/yKYnlmV52Jnd0Kct3aIU8UQW+qM3JjsW0lVtf/D9ue9EiVuQdlpVMWOpZ6FbkNohxvb8pMc5xub1ye3E93FRRQ2VVdZQy8hQIf4fK6ygHm1a0t1vfi7Ghg4CSLjWe0+UuAMSHOhhGIZhGIZhGOZ8h0V0psnAM/qlRjsD3Q9Zp7qmzjLLr66e6MucQnpiWSY9e1t/zkhn/EJmaUI0mjKkq8d7epZwTEQIjUxrJzKf7axIdCBm7zl2SmSaBppV6SRkQ0RXhSeIWItX7xBZ9bCduOuNz+nlSQPcxfxMWPmQOwngG/bn0dc5BcIGRxXRdTHZyk5i4bg0Ki6vEsKxL8VI8Xtdfb1HMVKIjPL/y6cNEWLnmcZfmxs9IACRE4EPU0YxrDPUlQGd4qPoaHGFbXsg5P7pP/s8roupGKnezosZdZWF03XC6gGrbdSVFCZMxYr18btVC34gAFe3JtvjfiLwhX5kB4JlCS3C6X802x9fBGlTn8Y82CnOXsSW54/PzlqRJVbn3PynhhoSJvQ5E5nq9fX1Xu/ZBaQYhmEYhmEYhmHOB+yfFhnGB8TDeqN4JL2ZTcA/VWapWgnsEBmQmVdQ2pBVzDC+AksDKaSp/VBaO0DkhDgN8XnkH9fT02t2itfxvq8CWmllDV3/+/8KKxg7AQyi8b7jJeKYyBzF77qQbULN5JbC08xlmW4hWXqjO7XTyodcCuDIMtWPK2yV1n8rxp9qIWHK9pd2Eh89fLUQuvETv3dNjKa+neOErY4qlDkVIzUdz+48mhsnmxs1KGEKCKD9lhYZynVTA4924P4iI12/Lk5BnosZNTjldJ0ghFttY/cdhrEXE2l/7yAf6/OKqZ9b9XmV4CAXzVuZ5eG9rgrS6rziNeeUe3+H4vs181CRzXe09/wTFebcVyXY75Sh3YStG0CwUb0O6hzCMAzDMAzDMAxzvsGZ6EyzClAQ4ZbcO5hctNNjmToerh+5sTf98aPdxn3ILFgpLBRX2FteMIwKRGnYDEhBR/XWhq+wudjtSaojzyxoKaCZBFFV4LbLqnTy1rbK5JZCNuxMPNqpZNZjv2/dM5i+PJhv2U7dh/xYcYUISmFMQQBsGR5Cj9+UTFOGVBhtlQBeN3l8I2s8EAsbk6CnYhI09fOw3X8ABUH9WR2givmmgICTaKuvDIiLCnMsFGvCKXhyMaOusnC6TrjfVRb3TM4dQS6Xl/XQkxPSqbyqxnaO2Lg/TwjZ+ioCvZ/g/ztyiy33BUE7LCTIMjijrpAwzTnwdtfBWJa1IIBezHTOmFQa/9JnXkK+1eoVtLF1y3D6048HUOsW4aK9uUUV1DY2XPixwxrqxYmX0vQlp+cWq1UyDMMwDMMwDMMw5zosojNNRhWg8KBcWFol7CAgCEqRLvNwEX227wQ9flMKVdXUNxZq9BYPn72tX+M+uWsyvgFxCwXuRvzxUyFcSVFKemvfmNrW0tpBtyCSAhryKPUgkC5wm2w+9CxlVYjOzi12FwHUCwNCfFqTddRDyDaJb9h+0mub6He39BO+zvNWbPcYS7oPOUQsZLLrRTphuwIxzcqaIirUXJjxqsb9++NrDIEPPtJ2tIr0FLHRxsXj03wSwgMtCKqK7xD53753EH22L0/0AfW66GK+KWvd35UBsKqCTc+sZcgytg6kwHpDFTAhrluJ71arGy4W1OCUXTAMffibQ4XUu11L47XEvX93Sw797tZ+VFJR41W4c9fRYnGPUADW6t5hHyZrM7Wf4P9WhXSloP3tyVLbc0bb9IKqcr6Bl/qSeweJegOyT2Me0esOoNCxFMARbHtx4gBREFd+BsFJjEXYrOlz4uSh3YS9FK7779ft9jgHrDybM6YP/eFfu0VhVVlr4vtaXcIwDMMwDMMwDNPcsFLJNBmICxAmpIhVVn3a0xgP9XiAvi6ljbCiQJbalKFdaWpGN+Gb2jE2ktZuPy0e4mEewgYKCTKMEyseGEI782uFkIP+o4tS6Id9/PDUlgLarFF9RF+NDA2msqoar0xtiZ5VqWYpSxsZXYhG/0ZGa5eEaLdIDBsGK6EfxEV5ZkJPeeNzsf85o/vQ3DF9hM2MKvTJDHRdQAeoO7B5fx4tuWcwHSkqFxnmEM3e2ZJDPxqYRFd2T6DYyFBRHBGf1TPSD+aViuxUX2oWSIGvX+dYS1ET1wMFTfWCw4tW7RBCplPxRH8LgtqJ72gL7pm813pQwipr3U60tcqoR/Hk39zSlw6cLBUe6PqKAHyuXUyER7AFwYZbL+tEszRBUwYdLnZkcCqvtMGXf/5KzyATrtO8Man0o1caPL5fm3wFuWiXVyAKQSb077aGqSM2Kox+u3YnPXzDJeK7zG41h90KA/x/QFKsh6At94Wx+0FWLqV1aGV7vhjzcs6xm29kn5Yivqw7ID+jC+BoK17HXBgVHkKzlmZ6BMZh07L72Cl329WVPup88V1+GU2/rheFBwcRHF6yDhX5vLqEYRiGYRiGYRjmXINFdKZZeOCansLqAQ/S8kFdPqC/8dm37iw0vDZ7VAqld2pFhwrKqaCsitI7tnJnruF9ZGhyUVHGF1wuF81cmun+Xc+yhOiI4nx2INsXnt5qxin28/SabJo8pKtlIVxTVqWapayLSxKInxBBf3tLP3emtF3BT4hgnWIj6fqUNvQvpdjn5V3i6JpLWlN7i2xrZJXqx1aFtpnLstyvX5vcWtjELFq1XYhrELThw2wlzPmakS4Fvq0HC4wZt9gPrrFVVrye6W+1fxOmlQK6+I52oSioalkDAXPZtCHC2xq2K/pcZLpXVisYZGFYiLr7T5Z6Wc3I62cq0qqK92qB1l/94xuvlT4y6PDq5CvoYkdeK1ynfkmxXkL3U2t2iGAR+vPEVzeJcSq36Z4YTe1bRdj2OfQHCPHfFZTbzg1q1jn6+QPDeopgn2RXbrHoG7OXZ3mNrUdu6C3Gb1CQyyubXA/OoF85zTfo16t/nkEVVXVibGPeROAsNNhl/Ax+R1/+7Q/7UmFZFa3beVz8k8h54dKkWI8CrVbzBUT56cN60s39O3JRUYZhGIZhGIZhzltYRGcCBoIOxCEsB7/rzc/dwmV8dJgQxCFgyAd0PFz/9OruNCK1vRDqnlAEPGz7+pQrKD46VGTU9nHIvmMYCQI3MoNZZlRDbJICDopeQhSz9PRtzPb1EMFdJIROZLQWllV7rLJwyjBWs5RVcUkHwlZRebVbRIWwBEFtxtJtXpYJKNS3cNUOWoz3R3jbS1hhqitgJbRhzC1ctd39usyitdr+Ux8yvdWggh7ckKJmh1aR9MM/bzAK6JgzaurqhA1OcXlDFjZEaFW496cgqArEdSnsmwS/y5LiaMLLn4lAhW4LY/K0lysYIHzDukbeo4jQIJq3cjutU4IfutWMbu1jd2+xDfal7o8hv64T+tUvhl/iETiR8wZ8xH0RebGKICQ4yHZu6Nm6hZh/5P0E70/P8LrH6r2PDg8R42Lh+9tp3c4TPq2QiImosp1vcL4IGsxd7lmgFP183uhU+ssn+43niHmotKpWBLt15HjGdzpWk8k5GAEG2N18lePp6S/nj9F9O9DIyFAW0hmGYRiGYRiGOS9hEZ0JCGmFAJsGPLyry8PxYA2bibzSSo8l48eLK2iBItRJxFJ6F9HjNyZTTAQ/XDO+85sPdtLmwxVeNgRSbIJYZVXIUwpR2O4xC0/tLonRYhunTGFTlrK/xSYRjDJlGMtzgYDeo00Ln6+Nqa6AldCmvy6zaO0CAXaZ3lb1EvR9rXnoKksBHfdx8aodHsKfaoWj79+Elf8yxHerAAF+R6BPFoY0BQt8Eb6R0Q6bnpsHdKKJg7q4hVqT1YyvRVqdggaM/XWS/eqZtTu9BGW8jiCNr6AP2M0NWCHShRr6qcR0j+W9x3fqJ7tP0KptR4QI7bVCoqiClj8whIJdQR59Tc45VvONbT9fvcNYAFWCQJ8dqR1a0ZOrPceoPgerx0MAzWnOYBiGYRiGYRiGOVdhEZ3xG9WHeMqQru7X1aXcyG57vdFaQD7E4wHa5BkMsK9f3VDPfqmMX2zcn09B4VHu32X/Qp/b9l2huz9ZiZ5g+ttfGT21H39vGy0cl0rhocE+Zwqrgr0vxSbhK4zCfQnRYWLfdr7oVlnVVqCugF440Upo01+XHt/+BgJ0nGxqcgvLjV7ivlrh2O3fyotciu92AQKIglgBALDv3OKGQI16z+2EbxFkfO8bS3HRlwCEVbuZwK+TnaAM+5Jnb+vv13H8WUVgx+GCMjFnoM9BQLdaIXFljwTqmhhtnHPgrW/Ctp/vOSmCdlbgO/0/u0/4NUbVOVg/LuYTrF6jEyUetkYMwzAMwzAMwzDnA/YqD8M4+BDjoVgKbupDNTLQoiOC3Q/xeM1JkKutreOHaqbJoK8N7ZFAT9+cLvrqVzkFtO9EiXgPmdzI9sZP9DU7T22skIDf8GPvfSMKP+qfdRLW4K8MqyITGC+rM3NpwfvbxTEe+cc31CoyTIhWVoSFBInzQBDLF2CtAIsYiNUSK2Fffx0Z0xDXYKESSKa3BPPAtGE9xfmqDE9pI3yl0cZfXHcJvX3vIJF5K89/SHdzkU7VCkeCIpCw1VCxWikg8SVYp85X+0+UCt92iOM+BxkN4qIIJmZ0CygoItuNczNh9frFiNV1kt9FVv2qRLNAwr3EagI5h5jGHvqYr3ODCRTqPZBXJvoL+pydOD1nRZaxDZhzcGx9HACn793osGDjvIPrFx0W4p4L9DFsN0bxOq61aZ6BxdHBvDJak3VUBNEYhmEYhmEYhmHOFzgTnWnSUnk8FMuiepGhwR6ZZzW19R7ZrE6ZudEG+wmGCYTQ4CCasTTTaNHij6c2+q6pEKgTMkt58YQ08Vnd5xyilLQ7wKh47KYU2rg/jxaMTaVH39vmtT98BqITxpfpPOy8m5FdiyKF8Ehv3SLM6OOMQJiatS49jxEMQCBAWC75kekNIPbBJgfe46oXenRYCCXFRwpBUL0uOM7K6RlUW19HxWXefu4qEKClpZTcv1wVg0Kx8Lm3EzPxHrazQ52v8H+TDYsJu8CMtLSwC0DgumEf6Jt6IVInayKGbK+TE2pgQ/YvpznE7n45gWM8sSyTJg3q4u5nTpnjR4srjPtHQAp9QG+zUyCstq6e5ozqQzOXnS7QjLkAAbiWESGiLoCpngHmWDt08R5zGCyOMNfg/PB7t8RoqkbwnH3SGYZhGIZhGIY5D2DVkmnSUnk8EF+aFCsesv/yk8vEa8hqwwM3HrIfHNZLPIjLbU3LwsFVPRMoKtQ6C5dh/KGqps5o0aKLoE72GFJI1QuB+gq8uyG+47Pfniz18jl3W4ecqhBeyIvHp9H1KW3oX0pBRIyNOWNS6YOsXDG2TOdhJ+RBXMM/icnHeVduMc0fm0bzVma5xyfa99bmgzRvbKrImNfFRLtMb11MVkVBFCGcveL0cSQQ6uevzBLXoIVDQA0CtCoWqvvH9UMR1pPHS2yFTQjtVlYwmKdwn/T/+2LD4hSYQfHIpyekuedFee9KKlE8NYzmiAKQ1sJtc1mIXOiYrhMKEdshAxuqZZmKPvachHYngR3zghpYyTpSRJd3ibdtIwp9WgWJcMzf3dpPZM9j9Qzmm4rqWstAGPr2hv15dM0lrd3FQSFoo28KcVsJRqhj7Nrk1vTYTck+B6FwnOnDeom2LF6dLV6T4//xm5Jp9vIsnwODDMMwDMMwDMMwZwsW0Rm/UX2I3VnoIQcpNirUwxddPnTDpgGZbXJboApoyIx95IbeVFbtXWCQYfwF/QnCkAldBLXy1EY/nj0qRQhKL08aIAr7wTM5ECAMIQNz2ltfWm4D8QpjYu6K7UIEe/SmKqqorqMgl0tYTCAoMKx3G7o+pS39c8cxeuW/+93nEUjGLAr/hgUHUVF5FUWHhwpf9h/+eQP9aGCSR7YpxOMfvbKR/n7XQJo7OohKK2t8Fm2txOQ2MeG2lhrl1Q1Cnu7nLsHrsKAwZXvjvt0+MIke+d+vPexUTNfDKltZXSmg/l/iZMPiFJjBNVyTeZQG90igo4Xl9GjjvcM8CdsQ/do0pRDpxY5+nTAGfPHQt1tNgM8eLiwXIvXsZZ4BD/V+wU7KaTVMcaMtEcYZhOn0jq0o2EVeRUVlUVoZeLML5CBghuxy2a8xJpZNG0ILV+3w6Ftq3+7TPsZjfsJ788ekiv+jrWgzBH+0t1VUKEWEBNPGfSdtg+KtW4YLYb5jbKRoz4lTlYQQBuY39ZzUa+a0yoNhGIZhGIZhGOZswiI64ze6+ISH8BXTh9IX3+YL4VH3cz0tnn/rsSwcqA/YUeHcHRn/GNIjgTYdKvcQqZA5PeaF9ZafKSyvshVSITpB/Hn533vpiWVZ7m2RzfnkhDRhkeIvvma8Q3CDSJtfWk0vfLzHKHplHWooPFhaWd1sGbMQbyHMWdlIwLO5d9uWwve5qedcUmEfLDtVUUMp7WPoyQnpXlY4ENDxOsR/E1Z+0lYinZ6tjCxxBBR2Hy8Rr+urBgC22X+ihGrq6kVmc1lljdinzDK2K3Yqs9ohvM5dvp0euLan+57Y2XgEWoiU8cTJDkdeX6fVBBgPGLOm7G6AfcP322lcIjtdfke+c99gen7dbvr5dZeI8agXFcWYX7L5oOg/KERsAvNBYVk1lVXX0BOjUmhmPYkVMDV1dXRpUpxXgEz2bd1qDeMH38sgJ69UWL3IMSWDPbIAqtxeFdAnD+1GP3plk9g35s1Hb+pNr67f7zWf4fPITpfXhvs4wzAMwzAMwzDnMqxaMgEhxafcogpRGLGquo4Wrc6md3862EN4VP2VIXA9PiKZvstvED2RnZtfUknxLcLFg327VqctJxjGF565pS9VBUV42FrklVZ5iJ46ldV1QmySYg368jO39qP80ioqKqsWGZSwFdELQ0Iwg38xPMZVexRf8EVYlUC80gV0IH+HGAah+Knx6Y4Zs3gfOAntvoj8/hTCxPWFGG3yX2/RWHDYiphGmxPVCkfeX2So437tO2625QhEiDZlK7+16aDxXuF8vv6ukOKiw7zEejUogZ/ymkt7qyu7J1Cwy0Xl1bVCiIRwGh0e7OUhLbfXM5ERNGGaji92OE7jITosRHxGWqCYssWRqW7ii4MFQujG8bEqYcm9g+jzA/li1ckvhl9Cz6zdaRz7WAkDCxWI0xP6d/TaL4p0Hswv85g70M++zikQwS9dmLeafyQ4D3xHqwK6PsZMXumYP6WALufN+yt6WM5nc0f3cb8WSLFdhmEYhmEYhmGYi0ZEf+mll+iZZ56ho0ePUr9+/eiFF16ggQMHWm7//PPP05/+9CfKycmhxMREuuWWW+jpp5+miAgWYL9vpOjw5JpseuCanuKhGX6tJvAeHrz1ZeMQIVwulxDHIEwxjD9AuKkJrqOq2nqqqa+j0qpaIULLfqULW9IDGCK47L96ljY+qwvoEmRFo0invyK6L9YhEiSAWtmdSP9kjKWq2joqqXQuwAnkuZkEWgh6EARNgrcqspmEOxNqwU9kmiJbWz2f0spaW6sWdR6A4GnySbYKSujFDK2uR6DZytOG9aTN3+bR8q8P22a7S2/qkyUVFBIURItX7TBmFpdVng72QIA02WHJ7X84wLfrzzgjAycQiTGedx0roZjIEIqLChNjW/YvCN76eDl5qoI6x0fSvBWegTZ5T62yu4G8v7OXZ7o/K1e+/OaDbJoytJvt3HNXSZUo9KkX9EXg5z+7T4i6CqZVYG9vPijmGWBl6eJ1jSJDxbXR+7k6xuT3ugrsr9QgJs5PnqMecMC+1TnMqtguwzAMwzAMwzAMXewi+rvvvksPP/ww/fnPf6ZBgwYJgfzGG2+kXbt2UZs2bby2X7JkCc2YMYNef/11GjJkCO3evZumTJkixLLnnnvurJzDxQ6EiKdRxK8x4xU+y3bowoLMXkuKi/RbmGQYZIZvOVyhiI/evr9S2EIBXCkYDU9umF9MdihOQmxxhb1w7ZQBe/xUJeXkl4nXdLsQCHfITrVDtg/bOWXMQpSS1hRWAu1VjVYWv56QTo8v3eYhbkuR7d0tOZSY0SDC2aFfT92+KSk+itq0DKenJqSLe6dbteB1X+YBK6E7NtL5egSarYzM+hF//FS8/vt/7fH6DK5v386x7tU5LcJDKCo0xFhEVf6+YGyD77TsC3MMdlhy+7nLs+h3AayCYMzoNiVqH4RlE8aEzOxWxwu8znUBHcj9oL9/812hMbvbZDeE1178917x2h2Duti2ub6+XrQPq23Qx2SxUvyOcaX3G3UVWOe4SOFzjiAjXkfxUAQJdLsi1R8ewQUdU3DA6n055zz3z12WAQfMh+oxGYZhGIZhGIZhzlXOqogO4fvee++lqVOnit8hpq9evVqI5BDLdTZs2EBDhw6liRMnit+7du1Kd9xxB23evPl7bztzmk7xUW4xDsKBXmxMtTPAA/zrU65wZ6LhgbtjXCR1DsBnmmGmXdODHo5qKQQhl4toYLd44dUrRSH0Q0g68BtGQU4pGEkx1WSH4iQSSbuRpmTAwldbF4AxfiCQwe7DDtk+aUPhS6FEO7/wT5UMaiEc5pUJKwrpmwwBfeG4NJ+8ivXrqWeqfvTw1e5rAFscZLoiKIFrigx0fwRik9DdIiLE5+vhhG7zAjsMnI8pyGIVoFjxwFDbVQWwFpK8syWH/ufuQTRTs8OSfBrgKgjGG2Sgz39/O13RNZ5+OfwSqqmtb7TWcdHm/XkiWxr39KWPG8RtFYjVVtni2BarsiZc2lFkrAN1JYzJbkh9zWnuwXcl2r0u+7hXHQh49JuQYxCBQ72mAeahD7rEWfrDm+Y603e8lTWM1ZyjBhwQeJeBPPZDZxiGYRiGYRjmXOasiehVVVW0detWmjlzpvu1oKAgGj58OG3cuNH4GWSf/8///A9t2bJFWL7s37+f1qxZQz/5yU++x5YzVkL64vFptGjVDpG5CikAQoOdPQGWd8P+BRlyDBMId77+OQWFR7n71PRhPalvx1h6YMmXiidvHk05Venuf6qYaiogaCcS6XYjagY2xFzsT2aH2glCEICR0aoL1r/+IJtmjExxtFaR5+BroUT87otfeI82LUQGtRSmYeGCDHRfxS2ngoyqnQrEYPyT1w42MLB2cLp2dkI38OV6BILM+jcJnVZi4ZEis72VpKKm1m0bgnZb+Wg3dRUE40lhWRX9eHAX+tv6b+n5dadXFcg5pKyqhgrK6oyFQ51WqoQEB4nCxph/MjSLFxPq/pzmHlgvqQI6QD+fv3I7PXpjb9t2QTDfd7zEY45y8odHUEq3XpIWMfBoV19HAVEUyr3rjc/drw3pnmA558iAA44JX/T2BtsmhmEYhmEYhmGYc4mzJqKfPHmSamtrqW3bth6v4/edO3caP4MMdHwuIyNDLGuuqamh+++/n5544gnL41RWVop/kuLi4mY8C0YCAey3a3fSQ9f1ErYH88em0YG8UkpoEUbPfrjLmIkWRC5aND7VMfOWYXwZx7KPjUpv32CRoIg3UqjSxVSTHYoUidR92tmN6J7qepFJExCOZyzN9PiMDDjNXZFFk4d09fISV61V1HNwEsKk0J6dW+yTwG0Spn3FF3uZpl47f2xzUJQU1xUCIn42BZn1bxI6rQIUTvZWsZFhoq0QR+GT/diI5DO2CuJsc659F0NAt7JkGZ3egZLbtzR+zilbPDIsyC2YQ2SG3RxWJKBwKMa03f7s5p7FE9Lplj9tMB4T4+dXN/S2FOCvagzUzFyaaRxnpvGOOerpNdk0Z3QqLVq13S2Y49ze2ZxDi8alif/j+xtiO/zkI0KC6P3pGe55qKi8webNiuAgF50sqaQuCQ2BUIZhGIZhGIZhmHOZ8+qJ/D//+Q899dRT9PLLLwsP9b1799JDDz1EixYtojlz5hg/g6KjCxYs+N7bejGh+iDfPKCTEJluu6wTvbHhAE0Z0tVy6Tuy/Mqr68hFLtp3osSvDFTm4sLXcSwLb+pCd9eEKGEloorLwGSHIn2E4U89e1QfIQghc7NleIjIlN7ybb67CCFEI10E1otMmvq0yUZGZjPvOnqK7hzsEn7ZsPtAeyAAt4gIpto6EgUr9X06Cd8Qykxe62qh0eq6er/GoZp9j+x1CManKqro7XsH0Wf78jxsLEx2KiY/etO18yXLX90GBRHRloWrdjSrOC+DEfDD1os0WmUn22UWq6sJRH/AioniSp+Lrp5vnEvfxZCy7SxZMIeEBCPX2hunbPHjxacDBQB9EAI6Vnmgn+rzjbo/1cNc1hHoGBtJhwvLae/xEnftEfQbBNLaxIRTSUWDv3l0WDD9cngv9zmoAjqy66cqGeK+zlGrM4/S5m/zhQXbA5U14jxgyYbizKMas+2Rgf7kzelUWVVLeSWVorgzahOYrJP0dmM8x7cIozqqF9eGv/8ZhmEYhmEYhjmXOWsiemJiIgUHB9OxY8c8Xsfv7dq1M34GQjmsW+655x7xe3p6OpWWltJ9991Hs2bNEnYwOrCLQfFSNfutc+fOzX4+FzMoatavc6wQzCGm3dy/I1XU1tLCcam0/0Sp7Wch7N3/P1vFA3tTRS7mwsWfcawLmuhXEKJMAo2VHQqKkLaOiaAf/mkDXdu7NT16UzI99n/bvLNDx6dbZnhLixRdCIbIi6kKwlRFda3wX0aNgMuT4oQv9lv3DKaFq7Ybj9W9dXTAVjLwclYFPCurJV/GoSmDXGbKQwQckBTrYWNhslMxBRLUa4d5BYKcU6a63pbp1/YU/uW6yOkkGvoCjokgBtomizSKe2iR5S4zi7HqRrUG0a+HtMHBeeD+q5m//hZdPVc5V76LMV4OF9jb7GAOKSirNorluKcYu9KyTL1Hc8ek0sRXN9mu8tDnG+wP1mayj0gP8wZrmV704Y6jopAttpFCtNUc8eSEdPr1+HQqqW4QvJH4jsDfqYoaIcyrgS29EK4+d5RUVouxhABbWWUthYcG067cYlq0OtsjOIY2z1qWSeP7d6Bf/WObh3j/65vT3XZFDwzrQSPS2nsVZUW7ke2OfTwxqg9//zMMwzAMwzAMc85y1kT0sLAwuuyyy+ijjz6i8ePHi9fq6urE79OnTzd+pqyszEsohxAPYO9iIjw8XPxjzhy48hCtpGD0yn/30R2DutCSzQeFCGBHVU0d/W3KQCEU4PNNFbmYCxN/xnGnuEghIEEA2gnRx1AUUxe1nxyfRntOlApBVPqTSwF4woBO9MSyTC8xDSInLDgght795hfGtpRWVnuIvKpwrVu1jOnbnn53Sz8vcUw9FopxqkKqP3YouoBn5ePtJDZbZZCrxQIhAqo2FvoKAF/80yFQO2WqA30bX7zfmzK/6Fn/uAef7D5hFFzRfzAPThnaVfyT/bNd4z2UHtWRYcGiv2IOnPTaJtGnHh+RLLJ1sQIhNiL0vC++fK58F8tsbjsQcIJo/OCwXvTAsJ60QVlZcXmXOOoaH0W/UwrjIhMc/QACumn/EKgxbhB8Qb9+YlQKPVhRQy3CUMAUqzhcNLZ/B9FHIOBjDkLxU8xHf/lkv0fGOjLUreYICNGYI1oZVsjgszKwBZwCaK0iw8T3ul7LxOTxjuM8dpOnJ/unjV7tT09Ip+8Ky+nbEyU0Z0WWsd0IGj12U7Kwspo1MoWiwkPO64ARwzAMwzAMwzAXJmfVzgVZaZMnT6bLL79cFAp9/vnnRWb51KlTxft33nkndezYUSwDB2PGjKHnnnuOLr30UredC7LT8boU05nvFwgD8xsfjCEC4aH80qQ48fOrnEL6xXCXpT3BVT0ThJcqstGH9EigG/q0FUXJmipyMRcvEHn+ueOYEH6QCbl4XJpXwTqT8Ixt4UP+yD++8SoACOsBk3UDQL+G2GkFhCj1WFbCNcbKlwcLRQb8pEFd6O6M7iI7Xc0cxbEg2klxyVc7FBXVPx1FLQMRm+0yyKUVhm5jEYh/OsRGu0x1KVbq2zgVflSLmzYVeQ+2HiwwelkPT2kjiiYiG1jaXECgNWXYq0Uo1aAMhE0ZMGCaDoIWEKTx/WOydIE9ye5jp+iJZVker73/YAZV19ZRGe5lda3I2k5uH+PhH24S0K9PaSPshX71j2/oRwOTvMa/FK7x/SfrGoQ1BvKe+9dut91SVW0d3ZTaTowpu/kIc8STa7Jtg1zALoD2zK39aM7yLDEvyWx0jCusmjlaVE4/vbq7yI5XKa/yHnf/yj5Os0f3oZc+3kNThnazbfdMl0tcHxRbfm39frHyIuk8DxwxDMMwDMMwDHNhcVZF9Ntvv51OnDhBc+fOpaNHj1L//v1p7dq17mKjOTk5Hpnns2fPFtmN+Hn48GFq3bq1ENCffPLJs3gWFzfSy1fNAIWIhp94+H5+3W7x8IxsdX3p+cyRKXTLnze6RUK89trkK0T2LsP4i2onAiAizV6RRS8qYrKV8IzfUfRPL0gKkA1sR2ml+X2IYxC+nLKk1ez0mcsybbM+kfXqqx2KlQguX4PFQiBis1OxQFXELrTZ1uRHL8HrZVU1Xr7tUshDgAHzRG29/4Uf9eKmgYAsYYiVsMlAn4OdFcRHiICY/9DOqNBg6pYYTbOWZ3ncp6dvTqc123I97F2ADDSqfdBkg8M0DQRvEJx6cSICE542OxDWpw3rSXe/6ekfjm1gQ9I/Kc7j3qiFOU22UNhm/thUUUQYfcRp5YcMOGGFglzZpWeLv3PvYMcggT4vqGMI/R+Z83YBNPTtrTkFxuNjXpo3OlVkyKsBR3iy68fCOMA2/ZLiqKau3qHdNeJYqEMxcVAXOlRYTiHBQWzvwjAMwzAMwzDMOcNZLywK6xYr+xYUElUJCQmhefPmiX/MuYFqySDFM/lTCoab9ue7C6XJperIskMBNvUhHCKSi3bR4vFpZ+FMmPOR/3f3FRTVIoYiQoOopraeiss9vX8hJh0/VekWIX3NolaJibCfJmEHo4vBUvw8WlzhmCVtlZ2u26PobXGyQ7HLuPbF0kIXmxGAwPmEOojUqogNqwo7/3YIyrB8QMaqLDoIq5PSqhrx2TemXAGdk179dL+XkHfLgE4i8BFIMc+mkJNXKoIduh0PRFQ14IEg4l/X7/fKdkYmui6ge9j2jO5D4/p1EJn4CCSUVddy0cVmBPf/si5xNH3JV3TfD7rTQ8N7CYEXIjAE9m9PlgrfexmskXMJ7o0sKGta8SFXeRSWVYv+K1ceyHkINUN8XfmBNs4Z3cc4L0RHBPs1bk21D16eNMBR0Labl2C/os5L6P/hoUGWdRbw/ti+HcT7+kofCea2mSNSKDI0SNi64HpghRDmBBbSGYY50yBx6+RJ83ezPwwYYD+/MgzDMAxzfnPWRXTm/Ea1ZIDooIpoUjCUhdJ0TA/yEJeQvcswvlBYXkOvbdrtIVTqGdxF5dU+C8862FdYaJClJRFej48Oc1ukQLiGiCU9wHXByJQlbefhrQr7OFZcdJjPdih2GdfS0sJKbL5KE5uFBc5728T4hDhs9Tm8jv3K9kYo52vl3w7bBvggk8tFs5Z7itNPT0ijNZm5RiEPQhtsJ/QAhszgdSnZ3bJtyDLGPWkVRQFnoOsCumwPUIVF/b7KDN1oLbCgA3ur59ft8cnnnvEfjEv4dM9Yuk1cZ/zDvUHhzt+u3Wk7l+hBMF38hnCO1S/qvZMFQf2xGcL+BneLFwEX2Dupgj6Cz3bzEXzWVUxiuNNqDQjadvMSrhFWmMlrhNonh/LLHYX32aNSPGxyJNjHB9uPiuPhHFA4FbUBcB25TgrDMN+HgJ6cnELl5WVN3pdVjS6GYRiGYS4MWERnmoRqyYA/HPEALMU5pwd1q/chIjGMLyzZdJA2H66wFTQhkPkqPCfFR9Gan2fQgbwy94qJu/72ubAZggikClfo6xCApUe5SeTRLUtMwrWTuIb39WOZ9u1PxrW0tDD5eKN9ajFWtwVOY/a01efgGz15aFchOGIfENkqGwNidv7tKNoKgfjR977xEt/axEQYfavlZ0sqarxsNCB2vrslh2aN6kO5RQ3FGd338o3PRWHIQEU52FyYggfoY6gFcWNqW+rTHisjgsX1l5m3aoYuxEk7Kqs9LYDkubKY2Hx0io8SGc7w3y4srxbFXiGg68K0PpeYvrOk+G3VxwOxGULACUEik6CPlRtW89GTE9KpoKyS3r53EH3WWAzVJIY7rdZAsO5wYblte7FSBAGC48UV1KFVBP16bTbdcllnW+H9sRHJXseFhc5kxYZLFhqVBZuboxgwwzCMHchAh4A+6K55FNO+oQh4IBTnHmjWdjEMwzAMc+7BIjrTJFQv2JCgICGcLdl8UCx7R9amyEzNKfTyNEZxsqwjRWfMs5i5ONi4P5+CwqMsM7jR/6KVzF8n4RmZnxBspr31pcd7yIqEqIMiouVVtUKEhtCkitomdK9kU5a0k7gGX+1nb+vvdSw7H2YnH21cB4jJEK50qyXY38RFnR6DugUORGH1c9HhDcWBkSWdk18mhF6IdNjm/9090LgPFbQdqwVMgp4v2bvwkdZXAoQEuejHf90s/Kg7x0cKX3sUZcQcBKEzUFFO9aSXWFlYIJtfZjGrGboQ2+1WAGzYbx00YDGx+egYF0UtwkPENa2sabBrMaHOJXKVhen7yqqPS8HaV5uh00Ers6A/7tKOYj5a+rMhYiyiT8LjHGPoh3/a4LZqkoVqTV7kVoEwOXdgriksq3LMVm8REYwFJPTRrqP0xIgUkYkPYV2tXaAWRz5UUC76v1xdg6LNH2Uf97BBMhVsbs5iwAzDMFZAQI9P6n22m8EwDMMwzDkMi+hMk5FesHuOl9Cdr2+llyZeSu1jI6lTbCQN6Z5AR4sr6YV/7/EUmHom0tSMrl4eqc3hWcwwkgev7UWxiiDsq/CM31F4Uw3+oKhx1uFiGpnWzi8hU44PKfLCCxyiOLKo8XtclL2wjyxPq+Pp+4agHRYMIbxCeGknRjfYyuio10EdlyYB3mSBo1o0wZYJQQeIZz/9f1s9touNDGuSf7uv2btor9rmzEMFIlt34artXgWNYRVRXhWYKGfyx7eysPi0cXWO7EPyetkJmPPGptKYF9Ybj425Ej7pO3OLhXAaExki+o5TIIexRvabr3Lsi+yCuaP70NGiSmFnJIVh9fvKqo/L+/3Olhy3p7pJuPanbsPXOQUUHhpMSQnRIliNQqTIqP/tLf3cwrWoMeJy0fwxqV77UQNhKORZWV3rYUMFUJvAal5S7VfQL1+aOEBkrr/07722djjI+JdOBx1aRdIP/7zB0iNdLejMgXWGYRiGYRiGYc4FWERnmgwy55C9CoHnxYkDKCk+kvJLUTywRjyIv/TvPd4C096TVE8NApMUl3zJoGUYX0loEU7tWoZ79SddeNbFI/wUVg/Iqv5YC/70SqSrL2ntt6e2LvKCtjGn/x9oRrm6byvPcemlrRf1hMBudx18tcCB0G3K0lUFRl/926VvuAxcxEaF0VMT0mjx6mwvsc0u4NYqMszoXS6tImCNEwhYfaD7Udt5R2O7adf0FAKnVSY/zrNrQhR1jI2kvNIqcQ1wX5ClCyERWcYIioS4gkTbVZFS2vxATGUCx6l/onjwhJcbBF8pDMMyaKFieyT3IQvk6vdv3qg+VF1fL0TthqKxtWK/+pjzpW6DtHZqqFXwjaVwjbkAxzJ5qOP4EON/MriLMRBjFXDE/qcq9ivox7lF5bTaonaB3OabnEL6cPsx91h5/8EMSwEdY6B1yzC3nzwKCHNxXYZhGIZhGIZhzjYsojNN4nBBmdtXVi7fhp3L4zclU+bhQiHeWXka46F+5ogUIUrW1DYIZgzjD1f2SKDNh7y9eyF2t28VYZmlaxK1VUR25cd7jdnFgXhTmwRs9fNOwr4v+7fyHJ+3IovmjUkVorJJYIcdih12FjgQ1BBAQ8Y//MatAgBONjoQE69Lbk13DOribYvSM5Fen3KF2L8U3ZwCDLCVMNlmyHkH7wcC+hMETPi4S1HSyXIG82I3pSCsqdjy2oeucp/LO/ddSfNWZnll0MOaJvvoKa9zQVtMdj+M7zj18f/sPuHue7gvQeSi39zSV6y4UvcxOr0dPXjdJcYVEPAr755oP9Z8FfRh0eJk+yID1GVVNV59VrZJr7Ogo85LsItBfYHPD+ZT1uEi8Tr6PupI4HVTwVDZHgSSrk9pSy98tNs9v0ZYFGyWRV4XrPQMGHFxXYZhGIZhGIZhzjYsojMBcyi/jB5fus2rKCGy1H6zdifNGplCx4orbfdRXl1LD7/7NX1XUE7vPzhUiAJcPI/xlcdv7E2//+SQu+il7IMPDOtJEQ5WIHYISwVln03xpnbKEPdV2LcT5UNcLtp60GxJ0bt9DM1c6i22+Vqs0iojFYEKFCCV/unvT8+wDAA42ehAjESG7gxD9jjuA3yXP/j5VVRQVuVTgMHJQ7kpHsvI+oZojSKj0o/aSfSsra+39MPG68FBLrf4rwvoAEIjCkrKYov6e2gLi+iB42vWtdoni8urvcbvjBEpXt+J8h7NWpYp7FacRGD0bYytT20E/eHJbYQtipPtC8B40fssbIl8qekgz0uOtdzCcgoKcokVOs+v2+PeRmaM261Wge/8Izcm0z0/6C7mquf+uYvmjE71KpA6Z1QKvazZwgAursswDMMwDMMwzNmGRXQmICDiQZizWr6N4mH7T5Y67gdZmjNHpoifsCuADzUXz2N85Y7XNtG916XR/df0EEIkskWxGgJZyxB1A+1HgXp4+5MhHqggZBLl1SKWukWCnd2IrwEBXzLlm7qPqtp6y+xxtBPZt/2T4sgXEFiwo6keyxAfpQCJe2yXZY9zhE3L3RndCGEdVRy8CiJtRje3iG5VYPV0scUU+uX1vWhY7zbiNdzr0OAgEWRgmobsn0eLK6iwrFoUHUVNzo93HXNvo9oN4V7tO1HisarkVGWN7f3DZ1CY2GpFCsDvCE7NWu4ZUFIF/Zsv7ehY+BNZ4qrlkdpnA8VqhY4TOG8Z/EH2Oc7vpX/vo88PFLgLNsP6BoVKwUyLrHYursswDMMwDMMwzNmERXSmCZm6ebZZcFW1daLIIewYTFm9eH1tY3EyVQgsrQw8S5S5uCivqhP9B/8gMiF4I/tTU7KNffXwdsKuSGAggpCVKI/f4Rus1hiQONmN+Hqd/MmUD2QfzRm4gAhqsooAeB3Z4yjGaCdm+opdlv1vf9iXKmrqqLq2jqLDQkQm7qM3EeUWVVBIkEsUhYRYm9Bo94LsZjvKq2poYNd4sdJHFTIxd0KMZKuLpnGqooYWrtrhJV7jewn3F/dZtxtSV5U43T+8f/srm4yfVcHqjtF9O7g985HJjZoDENCH9W4t+k54SLAo6itt1GSxU0lsZGiz1xixWqGDttmttFDrJWBMzl2x3T1X6SsrcE52NGVeZxhfycnJoZMnzd/d/pCYmEhJSUnN0iaGYRiGYRjm7MMiOhMQToIXHvw7x0fS7/+1myYP7Up15JlligfrheNTadQf13sJgU+ND6zoH3Nxo1oYNDXb2MnD26qg5ZkShn0R5fXzV8W0M5mV3Vw0Z+CioqqWpgztRvXK6hg57+B1WFH96NXNzeK3DNEe2cW/GN6LnhiVQsEul8gshzCODNyZ75kzih9sXDUAAfzFOy4V+/Elg37xak+RV/Xq//vdg/xuP+Pb6ioI0q9/9q3X++qqEsf7p71vtSIF/0etED0wg7oBv7qht1fRXLWYqOxTqHVglXnuVKPB3/kMAj6Or6+0sLPDmTK0q3FfCBicD/MVc2EL6MnJKVReXtbkfUVGRtHOndkspDMMwzAMw1wgsIjOnBHBC8IdxKRbLutMoUFBQty7O6O7KEAGj+DgIKLSyhov6wkIA8hgZxhf+N+fDqYyCqOdR4upd9sYigoLEUUokeFrJXT7IiA5eXj7mt3ZXMKwr6K8DtrbJSGqWQICZ5rmClyUVFZTq6hQKiqrpkdu6E0zRgQJL/Wa2nqRsQtB73e39msWex07v3tkoOtip6nwIz57uNFrOiTYZZtBD9cXO8sbpvlWV6G/Yay3iQkXViOxUaFipctXOYVe31vuVSWRobb3DwW0dWBhhpUTDcU7qygqPISCXC4KDXLRM7f2o5KKGndRT9QQQaFguz71zXeFYgWElYDua40GE1g1YQLXA+PqnfsG05RTleI7HAVHP8g6arSYsgOFis+H+Yq5cEEGOgT0QXfNo5j25mCPLxTnHqDNry8Q+2MRnWEYhmEY5sKARXQmIOyKn0EsiIsKo5+8vpl+NDBJ+MeCNi3DaV32MXrlv/tp6bQhdK+2jFsCcZ1hfOG2v2yiH6R2pvljU+lHr2wSQhRA30QmZ6uowAUkX3zAvy9h2FdRHsLVRw9f7dVeq8Kg88amUn5plRB8IdY1h71JoDRX4KJVZBjNWZ5pzIiVlhembFd/7XWc/O6RlW4leOurBg7kldG0t76k8f3b0+Lx6TR7eaYQYqUH95XdE0Sb4Rs//dqeXtYdTNNRA1QYN2/dM5gWrtpum/GtgjGH7O+nJ6RTTkG5EL6l1Ur2kSKaPTqV7vzr6dUPAPcX+5tt0V/f2ZIjaoZERwTTzX/aIAp42tmozRiRTOP6dRCFes9EjQbYs1nZtlyaFEv/3HHMnZWOIJZVLQbQMS7S628IjPVhl7QWc7ep7kNz29MwjB0Q0OOTep/tZjAMwzAMwzDnECyiMwFhVfwMD7ozRyTTff/vC6N/LArp4QE7v6SSvisoN+6bl2sz/gCxcf7K7UJgkf66nxpEoUAEpKb6gDeXMOyrKI9AlWmfakCgsLyKKqvraMP+PLr9Lxvd41Qdx02xN2kKTQ1c4B7PWZ7lJTR6ZOrmFHh4NAdqr4OMWTu/+wfL7YOBqle9FPWXf50rfiK4gUKqWMWzYGWWxxxqJ+QygaMGqDA2dQHdtIpApUVEiAjSPYH+p4m/i8eniaCx/p2H/ehjTz0OMt/nrsgSKyp8qW/wXX459W7b8ozVaMDcAXFfbaMMnMMmCX1SnhPabiW4y0D7ixZj/bu8UhqR1o6mDOnq9oQ/XlxhzORnGIZhGIZhGIb5vmARnQkYvfgZBLzosGD64Z83WooDELfwGLxwbJpxn7xcmwlUSH98RLKtKNTcRT59pTky2psiyqv2NbBj2H2shBat2iEEWGQ1m8ZpoPYmzUFTAhdWhQ8BzvGBa3rSgKRYmr7E06PZ3wAexNKcfHu/3KjwYNv3pXCuF16EkD6mX0fx2lc5BT4LuegDTOCoASpYuPi6ikDew/DgIMuivwjsTM3oRjOXZnq8h1VaVtna8jh4f8YIl09+4bBRs/v+bGqNhhbhoXTHq5tF35Pf+8i2xzGfX7dbzCnynGB7g2CPPBe1oPiTE9KE3QzmJoDaBdRwikIsn2GwQZLi+7O39be0qmEYhmEYhmEYhjmTsIjOBIxe/AxL09+cOtDjQdqE9D3Xs9Tw+7RhPcXndRsOhnECvsV2olBzF/n0h6ZmtAcqypvsa9RMZrtxeiYDC03Fytfe6R6HhwaJoIEpg9vXAJ5c0YAsWTsQULTyx5bCuVXhRYiTvgisutUFEzhqgMo0l6ioGeHyHp6qrLEN0s0alWK5isTpOAVl1R59xkpgRv0Du/Fq5WkuiXZ4H+Pj8i5xXv0S3/1zRvehmSNSRFtVn3RVcEcQoHNcFCUlRFNuYTn9Z/cJEXzHe/jclm/z6cpu8UKAN4GxVFBaxSI6wzAMwzAMwzBnBRbRmWYV9MJDgz0e/qWnLwQhmbUGj9iSimqx3HvaNT0pLCSITlXUiNfveuNz8ZB+NjJgmfOblhEhtpnFzV3k82ziJMpD6IXdCLKlIfD16xzr9tFWM5md7CHOZGDB1yKvOna+9s4Fj8Nowbg0qqwJ3F5HrmjANbUSNLG/IHLRgrFpNP/97Z72Hj0bvOgPNWaym2xZuiVGiznRbg5F1vF7918pilla2fgwgX2fHSmqsN0O92fZtCHC9/uLxmK1/+/ugWJlh36f5Lgrr6r1Cn7V1YscbEtk5jmK4mIc/9/W72ju6FRatGq7R3AGfWrxhDSqqqkTqxesxpKdpzlex/uBrITBd/Y1l7QWXuz7jpe4X8d564I7ajZg3B/ML6NV246Itqje/8dOVdL/3DNIiOUoTl5WXetxLYsbxwXDMAzDMAzDMMz3DYvoTLMKeseKK0RGHB7+ZdE03RcdD+s/vLSj+HeypJKCg1weYsO5nAHLnJvIPodMSbWYLUQqCDboS81d5LM5heHmPBbG0GM22edSSNctKb7vwII/RV4lTr72z9zaz/Ee415IMbO0sloUIsXKmKPFFUKw0++Xfo1r6+vF3CYLKAK9LgRW1Nz0x0/F7xAH77+6h5jncO0x163OPEKff5tvmaUeFRosBE27OfSWAZ2oa2K0n1edcQL3HoV27VYRrM7MFWK1LFZ7be/WFB8dJl6z8q9Hlrce/ELfsuqvaua5/H5Ev31mbTb1T4oTx1btVBa8v50+3nnCdixZeZrLbPqictirRHv0e7yGtiPYjXFSWlEjss7RPxve81wJ48s8i+DD/hMlYg768eAuIjt926FCuvfvX7gDStJn/ZF/fCNek9eyVST/2cowDMMwDMMwzNmBn0aYZiUiJIjmj02jz7/No9mjUiyLps1duZ3G9G1P8S3CG2wlkmI9RL4znQHLXDgMbRRbnv4gm16fcgX9Zu1OL69oKSY1Z5HP5hKGm/tYEHC3Hixw9NGGALcjt9g2m/pM1ScIpMirL772pZU1Pt1jKWY63S/T+xDJ5Vyl21UgI3zPsVNiRY0UA3G98Q/XGatv8H8pjrvI5eHhjm1mjUyh6ro6qqsnIVZazaFzVmSJwowcbGx+YBfy1IR0emJZpoeQrtrvyPu7YGwqDe4WL7a18q/Hd+EXBwsoMjRYCNFF5aeDXqb+Ko+zZPNBj+Ph8+t2nhD/JMh+N3nnm8aSydMcwUeI9TjG+9MzxHamfq8WD0VbrOY1X+o25JdWiUCELuSrfwPgutcrcxa2hW36b2/pF/B9ZRiGYRiGYRiGaQosojPNCiwk7nh1Ey25dxDV1RE9sSzLuB0ezh+6rhf9ft1uD2FP/v98stZgzh4vTryUdhfUuoWXezK624pJzVnks7mE4eY+FjKl9aKTQM8+h3gms6khTqliYXMGFkwEUuQV51xVWytsNEKCg4TdQ21dPW1VVrEUl1dT99YtxLXGXASxEoI1Mmnx09+sdqtCkfXKNcaxpd0KPNdnWsx56vWXftHv3DeYppzq6s4obt8qgp79cBet23lctPe9+4d4FaNU23GsuJJF9DMEfLtRxBKC77cnSz3EZimgi4Dw6D70XUG5KJptAtvMGJFMt/9lE12WFEeP3ZRMH+08LvoNbFAwzuScJPury0Wif/fp0MpDtDYVFvWnroHJ01xaqbx25+Uis/xgXinNXpblVaBXF7Xt5jW7eRar1eauyDIGHHB27953JX2446i4PvqchTbAFodhGIZhGIZhGOZswCI606zggRnLswvLqimvFEvDrampq/d4SJb/P5MZsMyFxfQlX1FQ+OkqtIXl1Y5ikj9FPv2xZglEGA4Uu2PZWbVID3SMsZ6tW9CSewaJ84JYWFJR41NgoTnsavwt8orMWAhvsOrRM7PVDFYZfCutqqWFq3bYrghwul8FZdbvQ8xDPQcZhJB2Ky9PGmB7XqoHvcws7poA//NqiosKo9nLPcXLkkp7/2e0EdemuVc5MKcz0g8XlNG0t7603KaovMZy3pEcKigX9xv3dsqpCpE5LvssAjUQnHu0aeG537Iqat0ygoYnt3GPSfRZHX/rGqDA6eSCcnK5XMJCpV+nWHpt/X63sP7XyZd7CehWcwvGCYJVpvnANM+irx44WWoZcMDr+vVB5r4KLJi+T8sshmEYhmEYhmEYCYvoTLNxvLhCPNBuPZBP6R1bUXiIZ+anTnRjZqguApzJDFjmwsaUqakKjnZF93RQ+HHm0m0ego+dNYsUhq0KQUL8aS6QbQ6xy1TA0E5Yw/WRWeYoAtil0f8YtI35/uxq/CnyKjPGUcjTytoEwPqkwW/ZOsN83oosWjwhXQQMnIJ82Ab3Ui/6KcF1/+DnV9Hs5adtPOz6n/4+rptaEBQFGVXxEn0oMsx+f5FhweJc2dblzAHPfDsiQoMc77tasBNjU7dXkgE2L3G4RZiXuK77jTsdG6sw4D+OLPL5KxCk8fTvhxXNVzmFHu2TmOayuKhQj3GB4sV3v/mFxz6fnpBOneJPBzeBHJd3DEzyaqN6nKiwELo7ozsdLSqnn17dnVq3CPfYLiYyjKa//dX3YpnFMAzDMAzDMAyjwiI602zAj3jByu3iIf3ybvF0Q0o7y+JsV/VMEEIaRAJVBEiKjxLiHsP4C8Qb2C1YAasEKfaooospqxEZwI8v3eaTz7AE/dm2mO6Ajs1ynhCyF73fMM6s/IRNwtpVjdnngdrKNKddjan4oBTShnRPELYS+06UiHsBsRvHnDKkq6VtBe7T7FF9aNexEoqJCBHbZucWe2TuYv+3D0yiR/73a3HtEISwo6qmzmiLI9uJn8dLKmlqRnfqlxQnghiyEKTJY14WirSyy9Gz8yEo1teT7f7Ap43ZwCyinxnsCmXKe+DrfQdybKpZ3Qiw+RKgwj1Gv/nP7hMiANPgwx8hvk9N2d0Y8/BiP1xYbvRNx7FQfBn9WdoS4TsYWM1lV/U8XRPAFGDCPmcs3Sba2THutJAuV35gbKpYHyeBFoxLozpqKOSLYyFQNkdbrXGmLLMYhmEYhmEYhmF0WERnmo2yaixXb3hIh/jz7D93ikJkyIBTH94hrD9yYzItWrWd/t9dA+mf2cfcD/wQBhjGXyA2oRDggve3G9/XhSyZlTxvTCrNXJbpJVw9flOyURCzs2aB2GZXCHLu8iz6zS39mpQt6RayLbKxIYJ9k1MofIf180cBxC6JpzPP/aU57Wr04oNWQhruxbyxqeJ9J9sK+FZL2w3MMW/dM5gmvbbJLaTj2qj3Bv0BgqDJugLXa8P+PCHo6/7RVkESvI7zwXkBtQ/gPBaOS6Pi8iqa0L+j0S5Hz87H+f5713GaPqyn1/5wvOnDeon3ZYCIOTNYFcqEyDt5aDdxD3YcKRIFQE33SRYGNc1Dsk8j293XABW+T9dsy3X3W/RJFFSGkbqpyDCK3OLzdgEoZH73v6NhpQeCNxg//ZPijHMZjgthG+MJwrwpcInA+cG8MmoRHuJutwwS6QEHfVyePk5D8dzR6e3F2Hp3Sw4NSIq1rBHQ3JZZDMMwDMMwDMMwOiyiM81GRVUtTb+2p3gIjw4Lob6dYoXn6sBu8SLjDoKBLM6Gomnrdp6guzK6u7MtF45L5Qdgxi/+ftcV1CYhTlgWtIwIEZmLlTWeYpcuZEl6t4/xsmsB+OzkIZ4itJPPMEDfvdRG5MFxIHaWV9cG7OHr5IX+wDU96eZLO1JZVQ39v6kD6VRVjXvMNRXY4fh7TexQiw8iG3bh+9uNmf/zV24XQpuVbYXMDO8cHyk8yaW9zW/XZotsWLn6QC/AiMxbFCmFd7qV8JnRM9FjNY2V4Cd/h2c7PoftMOe1igwVXuenRfNonzOecb5/+WQ/9e0YS6P7dvCYQxEkaREeTP06xopzRv9HgIXnzzODXigTfSw0OIhyi8rp+pS24v48vTqbLk2KE4I0+iSK3m7cn+fO2DbNQ9JeCb7fvgSoTgfRTm+LfUMoRwAPfudllbWi34UEuWjEHz8V7zsFoEKCXaKvoR/fm9FdBL/h128nvGOu6d851mtelcAnXgaw8FOOX4y75Q8MFeMd4+rypDjxuuzfqj2VzNZ/Y8MB+t2t/US2vh2F5fZzFMMwDMMwDMMwTFNgEZ1pNuJbhInMND1DE8LBg9rSb1mADw/a16W0FUVGT5yqFD7q7GvK+Mqdr3/uLiwqLTJUsSssJIjWZB01Wg/ooqo/qJ7dKsUOGcF4//ZXNgXs4etUkLOmvp5Gv7BeZGzOGZ1Kv2zMxMbx7s0wFxv1BYh3sDcJ5Jr4QjVERKtig3tO0s+u7iEyw3XLDLvMcMw77VqdXtmiC4noD7mFFUL41IN8sr/gHzJyf3ZNT+F9HR0WYissYj/4DLbBNffFXkLaCZVUVotsdRRQhXCKdiAo88CSL2nF9KF0vLhStBEFIdM6tqLfr9tNH+884d4Pjvf3uwc5X2wmIGShTGG78t43Hv312uTW9IvhlwgbqCCXi1xUT90So8XKKswzQO1Xso/Chgdz1lFt5YhVgArbm8R27BPBO1gUvbnhgJhbTpyqcB/LyTcdPudyXGFF2SP/+Ib+/OPLbD8TGhJEP//7F5Y1A3BMiNrzYT2156QIsItM/JxCUdMB4+rh6y8RHuevKoVN5bWRljHo8/h8YVmVYy2Fyuo6DiYxDMMwDMMwDHPGYBGdaRbw4Aq7CqsMTd1bWD7U4+d3+WXivRtT27KvKRMwEB4fb+w/shgfijVaiZ522Zl2Vh+wHULWcCBCcsvI0CZ5+DqJSNU1dULUQoYn7JIg0EFUa2qxXoi8JhHbl2ti8px3i5GNFhYyqGZFeGgQ7cot9rLMcMoMnz2yj/s1ZOfqfAE7Ci3wJ8G5ftn4Hv6tfegqsYrADtmnTJ7nJnQfbAQFZEZxZXUt3TKgkxDV12Tm0sCu8fTW5oNC9Df5W5s8u5nmxcpOCcEM3Hvcm69zCujXN58OkGGVgJcVTK9EWjQuTYjX6CNWQrQ6r6CvoIinHWiDnFuwf4mdZzvagtVgEnwnoz0IbNkRHRZClyXFWdoh4ZiwQ5J9G5nlEMZHpVdQUWm1GFPIlkchcru/G+TfCocKyumSNi1s66zgOhWWVfPfDwzDMAzDMAzDnBFYRGeaBWEzYZFJqhZQUx+w5c8BSXH09IQ0tx1CbmNWHj8IM/6i++LaFQWMNYiqEmE5MG0oLVq1w0MkgoDz9IR0y74JodZK5MHrNYowFYiHr1ORQ9W2BW2YNaqPh1BvJWg7ge3f2ZIjfMYhzqvnh/OCYGfaj2WxxJvT6ZPGIoN3DEyizo3FDK2IjQwTdg4oMjp/TKqwyoDQFxlmbzlBLqLl04YIiwgUV5RCorSAwdyT0SORHhjWkzbsyxP33cp6o7iihhKi7a9Vp7hIkQ2MAq5OBZJNhVplRrGaxY6f+aVVFBTkokdvTBYrAtBuCLayvcz3g5OdEr7n0B/VAJ20goG4W1pVQ6VVtWLukQK607jG6y0iQkR2uF6UU0cKztgPLGLkPqWALdup7hurH/JLK92vqd/NVsI7xvyx4nL61Y29qZ7qPeYDfOaejO50sqRSrARSLZYg7iPDHUExkN6xFT2/bo/l9Zx2TU9hiSNBpj+CTItXZ3vcBwjoUzO60e2vbKTLusSJABavaGOYi4OcnBw6ebJpQeTs7Oxmaw/DMAzDMBc2LKIzzQKWWtshRQU8fM8dk0q//9cuIVIt2XyQRqW1p7+t308zl2W5tw/U7oJhVG9uq6KA6F9dEqJEFqZJFIONxgfbc+nhGy6hKUO7iv4L4Quf6RhnLfiivz45IZ1mLcv0FprHp9Odf91s2VZfsDofK9/3UxU11Kp9mL2g7cM4QwY8Aly/WZstbBimavYni1fvoGdv7echpJtEYvDFwQIh/K7adsQt0MHqwS74EBbsopz8UooKDxUWGfI4Ww/m27Yb3vCXdYkXmduwlIKQiDZPHNTFywIGfQEe6bB4QYa6bgEUExHiGMT4545jYp8Q7rto/ud6ACPE5aLs3GJ3HQndD1oGWPAPwqt+LVXLCxbSvx+c7JTk95w+rnH/Zq/Ishx7dvMUBOHSyhrx2X6dY92WKAgCqf3maFE5ZR0pEp9DkAhgRcPkgnJhASTrk8DLHCI2AlPozwfySunjXSfcgrkU3PHdbCqWKueyW/+8QfyOoqY/q6gR9R4wttAGHH/l14c9AuvYP84RgTBkoGM/Tl7twUEu0R4p6lfWxIhgAs79/qt7iPfR93HuMNEBuE68ou38pTnEzMTEREpKSmqW9jDnvoCenJxC5eX2q3R8pbqS6yowDMMwDGMPi+hMk4E4FBVu35U6N2Zo4kH4tx/spDsGJdHbmw/S7FF96KnVyPb1tibgB2EmEMJDg2nLt/kUExkiijrqRQGx5F8WekQG9azlmZaFJW/s005kH6ufcaJLQjT99pZ+QlTC8VpEhIoMdAjo3xWUN9lHXD0fFPuEIIbMbFgyvHPfYMotqhBFDyHGtooMsRW0fR1nOHdYM0AgVn24VfSsequsXQhgC7QiohDKltw7mIh2emW1osghfJUfGn4JjXlhPV3eJc4tPkIItEO+jyAAxDbcU5zrGwYLmK0HC+jLgwXUq21L6tM+hl6cOMAtaMNjPq4xax/HNgnaahADFh4ABUBxjxDMQB/4TMl2H57SRmT2L1y13egHXV5VLe4bMphnL8/0miPRfuTz3veD7pbZvEzzYmenBOFYrkSorqunfSdKxEoPYDX28PqT49OEsIxVLM/c2o9KKmq85ikEgQD6zksTkdkdRC/+u8FmSAL7qakZXcVn0EdRuFPtMwgSLR6XJrzMUZsBx6yuq6P4qDBa8dVhmjc21d2vZHFcFK+dO7oP1dU3ZIGjeHN0aDC9n3mEerdrKbb90SubxLYoENoqKpRu6NNOBOymZnSnfspqCTneHr8pWRRCRd9Htrod+BzGHrLl9xwvoY6xkeJY2CfOHWMFKzLk/6VtXCCrfJizS3kR+oeLfvzjHzd5X5GRUbRzZzYL6RcByECHgD7ornkU095+pY4duZkbKWvlK1RTU9Os7WMYhmEY5sKDRXSmyRSUVYuHfEvP1Z4JBMtVtbjoL6+/RFhNoJjoOgtRjh+EGX9BduPqzFy3uITfn5qQTkkJ0cZ+BEuF0X07GAtLQqxt3yoioP4HgRf/IIKi31vZNFj5iJtQM5khuIUEu+gP63Z7ZXtCzJ2+5EshPt12eWdHGwpfxhnegzWDHXr2rVXWrqmgK+aFwtIqY5a7zLS+K6O7WySTwr+TDYa8vvp2uiCtFij9TFkRg+sJUbRTbCS1jYkQr+G+wloGfvsojKy3E5/JPFwkrtcTy7wDNDJ7PLl9jBDQrfygYRs0/e2vhIWHZdHVvXn02IhkeuW/+zkb/XvAqr+h/6Cf/HatZxAI2yIb3Grs4XVkqd/79y/cBYAhgMuaDrp4j3v8zaFC+sLgIw7bqTqqF5nrr1sEiWCV9tLHezz6E+bIv00dSFP/toXGXdrRYy789mQZpaTFeK0w+epgoUeWOkTt/nfE0u/+ucuyv0shHXZEye1a0qTXNoksdqvVQPi7Adcbc0JOXhn99P9t9dqnahWn28b5u8qHObtUl50ionrqP/Fxat0tOeD9FOceoM2vLxDiKovoFw8Q0OOTejep3zAMwzAMw/gCi+hMk0Cm5ZzlmbQ1p9DouYoH4TljUunXH2R7FBc9mF8mlov/YvgltvvnB2HGVzIas5ZVSxMIWhAyIUjCQkMXivH71Ze0trRRaGoAx8mmwdf961YssAAxFZfUC/nOXpYpxGYnGwpfxhmy+u3Qs+qtsnatLBzKqmst/c0BMvshwKvCP8RGX66veh9Mx7crUBrkctGLjXObBII6sv+tbHWCXOQloMv9yeOZggnqdiikiPsNz3g7jhdXiv1tU/zwmTOD1XiePSqFXv73Xi87ImwDOxWnsY2+evebX7iz0xePTxP2USbPdCcf8SdGpBiD2egjL3y8x+s9tHn+yix65ta+9KNXNnv05Qev7WW8BgvGpdG8FVkiCxzCdXx0GD2nCeiyPfLYsq9jLkJgc/byLJHFLlag1DcEAdRjTx7aTbwP8V0tPKzvUx3P6v8DWeXDnH1atElqkhjKMAzDMAzDMBe0iP7SSy/RM888Q0ePHqV+/frRCy+8QAMHDrTcvrCwkGbNmkVLly6l/Px86tKlCz3//PM0cuTI77XdTAMFpacLisol4GomW+uW4fTtyVJhATFpUBf35/BeQ+FD+y7ID8KMHSunDyUKjRQWLshAN/lDo58VVlTTrOVZRv9vO7uX5kDuH/YJEF4bimLWCNEYWZ1OxzFZsTgJsDIjU4rNdjYUvo4zX7O+nbaXxQ91rF5X31dFMin8+3r/5Hawu9Gxu56fWmTqY3+wA9p7osQrc/7dnw42CpkAr88YkUwlFfaZ48hyB/C7dmJ0enu6N+N0Fi5z5lD7GwI70n/8CWUFg7+0iQn36G97j5fQmxsOGD3TnXzEpeis+uvjNbs+jjly5sgUkU2v9mXYrrw/PcPY97EaQ445HMvXwuIdWkW6rWuwmgPD/tGbetOUUw21J/SVHaa5Qd2n+p78v7+rfBiGYRiGYRiGYc55Ef3dd9+lhx9+mP785z/ToEGDhBh+44030q5du6hNmzZe21dVVdH1118v3nvvvfeoY8eOdPDgQYqNbchOZL5/iitO+wfigVd/SMfDvHywlQ//8G6F3QFAKTCrgoL8IMw40b11C4qJiaEt3+Z59T2IWzLjt6yyVmSpf7L7BI1Ma+cWhfRij90SzbYvTcWqOKQvhT1NVixOQpouNuO8/BHAmyOr3mr746cqjRYOEM6s5gJZWFBmouvCvyzA6cs5yDarbXK6nlaZ+vllVSKDWMdJIP8uv9ynoAH6MO4N5kw1U1e/LvDtZ9ur7w+9v0nPchO4P073b2iPRI/5KiosxGu+cgeBir2DQCqYy6a99aWX9YlTHy8urzH2Zau+r14Du/MH8thoz6rMXLFqAjY3E1/bLP5G2JFbbFxZI1ez4RqZ9imvn9w3/t9cq4iYi7dAaXMUN2UYhmEYhmEuTM6qiP7cc8/RvffeS1OnThW/Q0xfvXo1vf766zRjxgyv7fE6ss83bNhAoaENAkrXroEXkmGaTkyEfRdCxtnG/XluUQhiwpwxfaissoZq6urJFURCLAC6lyw/CDO+ACE8OizE0uNaL9p4ZfcE0a90ixRfRe1A2xhoYU+TFYsvAqwqNvsqgOtBBRRGVNvlb9a+1fYmC51ducX05IR0mrUs06u4KCxSYP9kJfw7tVvFdC2crqdVpr5Vhn+LCPvscZlta1lHolei+PnTq1E0dDfNGd2HFmj+6Wox0wn9O9oejzmz2K30QCb4qgczaM6KLMv7NyKtrdd8hTkMNjEQzfefLBX9OiIkiDIPFVn2G1VU1q1PnPq4VZ/1ZZWK00oXHFs9XwTcpc0N3sM1MtnBXZvcWvR9eLPr2fX42+KejO7CI37JPYNEwVT8PfKTwV3c9QuYi4/mLFBaXVnVLG1iGIZhGIZhLhzOmoiOrPKtW7fSzJkz3a8FBQXR8OHDaePGjcbPrFy5kq688kp64IEHaMWKFdS6dWuaOHEiPf744xQc7LzknWl+4qLDLLNH8XrLiBDxwAvxHEUa+yXF0viXPhMP0Xj/1ss6CTHrRwOTaOaIFJFdhofj5rTTYC5cvvmugFonxFFtfT1dl9yaPmosUmvncQ0xC1YEgYragdCUwp4mgcpOgFWFNIy7Fo2BLicB3Neggq9Z33bbt4oiy7ZA1D+YV+ZRtBMC+sRBXYQApwv/gQRD9GsBv/dAMvWtLGvgU+6UVW8lHAo/6CFdxTk/flMK/eWT/fTB9lwald7esgAur9j5ftGDNhhjVv3n0qRYURjT6v6hAHBtHXnMV2oQULWJQZ+6O6M73d1o3WMlypusT8QKEIuMeOwXfTbQVSp2Vk/IJIetG/zTTXZbYoVJUqyXHVxUaLCwuZmzPMsrqIaCpK1bhlFNLYIU+z084s9UIJS5eAqU5mZupKyVr1BNzemVlgzDMAzDMAxzVkX0kydPUm1tLbVt29bjdfy+c+dO42f2799PH3/8MU2aNInWrFlDe/fupWnTplF1dTXNmzfP+JnKykrxT1JcXNzMZ3Jxg4yvpxqzR1VPVDysP3Jjb+GpellSHM0b24cOF3guQ8eDMYqLTR3alZ75cDf1aR9Dvdu2FMUCGcaXcTzptS0UFB4lhBUU4yPaIYR0J49r4eUfoKgdCE6FPUsrqy2zqU0ClRRgYYdkytqGIIX/Y9VHaWWNUdCWx0OWKwoDzl6W5SWwnamggt4WlY5xUdQiPMQtcI/r14FuHdCJisqrhD+zKvw3JcNfP34gBWD1rHZpydEiPJgWjE2j+Su3exVMVLNx8RNtnHZNT+GvrftBV9XUi/1BSMf9fl0LDF11Hq3YuVC+i01Bm+tT2oj5B99nav/B/UFA5JH3vhH9xOv+Na7Mwj7V162CgBjr9UQ0sFu8u6gnBOcu8VH0wfajRpFaBuJQqHTw+FSau2K7R9vRhsUT0ugP63Z7fMaf1WByHOjX5SqtQKiXzU2vRHpnS44QxU9V1Igx4HK5hL1Ll7hI+uv6/V6BKFHsl1w0NaMr/XW99zU6k3MWc3EUKC3OPdDs7WEYhmEYhmEuDM56YVF/qKurE37or7zyisg8v+yyy+jw4cOiMKmViP7000/TggULvve2XkwkJUTTovFptO9EKVXX1lPHuAhhr1FdW0dvTh0oCioeKaigmro6GtIjgTJ6JFJ5dS1tbVyWjQz0l/69TwhIVv6rzMWN0ziGkDJ3eRY9dlMy/eL6S4QHuq9e/iaaux9CFLYCwmvLyFCa/vZXltnUusALQerdLTn09M196VBBQ9Z26xbhFBYSJApnQkA6VlxBH2Tl0rBLWguRDuI8fI8h8EaGBgsRC6If9oWCgqYM1TMVVAhMYI9u1gx/q+x0ZOzKgpHR4SHuwpFWRIcFC8sJ3AOsvPnqYAFNfaPBW/q+H3QXRUSPFleIrNoPtx/zEDrlz0mvbTbuG/dkytCubsFdL9zcs3ULan+eZNxeCN/FVkGbf2UfFz9RLLOkokbMH+g7IUEuGvXCesv71yUhinILKsR4VPGlcLDqX44Cy1bbA4x9bI++PGdUH5pxUzLlFJRRWHBD0Gbxqh00b0wqTb+2FxWXe69S8cUuCec6c0QyPXojCifXit8jQoLptlc2GoV9fPd/8POrhF3Nb9bu9AoOwaJo3vs73K+pnvG4fu1bRYrrcG9Gd1GkWbV6ORtzFsMwDMMwDMMwFz5nTURPTEwUQvixY8c8Xsfv7dq1M36mffv2wgtdtW5JSUmho0ePCnuYsDDvBybYxaB4qZr91rlz52Y9F4aooKyaHnz7K5Et+ft/7aafX3cJPfNhw4OxujRdX36O15GFC+9XPMwj65RhAhnHWAnxmIvo9r9sEmJoU7z8ffEB9geIVVb2K+j7CACoKzn0jEo7K5baunp68d97jdYOz/1rN43t14Eef+8bj/3j/QeH9aI/TRpAP3vrS8eigxCVz0WcMvz9DYag+OvCVTt8toYxZSWrxRxR9+GpD7LFvZl+bU9RPFEXFJ2uvVXhZrRr0bg0sU8nH/hzgQvhu9guaAMh/Vc3VAkbEtyPeSuyqF9SnLAqwf3X7x/6CbLJZZHNQAsHq/tzsndCG2Yuy3QfW20P9ok5BsWaVXyxSxLbGOaYR29MpsHd4+njRpstFdgQRYQF00sfe85dAMfCKg6I5mijVY0L2NCgpsoj//hGnJs69jggzzAMwzAMwzDMBSOiQ/BGJvlHH31E48ePd2ea4/fp06cbPzN06FBasmSJ2A7+6WD37t1CXDcJ6CA8PFz8Y84sWC4ul6Dj4fzZRgHdyZ8azB+bSumdWtG67GPUMTZSZPCxnykTyDiGry/6G0QjK09qCEDw8g/EAztQCsurhKgNdLEbfV/1PVZRMyqt7E/iokJpdN8ORr9lZEibBHrZhtHwafah6GBFda0Qys61celU0NApGKJm2PpraWOVlazOe2pGsZUHOmpA2IEMdiGE5hS69wnatYqgZV8fplf+u18IiOi3f797EJ2rXAjfxU5BG1gjFZZV0QeZuWLMbc0pFPcc46tPh1buLOrYqFCxOuWVT/YJyxSIxOp85E/hYLDr6Cl68Npefvukq5iyt32xSwJiG+Mcs5MevylZnLOeab5wXJrIerdaASNXYfhibyPFdnXsNXcglGEuBHJycoSdZlOToJKSkpqtTQzDMAzDMOcTZ9XOBVlpkydPpssvv5wGDhxIzz//PJWWltLUqVPF+3feeSd17NhRLAMHP/vZz+jFF1+khx56iB588EHas2cPPfXUU/Tzn//8bJ4G01hYbEj3BPEgi4dzNVvMaWl6dU29sN+476oewublk90naGRau3M6q5I5d0HfwdL+H13emZ5Ylmn0uIaXfyAe2BJf7A1UWoSH0h2vbvayc4DYfaig3PZYVhmVahtQdwD2SItW7XBnOuNckAU7c2mm8fNSSGsTE2FbqBS+xlsO5NOfP9nXrD7D/l5Dfwsa4nUUfNx3vMR4DD3D1l9LG7usZHlt1Yxh3Bf0N/QvWLyUVNQKMRW2V2pRXP3a/3f3CeGBPW90Ki1atd0rm1lm3pquAfP9Bm06xUVSUnwUHSmqEAK6vOevTb5CBJbVewch+ekJ6W47HtQWmbF0mxCG7cdjIrVpGSFWNiAwg8Kkg7vFU0hwkDuYhhUQsPopKKuiEyWV9OLEAW6rEzk/mLLZ9blG7+O6pQqsWCJDgmnrwQLj9UD7sQ8E1mePavB+Bzi/kX/81HHFkD/2NurvD1zTk2rr6mjn0WIKcrmEtUzCOb5Sg2G+DwE9OTmFysvLmrSfyMgo2rkzm4V0hmEYhmEuSs6qiH777bfTiRMnaO7cucKSpX///rR27Vp3sVH8wSczzgGWfn/44Yf0y1/+kvr27SsEdgjqjz/++Fk8CwaUVNaIjMqXJw0QmeT+LE3PK62kqpo6t8crxIMruyfwAy/jFxCXMg8XCbEEWZ9AWqBIj+ugIJcI1EDAtbNIscMXewMd7Bf2BSYhaMk99tnDpoxKqzas+flVVFJRRS0jwqiqto7yS6ts9y3HJsS1FydeKgQn3Zpk2rBeIhMdGc/N5TMcyDX0pbCnui8UekTB43WNftXqMeBjrh/faZ7SBUanrGQZKJGg/1kVl1wwLpVclE3rdh43Xvtthwtpwartlqt5ZCYuc2axC9rgfp04VekWff/3p1eK1VUuF7mtzVTQ9xDkk4EpjNf+SXEicxwi+Ni+HUTQRLdImTy0K93+yka6rEscrXowg9ZuzxUWRL+7tZ8IIKIGCbKz56/wXIGiBlwgpJuy3fW5Ru3jVpYqCAao+9UR/fe7QrHKzCqgZxeUwPX2194GAYV9J0spPCSYjhaVC//0p9dk04JxaefcahqG+b5ABjoE9EF3zaOY9g2rPAIpurr59QViXyyiMwzDMAxzMXLWC4vCusXKvuU///mP12tXXnklbdq06XtoGeMrh/LL6PGl29wiATI6VZyWpocGBdHm7/Ldv2M/c1Zk0YvNmPXKXNjAumXe2D70zx1HPYQg9B/4XM9/f7ulYOtPH/PF3sC0PzuxF8UF/bGWsWvDk6sbCgTC9xjv62NRR45NiF8IQECEmzKkq0em/N1vfi4y2iHUOvkM+5Jd7nQNZXFGXzPU1WCICJagcGpIMC18fzut07K75THgJa4f32me0gVGp6xkef1kRjGu35LNB0VWrsxSl8UQn1q9g+75QXe6Y1CSEFDbt4oQgUVkESM4OTK9Pf3lk/3G45isOZgzg9U4xj3GuPv1B9ke/t9YSTBndKrlvVNXOKDvSv9v9JXQ4CC69wc9aObIFNEn8kuq6IucArdYjf47d0VDMeUXP94n9tOjTYOfuShSrAjo2Cf6HQqY/vnHl1FIsIvKq2rF6+rKFX2uUfu4laUK2lFXX28ZyImNDBXWLcg818H4wDXSrWDkNd12qEgEwzCH26GPXcxTP/ufL91Bqpkjk+nSLrG2czTDXCxAQI9P6n22m8EwDMMwDHNectZFdOb8BoLYTEVAB/pSdCeriA6xESITVn8wb66sV+bC5bnb+lFcbCvRx55ak02P3NDbQwgKVPS2ws7Cw2T5oWKX+e6PtYxdG3q3jxHjUYpSTiLV8eIKOlxUIX6/vEs8TXpts61Qa+cz7Gt2uZNFxMlTlfTB9qNu6wlfMtRxjbAtROdnV+0SbdUFdAmucWlVjdfrdvMU2gBLCLWIp1NWMvaHc3h9yhUURC66PCmO+neO9crklb7VFVV17uLMv1nrmbnslO3ra3FSpunIcZxbVEGF5dVUWtnQl3QBHWDcIZvcbqWADExBsLbK9pZ9RLVjAbB++VlFjUeAyzS+rPYp+xRWyZjmGrWP+2OpovZbCPvIBjf1W5zP8mlDvVZZqF7uuNZ2Y1MtnGr6HRZN9WuyReBMBhv47wqGYRiGYRiGYQKBRXSmSYgH9r15HkKYWIrerwMtQvbv3jx3QT1X40O/+oD96I29xcO/6QHbKeuVYR7+328oKDzK/fuvbujts2+1k+htwsnCw6nPWhUH9cdaxq4NutAlbVqIXB5+3xCaUIgQx+hcXEFXdh9EtXUwgbDHquCqHqxQ54Ps3GJxTrFRYRQREkSVNbXC9glZ2NsOFVK/TrH02vr9tl7fTgEPHP8/u0/Qqm1HhNA2aVAX2/OwEvRMhT8xT00b1pNG/PFTj6xdiI5WwY+GoolVNKF/R3HNfnNLX1FEcdHqHZaWLAgAmbJ9cS37dY51ZxFjftX9rZ2y6JnmRfbDw4XlwoYMKz50AV2C78ApNisFZGAK/QSFgOX914NL+B1jAIEWtf8igx3byP3o84NdYW/YN33w86uEN7/TChp/AzVYHfTk+DRRfwIrS0zgPL7NK/VYnaEWRsb7eE2OTfRyNSCIY0xRCqciYDh/bBrllVTSjX1gC+iij3cdEysBEPTwZTUNwzDnT5HT7OzsZmsPwzAMwzCML7CIzjQJPLCbMt3w2pxRfeiJkSkEU9i6unqaPqwXzRiRIgrpVVbXUttWEXQor5xCQ80CkF3WK8OYgEVBc4reOk4WHk3ps7rADmHYVBTTrg260AURavqSr+i+H3Snh4b3ovp6EnYnEKo+3nmMnl+3VwhzUgh08ie2ErHVYIWld3LPRHpgWE+6683P3SIgRK9B3eLpq5zTmaMmr2+rgIe0j8kvq6L0jq2oTctwujejuxDokQGui80StPHtewfRZ/vy3O/jH8Q4CJnzx6SKDGPUd/jiYAHd9cbpNgO8BtEeGby/GN6LnhiVQsEuFwV7FDCMdm/fKoqEiG7KpJXnO2OEyysI4ksWMax2IDpCvGe+P3CPMSaashJAtVDB/lAkFL7hdmNIX5EgAyhyP/r8YJdBjjGLoIwvdklHiytEMVMp6ksrIjl+YDuEOUQVwhc1erXbrdpoGR5i6+eP48ix+c59g2lqSZWwo4mPCqOwkCDx98RffnIZJbYIp69zCmjMi+vd1wbjZPqwntS3YyydqqzxCDYwDHP+FzmVVFfa139hGIZhGIZpLlhEZ5oEHthNmW54iEXW5Xv3Xyl8mk1LtV9bnS38XEsrvYVMkz8rw+i8+9NBRKHR1DIihI4VV1BctLNvtZrhWV1XT/tOlDj6bkvsxKDm7LN21ih2bYD/sA7G4vPr9oh///rlD4SwpX5WCoBOdibtYiIs26sGKyy9k/eepDry9E5GVimObrK70C0i9ICH6RrJzFQp1OvFFAFeW5N1VBwvQ3sfovg1l7Sm9o3WMQhi6MUQ0X+Q3Q/xUH1P3h/hb23whi8zWMh4XMPyGi8x1i6LGEDwRxAC3JvBvujfNxgTuO9OKwGSEiKFABwdHkwlFbVivkIx7m7xUR7zjuyjvo4haV0ypm97935aRISI1RNyXPhSMNeplgH+f6qiRojUuqi/5N7B9JdP9oqgkkkMl17tgdSEwPjEfCe92z/dc4Iu6xJPL3y8x+PaPDUhjV75ZJ+XbZXcZlR6e0rr2EoUfuW/KxjmwihyCnIzN1LWyleopsb++5VhGIZhGKa5YBGdaRJ4YL+ye4Lx4RkP+k+vybYUgLCEG/7HKKKHB1s8bNt5QTOMzu1/2ey2cxH2ARPSPd7XBWerDE9ffLeBv/7lgeCLj7upDRDOOsZFeghoKmgjMrX1z0oB0M7OxOnc1GCFv97JdoUxVQEQ4p4U+2rr6912USqwi4IpjRQZ9Yx21WtZbu9yuWjFA0OFtYVuoYPjyOxamXkbGRpEf1v/rYc1FcD1xH379c3pNGNpQ2FX9drPGpVCdiS0CBOWVypO1xIZ891bNxSTZL5/5Hzwye4TlgGo0entKCw4mF742DOYjPnqKW2+kuPIlzEk+/K7W3LcARQEllBsdPKQrqLYJ7Z1Evgjw4IbCpHa1DIQtU+WZXr1eeE3TvXCb/zWv2z0sqDBmEE7nCyrcB1mLN3msf+hjQGx59ftdo/fPu1j6CVNQAewjDHVfVCvFzLW7VbTMMyZojksRxITEykpKYkuNJpa5LQ490CztodhGIZhGMYJFtGZJgHLA9gYmPBFCEBhtpf/s5eW/WwI5ZVW2XpBM4wdEGBmLcukZ2/rL0QVk+htleHpT6FRf/zLnTBlgGIcOPm4I7NTtqGwvIoqq+tow/48+vFrm+m1yVeIYobrNcFu8fi0RssY8mh/XNTpQAPEZVwj6U+MzHYcS15PK9RghVPmq+l9q89IAfD6lDYUFhzkFvsgbDuJZurvM0YkiwxzZMvqxTnltcZ5qkCQ1IV6CHuzRvahZz7cbTw29lVcUUN3DEwSAqe0u8B1GZFTaLuKoX1MhLgX/mQRy6KWzNkD88HItHYimDxnRZaXGD1jZIoIruhzDsbnE9p8JceR032HzRCC0BDQ4b8vVz/I4NuGfXnucRwfHSYyxtWaCGr7vswp9JpvYFeEwABWZiBjHkK71ZyE8zhSVEE/HtxFZHt7WdA0BuFwnUw1IdBuFPrtnxRH92R0p1ZRocKupaC0WtRp6NOhlSjKK65PS7NY7sucg33ZraZhmOamvAh91UU//vGPm7yvyMgo2rkz+4IU0hmGYRiGYc4nWERnmgREOPiSmvDlwRYiGR7CS6trxUM0wzQF9KWC0ioP0VcVvVHU0iqw40+hUasCoc1h2TJvbKrbvsCEtDWRx58PobdxH/As/s3abDGWIOKa/Ill29X2q4EGeX1kdr2TgC7bIvfhlPlqet/0mrSqQDvmj031yO72V6hHkOHO17d4XFM1azavpIrq609R25hwT0HSsIrGyUcfhR6nvfWl+xykXQyu/5qfXyUyha1WMbQiEv+X98LpWrK/87mBHE8vGoJrKGhp5YVvmq8gimNusCMmIqShaG1GN/c4VusSoJ+r9UnEChPX6YCRWgB35B8/9di3ulpH2hWhELBTn8/omUi/X7fb24Jmz0matyKLFk9IFwVGPS2Oaumx/9smgk4INvW/I5Z+989dXvZvsKsRc6JF0MiXOaemtiEj3sm6hmGai+qyU0RUT/0nPk6tuyU3Kdt68+sLhAUKi+gMwzAMwzBnFxbRmSYRG9ng9YtMV32pt9ODLQqRbdzf8JnDBeViKbuTnQbDOIFMYCuR66ucgmYtNHomLFvmr9xu9Ag3CaeqcKau/vh45wnjZ2WQwCQkmbLrgam4qQkZrMgvrRIFQ00Zo1IYV0GWLPzsPV7rlUgLxqaK/8OqQj9Pf4V62E7pArqdrU9Fda1l5i2ycu3AviW6nUx+aSXNHt1HWFyUVTYUY9RXMahBH2xnZc+DOTfCoigzc3bQg1MQwwvLqn2ar2RQbevBAnH/7bLHOzZmdXvux3wcWZRTWhbJ8Y0xcaigzCtYZ1qt48t4Q6a3KViA8XD7wCR65H+/9pgTcB7ThvUU5ztlSFdb///Fq7OFp3xosLkdmFPs5pzjxZV07FQFxbcIoydX7fBqhy9WXgwTKC3aJDXJsoRhGIZhGIY5d+AncCZgIMRh2fgz/9wlvEvxEKuCB1cIASYgAKG4GrLPJMi+xD4ZpikgS9P6vdCAMnvRLyEmQ4RHIdKm9lNdFFbB60O6e44lq+KlunDmSxFBiHWwRbnuuU9owssb6LpnP6EH3/6KSqtqhaUJstjxE7+btrPLkoWwhzb96sZkMcZVMBdMH9bLY8wLX+eMrnSipFJYtODf2oeuEtYzCdFhwu9b7lNFFkE1oQv1uGbSskbiZOtTU9eQtWqF3bF1cAwEN0BBWTXd8Pv/0k3Pfyq8niHIm4ISeA33oFfblvT0hHSvayn9ohFw4Tnz3EQGyqIjgh3nKzWoBlEb42zy0K5e/cmu9oLd3IZ9QkCX4xv97pF/fGMU+NFX9XHRIFIn2o43fJ+bkGPtU8NYQ4FQvI/Pww7HKmMf1wVFQWHzYmqHKPI7MsXrPbQNc0731tEE1zkE603t4L89GIZhGIZhGIbxBc5EZ5okBLaJCRdZr5v259P/3nclPVRTKwQoZJ/BK/2yrnHCxkAVDPGg+8iNvemuNz4XD/f4HQ/R/thpMIwJiI1x0db9Ry80aidQO9muNCV70SprVBIeGuTVTpOApgtnThmj8FJ2Klqq+yvr21lZM8h2RYWFCLFKt5TJPFxEWw7kiWOgHfDzxrifvsTToxxC+t1vfuFxjeV5SguWAUlxlNEjkR4Y1lME8iCiYR8ZjeKyLByqWtJgX/KcrOo1YP99O8eKrFpYWMhionL/4N+7jtOD1/YS/9dtJyDY4X0dXANd3PfVh7+qts5ozyO93XnOPDeRgTJkWZtWaqnzlR5Uk9nj0tccKxYQCLKrveDr3KaO7X6dY70KopoCcej/S+4dLIqI6sU/ZXHTWwd0Cqg2yr0Z3enrQ4Wi/oLVmDtNPS0clypWsGFMy+KlR4saAnv4e+Oh4b3cf4MAjMe/fLJfjDMr+G8Phvl+i6U2R7FVhmEYhmGYswGL6EzAQEBTH7hr6uu9PFGvTW5NC8em0sH8MvGwC3EKD8B3vLpJPCDjIRwe0D96ZeP3aqfBXHhAkHpqQrqth7deaNQpw9NOTPa1EGkgGfGwSfKleCleU+0+ZIa2KaMT54jinE5FS3EMq0x53ZpBitrInIe1SHx0OH1xoEAE16yEMwCxTPqG68g5Rb3GOE8UF8WxvQoX9kyk96dniExTKc4vuWeQ1zWDGL94XBrtPVEihH7TuZksXlRfc8xZmYeKaFy/DjS6bwd3AVYI27CkgQ0MBDsdiKBTFXHfdM3t/KbtriXPmecmMlCG+eOtewYbi/3K+epIobfNlOprvnzaEK/Ct4HOberYhlAt/NKVgJApEIe23PPm5/T6lCtoWkWNKAgugznvbMmhRePSxPgxifh2q2PwmfaxEfTq+nx6ft0eyzEHkuKjqE2LcFHE9IPMXI+McqyCw6oV7EPdj45uJaWCgs50ooQ90hnmeyqWCqoreQUIwzAMwzDnFyyiMwEDIRD+xwBC2jMf7vQS75ClXl2znfolxYoHdlnIDwUO5UP4iVMV9KOBSUIw4EJ5jD+8+9NBRKHR1CIimGIjQqlzQrTjZ1TPaTuB2sl2pSnZi75kjfpSvBTvQ8CatTxTjD0pirkaixZKILRDsCsoq7TdnxRkrTLlVRsUXXRGUVPY3XyVU0jv/nSw7XHsMubV9+Q1hoCI4qIoQuhVuHDvSVrw/nafAhqxUaH05oYDNHlIV9tzU1F9zb/OKRBz1S1/3kg/HtyF+nZsRUeLK4RIDhH9gSVfemXP4tpDXFcFQX9E8EAtiJizi7xv6L+TXtskhOzHRyRTSUWt13zVXPfYl7lNHdt6xjsE724J0ca5Cfv847o9dM8Puokxim3xXQ5/djsRH2PDChx38aodtmMOcwva06ZluHjtqdXZXpYs+P3+a3raXhu0EzY5VuB63faXjeyRzjDfQ7HU3MyNlLXyFaqpMRcLZhiGYRiGOVdhEZ0JGBQmO15cIbLG9CXbMkMVr+Nhu0t8lHhdX6ItPV+xnZWdBsNYcftfNlNQeJToO3bL9XV8EahVwUnvz9JyoLTS/yxgZLcj6xErMOBprdvEWHkeWxEXFeqRFR0aFCT2DQ9heB7LYBWE5lmj+ohzMYm5qlhnJeqp41wXndX3Pso+blnoD6Ly8VNmMd9UeFSKzBXVdZaeyb4GNKTQ98nuE14Z+062E0+MSBH/l2I4LCOe+iDbI6BwaZKnnzTu58JxaTTyj586XvPmtCBizj7qfUPfhEWRRJ+vmvMeO81t+thWM97Bx7+62iiGD09uTb+6oTflFld4zIH4Tv+gS5w4HwjPz9zaT9SPkNnqCCBZrY7BCha7MYc5TZ0TsV9TsVWAFW5WxVgx59TU1nuNT9O809RVRgxzMVioNLVYanHugWZrC8MwDMMwzDktouOPsE2bNtGVV15JycnJtHPnTvrDH/5AlZWVYnnftddee2ZaypxzwDahXatImj6sp4dAZGWLkKEt0ZZ+qvgdD6z+iocME6jw7CsQnOxsPm6x8AG2QvVXl8L8z67uITzQYeFi53lsBba/+pLWbtFLZIR/WmAUiyB+zRndh2YuzbQV66xEPdWaQRed1fde+e9+cc3witoOzAFTh3YlF7m8hDV1PjCJzE4+8r7amkDoG5nWThQynLMiyx3EcCrKCksqnC/uG67xjaltqU/7GLo7o7sQE3H9kaUugxndE6OpfasGa6HLu8QZBVKIewhG2uGvBRFzbuDPffu+7jECeCFBLg8LKBUcDwV9cTyZ0V5QViXqHyQlRInxoo9Z+Z0u7FBQPLe0SgjoUmSH3QvODegBJqcaDqi3oIrZdnMAxPxl04aIzPZPtTZi5clL/9lDc0en0sJV2z3agWDfZG3eYY905lyCLVQYhmEYhmHOUxF97dq1NG7cOGrRogWVlZXRsmXL6M4776R+/fpRXV0d3XDDDfTPf/6ThfSLBHj1PvreN/S7W/pRx7hIR1sE2Eu4XC76v/uHUG19vbA/gKAIQR1+p+15+TTjJ0unXUmd2yba+qA3BYjJEJ2tbD7mrsjyKMaJzO/SqhoqraoVhfJgQSCFGN1fXWaASruCpmQ+qjYOlTWemaUqEIdmjUpxLFpqJerhnCS66NwyLEQUBYUfOiwrWkWG0OM3JQvLp6AgF4W4XLRhf54oJAqkhQRIaBFO67KPeVmeQOwLCXaJa9ectiYyW/fFxmuGuSyysRChFRAFf3l9LxqR2l74W+sBFVwvtf3wsZbX03Qtpbg3e1kmLRiXZmsf4Y8FEXPuIO8bBGbUA8G/sqoaKquuFX1avX9n+h7LAN7WgwUNAa76ei9RW58D5Ly2Juso/XX9fkvblft+0J3qiWj62195iPPIXv/H/VdSQVm1KMY7e1QfYTXlCmqo+wBx3o5qbY6xmwMw7nBOT05Ip+8KysWY1ovwYs66/6oewhqquraeTpU3FEbOLSr3WqHDtQaYcwW2UGEYhmEYhjlPRfSFCxfSo48+SosXL6Z33nmHJk6cSD/72c/oySefFO/PnDmTfv3rX7OIfpEAr1OIQ6+u3y/EMGSZQii3s0XAA/aRIeViabsUnpCpJv1OGcYfbn55I12TluTlYQvhB2IUMhchkgRaLA6fGZAUa8zcVjMWIb4gU/mFj/d4Zjk2ClNo25nyV1fbin/wJbejvKrWJ7HOJOoha1oK8GoWKT7fIT5SBBX0zPM5o1OpqKySbntls8f+1Tniw19cRdu+K/SyeoLIPOIPn4pM7qdvTvfZ8sKX+y+3QaZtdW2d+GllO4H72C0hiqLCgmiBlslq8nDWRX2TzYWnuOdsH+GrBRFzboF7hqCaXqDY5L3tdI8Dndf0AJ7qg+4u2qkE/PyZA9H3fzn8EpqPVR3KuIAo/aNBXWj28iyvzO85Y1Lpv7BU6pFgmRUPaxaMIQQmZbucbG86tIqkw4XlNOk1z7lGsu1QEXVKiPRqE+YpFH+Fdz2uL+BaA8y5BluoMAzDMAzDnGci+vbt2+nvf/+7+P9tt91GP/nJT+iWW25xvz9p0iT629/+1vytZM5JosND3Bm692Z0pylDu4lsNCdbBPk+PoesNGSOsTjEBIruYatapkiaUizOystagozHLQfyadW2I95FL5W2NZcdiZOYhuAW7EZ0/3ZZjwDikK+CrGk7mVUNEViKzggU6AI6QFANWdsofuqLsA+v9Jz8MvGaKjLjHsM/HsVRn1iW6ZVFD9/xA3ml1LK0isKCg2jmskzb+2/qI9cmtzbaPUgxf9QL6+nVOy+39GWXHs5WPtbIup1oIe6xfcSFiy5gS/z13m7KvKYH8HQf9I8evtq2DU5zIDLs9foHVivSsB3qM4xKb09FFdXCDk7PihdjbmhXuv2VjXRZlzh3IFKukNGvA7afNqynyPh3uUjMf5jvZDvkXIhgwcZ9eaL4sWmewnEQ4OdaAwzDMAzDMAzDNIsnOuw4QFBQEEVERFCrVq3c77Vs2ZKKior83SVzngJRSD74ltfU0q/+9xvxwNo1Mdr2c2oGKx5e8YAOa5czZcnBXPhIERI0h2Cl4mQjgoxLZHE6Fb1sLjuSQ/llNHPpNg/RShXTgoNcIhtdtxuBhcO7W3KaLA6pFhUTLu0oxG1YuMgCm6YCrJW19oE1KezrBRhV/pV9nGaOTPHIjocFy5c5he7CncIPPsfbD169/1Z95OOdJ8RPCOHIrEVwRBfz5WtW4JytfKwDCaI014oK5uzRHCtQnIR4rHLA97FVP2lqAM9p7jL5+jsV6sU4e2r1Trq8WxxdmhRnOebUQKQ4p/p6GpHWjqYM6SrGm1zVcdcbn4vCodjXNzmFtPyBIaL2wsL3Pa2XkAn/4sRLha2UGhzA3yKPj0jmWgMMwzAMwzAMwzSPiN61a1fas2cP9ejRQ/y+ceNGSkpKcr+fk5ND7du392eXzHkMHswhmsEPtWtCtDu7bXhKG0tbBLyOB16Vb0+W0lOrs2nxhDTqkmAvwDOMkxDU3JYpThYC8Pt2Wn2BtnVLjPbZjsSKwwVl9PjSbZYiMYT0WcsyjXYjCH/++ubmEYfUDHX4iu86dsq2AOv4/h3p+pQ29Nm+PC+RHQE0ee5OYl9xeTV1b93C7dWsezDbCXdqoMWqj0BInzSoixDzIObLoAAEPLS3c3yUbftQTNQqUONvEKW5V1QwZ4fmWIHiJMTDJkhd5aD3k6YG8JzmwBZh3n9K+rIi7dO9J2nK0K704Ntf0Q192rpfH5AUR5TRUCxUrkSRY/dAXhk9sSzLVpzHHPDFgQL6IDPXK0O+4XcXPTCsB5VX13nMRaFBQU2qTcEwDMMwDMMwzIXN6ZRgH4D/eW3t6cydtLQ0Cgk5/fD0wQcfsB/6RQRsIyCafXEgn1Zn5goPU4hOocEumjq0mxDPVPA7XpfLrCXIJMPDNMQ/ZNkyTCBACGpOyxSJtBCAWKQiMxZDglweqyus2ua0H1+yUQ/mldlmvEP8RUalCbxeUtX8BcXQboh0VvYNnzXaN8wfk0qvT7lCZIpDoJ721pcie3TNtlx3Bqo/Yp9JWPQlmAHvczuwD/yTQQG1vR9uPyr8k03gPrZvFWG8j7h3sKxA4VVcA2TMY/92nu52mcd4nzk/aI4VKE7zGnz27fqJFMFNOAXwsA+sOpk3NlX4l5vmrtioUK/9O82J8v2aunoxzp5Zu9NjXsC4w+tynGDsYszr56oj5wCsbNMFdMnWnAK6KbW911z05Jpsx9UmDMMwDMMwDMNcvPiViX7//ffbvv/UU081tT3MeeaJ/uZn3wpxDpYKy6YNoa0HC+ib74ro0z0n6O6MbvTEyBQqq6wVhfs27M9zL9E2ZaZjP/BDbhkRwplgjF/4mskdaLG46LBg4etdWlUj+i8CSLIQH0Smzd/mW66+UNtmKtZpKuppwhcBqdjx/eYX0UFcdBhd2T3BtqBwVW0dvaQVXhXv7T0pfM6fva2/Y8arvI645pU1tfTypAEenu9Owl1YSBCFonCDDXIfpqAAjgFhD6jBClhEwK/ddB9NGeXSXgfzIYqm6kGUM12Elvn+8LVPN0WIN/V7tZ/IAB6Edb2egF0AT+27clXGz67uQeGhQRQbGeaeuzAeZ41KockF5cLyD+Mx83CRu9i4jvq93zkuUojXTsV6ZZDUF3EebY2PDhNBK1NdCOxz/krvGg44TzkXsb0cwzAMwzAMwzBN9kRnGElhWZU70wsPprmFFXRJ25b0y3e/pjfvGkjzVmSJ92VG59c5BR4COjLXUTwMQpJ7n+UN2WYsEDG+ogtBTRWsdOxsNVpFNWRiX3NJa2HXAlRh5iqDSOVrUU8dJwEJ46x1y3BL4QjEGLyLnfDFlxuC03cOq0jKqmstM0MhtBWUVlFy+xhHsc9OlM46UmRrJbUm66j4v5O41zE2koYYggK4jpivIMLBP/l4caXwg/8o+7gIEpiunSmjHO0Lcrnog59fJbJ4m8M/nTk3CVTA9lWIN1mkmfqJvwE8ve9Kuzb8Q1vsCjnju33umD40tl8H998B+oo0jCPMj6jh4FSsV527P9p53HaMYw7AXPDcP3d5HXfJvYOpsLRKzI2wjOmXFOcxPwLMC/mlVeK8uA4BwzAMwzAMwzAqLKIzAYEH7EMF5R6vfZFTQJcnxdFLkwZ4PDirwtPPrukpvJnjW4TRR9nHvDLTIRKyQMT4ysrpQ6lb+0S3yNEcgpWKk62GFJLax0YKEfup8enGbPXmANmoVgISjg2bkHkrtovMblPG84CkWJEx3hwBBGRdQzSG9YEUmkzFBVWwIsWO4ooaR7HPTpQGV3SNFwId5pj1FsIdMGeTJwrLiiAXUUJ0GO05XmI+j0YxMaNnohAvpQiHQIqOXUY5XoeVRXP4pzPnNk1ZgWI3r0GEnjzEMxBt10/8CeD5shoCmMYj5qCFq3bQ7FEpdFnXeHqsMeCkFg29LCmW5o9NpbzG/dihzt27covFWAafGcZ41uEiS1spF+2k/klx7uCYOj+qf4egTgssXgDXIWAYhmEYhmEYRsIiOhMQ8gFaBWLSzQ92pNyiCq+MUzWLDZmyKCb4zIe7jRl1E/p3POPtZy4MUGQyRhOFmipYqfhjqxFohrmv4BysBKQ5o1LopY/3egjo6jZ4f2jPRL8sCmwDCEu3eYhREPOeHJ9mmeGN12Mi7b9u1Cx5q2tpdz9k1uo7W3KE6FZRXSf8zyH0S+FOCmVqNvl3+eUieIdtgl0kbCBwHNWz3MrOyknYDjSjvDksQJhzi6bOD6Z5DYGr2csyPQTg5uonvvZduyBRfT3R8+v20Cv/3S/GG4Ls1yW3oRtT21JBaTXV1NY5zgsd4yJFkFLyyI29xaq3GTelUFVtLdXU1lNtXb3bLg7XCMc0gblJzp8myxiJuuJHD5gyDMMwDMMwDHPxwiI6E/ADNkQnNSsWD/KV1Q3Zqc6FvzxtKWQW2btbcigx4/RDLsMEQnMJ2ueSrQbOZ8G4NLHK49KkOCEYYyzFRoZSQoswmrksy/g5jM95o1MpKaHBbsZX7ARrXYzCdvPf304Lx6XR3BVZHkI6BHRkroeHBluK7MgCR0Z7U+8Hsv9/d2s/971H0WMUDtSRQb0+7WPcGafXp7Sh0Ms70/S3vxLng+KfdrYRKDIqix+KeatFmJf1TQtNaPc1o7y5V1QwF+68hjmhsqb5+4kvqyGcxiPGmQwGIcje/45Y+t0/d3mMqadvThdBONNcg/miRVjDGDLaxvRKpMXj0mjLt/l0Q5+2YjxHN25vhV58WAbf7OxxuA4BwzAMwzAMwzCARXQm4AdstciefCg+WVrpU+EveA4vuWeQ8ECXWaAQoiDC8YMqc67wfdhq+OI5rmajQiTWs+z3nyy1PUZZlf8FRZ0EMl2M+njnCZp8ZbkQ12eOSKHSqlqRXQ4LGZkBDzEdhft0qxXURkBwAIKgnW2C0/2IU0RGXNcqrY06cq6CWDdvTCrNXJrpzuY3zW+6NQxEQljH/PaHfcX56iKfnUDolCncnCsqmAuXM9VPmmM1RHR4sBDzMS76do412qwsWrWD3rv/Sqqvz/aaF6YM7SaCc7NGptDxUxXUr3OsKF4us8cv7RxLe0+UUPc2LcRrj/zjG3Et7DD9fSLnMt32SYVt5hiGYRiGYRiGYRGdCQg8QF/eJc5tizCj0RYBXsIo3ndVzwRjEUE8pB4/VUntYiKovLqWkuKjhLXLuH4dqE1GNxaImHOKM2mrAZG3oKya5izP9BgrVp7jdrYxMRFVzS72OwnWJjEKfvAys/ujh6+mHo3ilgTZ8L+9pR8dOFnqEUCTgjQyau1sE/y5H3mlVWKOQZa7bnMDIG53jo+iN6ZcQd8cLqSSqhqP7dRaDshUhX1LaWWNlzUMhL/q2nqavSLTSyyHQAivegjtgWQKn2mLIObC4Ez0E19XQ9gVPP0yp5BGprUTYxo2b3qhXoBxBL902ENBwIagrc8LeB0BsZ6to2nZtCEUHBREC1ZmeewP4xljbdP+PNsVJKYirJ3iIun9B4fSh9u967RIuA4BwzAMwzAMwzAsojMBgQdoCH3wRpYPsrA2ePymZNpxpIjuvqo7kcvlufS6ZwJNv7aX8ED9967j4iF37ug+9ODbX9H70zNYLGL8ZvexYupMpzOdm5szZasBa4JPdp+gVduOeIk9Js9xp+J2Z0LsjwgNsrRfsRKjVGHdKnOzvKqWJr622fiek22CP/ejnoje2/odzR7dhxat2u6d/T6kK/36g2yaOKiL8G4+rBVKVm1fwMuTBrgDBKbggSnbHJ+/643P6YOfXyWKiHJGOaODIHJBKVai1IjvRqymOFPzWXNnueMnVo/NWp5puVpjYNd4EUyzWy1TVn16nFmtioFt1evrD1G/pDjxt4Y+b4rxV080tl97SjPUjchozGzXs8zR1n/uOCb+j/2eCX95hmEYhmEYhmEuDFhEZwIGmbJXdIunx25KpiAX0fj+HelQfhn9ZHBXigoNphFp7WjKkK7uzDJkoKNY3x8/2kOP3JBMr68/QItXZYtMT14qzQTCzS9vpB+kdhYBHX89v5ta0E9kJecUeGWKO9mzyIKdGBumbEmT57hTcbvmFvvRxnkrtwvRqd5HMera5NbiJwoHY8xHhAWL/ejH9tdnXr2e8DwPDw6iEenthQiuzi36Z+avyBKC22/WZotr+bNreorMfu/s9zr65fBLHGs52NlUwcrFChwDBU4RFGEYlZy8Upq5zFOAljUEztR81txZ7kXlVR41GvTxhXG173iJ7fhxsoBr3SKcfr9ut7hOmHusBHesJHloeC+qrq2jJ0amULDLRYcLy8nlcgkR/Pl1uz1EcmSvzxndRxQq/fpQAd3dWI9FvR/YZt7YVLGyRV4PhmEYhmEYhmEuTlhEZwIGYldqh1b0m7U7xUMnBPK/3zWQ1u89SVsP5FvaueCBe/7K7WLp9Y9e2URThnblpdJMwEBwhs/2s7f1P6MZ6VI8QRY5vHc/NYjVEJx1X2w9i1wW7LxjYJJfnuNOWdrN6Y2MfazLPk4b9uW57UyEMB4aLPaJQJgqRkFAf/ymFFq4aruHAGXKoPfHZ14vJohin6YsVHksGWQQ11gR3CYN6kKTLLLfsa+fX1vvVShZBUKaLtSrx0WWrK/ndKb88pnzLwNdF9CbMp+drb7SIjzUNou8orqWbv7TBttCvbgWdhZwYSFB7s/p86IOxilWjKycPpSeWpvt/hz+PsFchrkAJESH07qdx2j8S5+JuQzH6dsxlq7oGk/Th/Wk0OAgYSGzYX8ejXlhvbtIqt2KIIZhGIZhGIZhLmxYRGcCJjYyjH774S73QyoeMv+z+wRd2T2Bnl+3x/gZbHt3Rnfx0P1EcAq9MfUK4TUcHNQgArBAxAQChCdYIgQioqviU4vwEAoLDqLC8ipqEWGdRa5bd0DgRt9fsy3Xy39bzyKXmdi+FOC1y9K2Es2aYwzJNqp2JhKIUSseGCoyPZHxWVMLm5IayiutFAGyr3IK3QK7eu4A2Zy1dXW0+sGMxv/X09acAlHEU4pU0jbBdK1RSNBKsFODDLL9UnBzEt6wssCukOi8MX0oLCjIyzJHBk9wTZrbTgcBhLkrsii5fYw4b3hKH48KFXUkOsZF+b0/5twC85XdShS7+Uwf+xEhQWLlCAJfkuYQfPXjYH7EChy1VoOdlRSy6iFCA7vx1b5VJE1FFrhmASdtYdD3Jf7Mm+px9LkMHuh92sfQnyZdRnX1deJ8MJfd0KctRYYF0xcHCsQ1VYOFTiuCGIZhGIZhGIa5sDknRPSXXnqJnnnmGTp69Cj169ePXnjhBRo4cKDj59555x264447aNy4cbR8+fLvpa2Mp52LLgLgQTmjR6LXtjILDGJQdFgw/W3KFVRZU0tT/va5eEhF8b+ZI5OFX3I7zvJiAgCewv6iZzqrws0dr24WxXMhRKHPQkzKL6sS7/XrHOsWfiVtWoYbC1hK8QUZktiHFHnsMp+tPMdlRrOp3b6KZr5krNpli+Ocg4NcIisdIpN+7SCUSasXOeZ3HysRnuDR4cHCUuHjnSe8PvPulhzhryzbIjP2VZzEcBlkkO2X19pJeGsZFiJsHYJcLvrpD3rQzBENAYKismo6UlQusmlrgutF4GCmuAY1IoioZvo31U5HD+Z8/V0hTRyURH9d/62H+Adh8tc396VO8SykX8jzldX7prEvLZawcsQUwEL/8zdT3e440qpF9m9T38fqjalDu9L0JV95FOp9YFgPUYi8oqpO/F2AeeS7/DKau2I7vT71ClFkFCI9LOFq6+uFFYsIck25gr7MKaCsI0U+zZtlldYWS+BQQTntOX6KRqS1p99+kE3JHVqJuQrBvdioUErrEEN/nnQZ3f/WVi8h3W5FEMMwDMMwDMMwFy5nXUR/99136eGHH6Y///nPNGjQIHr++efpxhtvpF27dlGbNm0sP3fgwAF65JFH6Kqrrvpe28ucpqTS+yEfD5soEqYifNDvuJT+9pmnGISH7BcnXioesiE+1q/Jplmj+ogsMH5AZfwFRfn8wSqrXIozEIDRX7HNyPT2NHNpplEslgKLk8Cbk19Gd7/5hdvWwCozE7YGkw2e4xCsQoJctPvYKVr0/nYv6wNfsiR9Fd9N2aUyEDake4LIJn/8vSyvNsjz+OnV3YXVkz7mpQi3aX+++7rhMxCvf3drP4/MW5N3uqMY3iiey/bLQIVdwOL6lDYUFOSiNduOeJwPtoetw5AeicKmRhX+pW+1ep399c53ui9PTUijv63/1mj3ARuQFzkb9rwmJiLEcT6Dl7gqegPTnIU+4UJiwX2DhTgMYRqCM+YYiMLw7Pcn6GY1N+I4sKy67wfdRVAMovOO3GKxOmLasJ5ibCPgJOsUuESryGMOGZ7Szsv2CePptclX0KH8ciGcoyAwCv5i/tCz1uFbDtsV73kzkSYP7SrmTWwXEux5bJ1OcZEi2/83H2TTHY3H0ucqBM0wl/3+X54r67iGC8MwDMMwDMNcnJx1Ef25556je++9l6ZOnSp+h5i+evVqev3112nGjBnGz9TW1tKkSZNowYIF9Omnn1JhoXfGJnPmscpWxcM7HmhlVi6EN/1hGMgH9LfuGUQFZdXic4VlVSIDjcUhxh+EUJpTKPqkKgpBDCosq6bSqhohJMG7Ghnjbt9sgwUBQF+FDzjANigCqr+vCu2+CLyS0+L5t0LwkZ7jUthBFjJqBugF8CBSjfjjp0KoNXkHO2VJ2lnR6OK7XqhUDYSh/e/+dLBlG3BtHr8p2V0rwSTCqdcNoE0lFTXUNuZ0WyNDg732bSeGyyCDFKyfvjmdnl7TUFR0yeaD7kKtumf7/LGpNGNppjEgAHF/TN/2HgK6nW+1L975unBpdV+wX7RJXcUjfekxVx47VcHz5HlMXHSYEGrRl3Tw/fnVwUIRLAHoA1gp0b9zrKilgL4sRXI5T4gaAI1+4ADjBEFqaMkoYPrw9ZeIIuAFio3SvBVZInil9yOnuRGZ5L/+YKfHGJYreNDnZZvwmjrWkbWuC+gA12DRqu2igOe4Fz8Tc9Ebhr8Z5O/wLYd11LRreooxj4LDH+08JubTS5NiRTv2nyjx+DvE8/omUOahIjHGUhqDfaY2Pb1mJz16U28vER2BfoZhGIZhGIZhLj7OqoheVVVFW7dupZkzsUC+gaCgIBo+fDht3LjR8nMLFy4UWep33323ENHtqKysFP8kxcXFzdR6xsoLFQ/2yx8YSove3yEeYO18jKVAiQxdPHBDsCqr9t+Wg7mwsRvHUryBgPJBlzi3GJxbWE4H88vohY/3eGYsNloQlFTaZxOqmeWmLHNVaAfIvERWc+9GD2tV8NxxpOi0zUCjrYEUzyEAxUV5WoNA2Cour6aSqlp3VnNuUbkQ03y1NNGxE8Z08R3CLqyVfjG8Fz0xKkV4Li9etUOcMzLpYbnghJXfs37d9HYjY3/W0m3ULynOSzCXAQjkmKrioxpkkAIe5iZki8OWBfYsdfX1NG90qviJbWDZgHoMEBWtrospgOKLb7U/AQur+4L7bLWKB9dlbL8O51UdCf4u9gT9Bv0TwRiPvtwzgR4Y1pPuevNz8bvaB5xWw6A/Y3xinIggELlobL/2FNcinF74916vrG7Mm8hU1/uQaRWICsa/lcCtiub6WG8TE+5V6FOdK9Hewd3jhYWLXZAOGeKIxmEfCF6iAOiV3RPp+j5tKSIkWARMW0WE0MLxqTR3ueeKGZz3nDGpoqAo5lnbv0/2nqRHqbfHa/j8lzmF1C4m4rwZewzDMAzDMAzDXAAi+smTJ0VWedu2bT1ex+87d+40fmb9+vX017/+lb7++mufjvH000+LjHWm+dGzVSWXdYkThUJHpLejKUO7UlSYfTeToiAejhevyqbZo1POeNuZ8wurcYxMy90FtW4hSYrBAIU+V207YlwBgT67aFya7THVzHKrLHPZdyHYXntJaxraI6HBakOzBZgzOpUmvbbJWORu+bQh1KNNC4/9whMY+9EtD966ZzAdVYrs2Vma6DgJY1LENlmLQKSePKQrbdifL0QnJ5z8iE2BALT7u7xS93lvzSn0srvBdYN3OoIgFdV1os0QDr84WEB3vdFQX0GCvgCB0sreRmaKw3fcqfaDv77V/gQsrO4L+pzVKh78vmjVDlo8/rSH/LkOfxd7k5QQLVYzIBiDvgSLl4jQIBr5x/XuvmzXB+T7ci6R1kFSXBci8E29jatC5O/zx6R6tcuuJoIdVgEySUlFrb3FW89Emj8ulU6esg/SHcwrc2fcy9UdA7q0EBn36ryJ48welUKPjUgWNjdY6fPh9mP07clScX0xxpyCkuqcogZsB3aNP2/GHsMwDMMwDMMwF4idiz+cOnWKfvKTn9Crr75KiYnexStNIMsdnutq9lvnzp3PYCsvLlQfYGS0lVXWUOf4KOGLGhsVJjLKQhu9Sa1sCWDfIhHe6PB7YBgfxjH89IPCo4xiMGxbrLKhIWRCHDWtpNAL1FkV+QRdE6Loo4evFlnk4JG3txltAWBh8KOBScaMR130PlZc4SWgq5YHsGSwszSRbfFXGEM7rDKo8TsyuDF+MXbhg2zVBgjuyPK2Qw9KoN2wSIC4pQrmasY+jtujdbSYV2D9Ir2iQ1wuISirYpeTvY16nr8c3ktk78p5KToshGrq6sTchXmsS3yUO7tXHkPOZS0jQox+574GLOzuC/oc/OftVvFgtcD5An8XW2ekq6sZ0J/UvmyXKa2K1nKessoIt/o8rF18XWUmM+Wt5kOgi9LwS//4V1eL+QP2SH+dfDmFBgcJz3JYssCG67QlzUn68mABpXaIEdupfyd4jL/QYI8xezCvlOrr62n++55WMdj+iWVZ4trgWNuPFIvrKwOBmYeLhBhuB8bny5MGUOf4SJGB/2BjwJZ90RmGYRiGYRjm4uOsiugQwoODg+nYsWMer+P3du3aeW2/b98+UVB0zJgx7tfq6hoe2EJCQkQx0h49enh8Jjw8XPxjzhzSB9h1ooT2V1TT/JWey6efnpBGw1PaCBHRVLxreEpbIUrJB2STGMZc3PgzjiEGQ8R0yjBE1qZpJYWabfiDRpsQZDmbxOKOsZFu4RRFAH3xWHcSvZGVaiV6QUif4XJZ+nsjQ9sqO9JOGJPt8NUn3qoo6rXJrUVmKwJhuD6mfWVoIpxsN+4ZMvBV1Ix9zBHvP5jh5TOO4+i2FiomsUueJ/YJUR7CGo6jZsjq1hfyGMCURav6nfsSsPDFFuvqS1rb7ueURSb8uQh/F/uG3nec5jG8r85Z+lh1WhViGjNWq8wyFCsUXwJk6NcIZuIYsNZ66eM9XtYq6tjF+OvXKVYEHddbbIfAUmz06TGrr5ZRixZL5PWAAI79IFCJuQrHiosKtfWmR5ABQUMZ7Jf7tlrxwzAMwzAMwzDMhctZFdHDwsLosssuo48++ojGjx/vFsXx+/Tp0722T05OpszM056gYPbs2SJD/Q9/+ANntZ1lkDFmWna+aHU2/d/9V9LiNdnG7FoX7RLZ7DLDCx7RDBMIqiidX9pg62IFsoejxXL/PkK8jQ4PFsUsg1wNdirvT8+gFhEhIssRxep0URW+xSpO2cemtppEbyuLEFU4lRnaD1zTU4w7jBnVU92ElTCmtmP/yVLbY8ssdFwPPUscIhM8j2ctyxJFCyFWIftU96OHjU5lTS1d27uNR7u/+7bctjgrjjV/hWeATs+S9yXTX71X+AyKK6rZu07WGcC0jep37kvAwum+XN4lTvRPO9BnmQsLve84FSxGhjSyrPUgkhTXkfFth/y+xeoMBJfkCg+srJCrzDAfRoU3+I+76hss20wBMnXVjpxX7Ky19Kx5/MRqm/UW28Ga5cruCTRbGbO+zgO4HnJ1y0+v7i6CfVjxs+voKXpt8hXi7xC1CCnOZfLQrnT7KxtpQFKsCPZDfHda8cMwDMMwDMMwzIXLWbdzwfLuyZMn0+WXX04DBw6k559/nkpLS2nq1Kni/TvvvJM6duwo/FQjIiIoLc3Txzg2tmFZrv468/2Dh29TBi0eXHMNhcgkeHC9/5oeQnSD3zE/nDKBoIvSWw7kW1qOYGVESHCQsIPRhZMHr+0lLDzax0aK7PIpf/vcQyyGkAShCNnpENrl8Zyyj2FrAOsXWSjUSvSGL7IdLSIaVm1s+66QJg1MEu0MxH5J+omHBQfR8VMVVFZdSy3C7Y8dGxmqZKF7ZmI/fXM6/XX9t+7rqYrs8vyRlWol9OO8/7vnRIMQl1PoZf3ULiZcHLupmf7qvdKtMpysM1DQEJYUVttI+xh43DsFLOzui+wfhWXVln0YryNzF31UCp89Wnt66zPnH3pQBXONXR+Ax7epP2KsYi5bv/eko/3Tofwymrl0m0eASq6sQB+DTYoUzfH761OuEP9XhXRsv3BcGhWXV9GE/h3d8xv6p521ljp2ncbfL4dfIoqG+lu0GGDeljZMV3SJF8FKbI/XPtl9XHjHzwxKptzGmhO47jIwAVG/nnbS4zclO674YRiGYRiGYRjmwuWsi+i33347nThxgubOnUtHjx6l/v3709q1a93FRnNycigoyD4Tizk3KC63zqCFt7AdyHRbsvkgP5wyfrFy+lCi0EgvURo/r7mkNXVLjBa/e2RD90ykh67rRU8s3WaZ8QjxqaSyhgrKqj0sReysQpC1bmULgNchcqrex1bERYfZ7qdleIjbhz2QsSLtl0wFRCGEW9mwQDyCOIzAQWllNT01Pl34ysMWB9cfWaAzl55eKaRfN7TZrr047+wjRXRPRndRXPHFf+/1smuws21xaQm3dmKXzPbVrTKcrDOqa+rIqWSD7BNWwrjVNZD3BdmusPTZdayEYqNCaNbIFHpSW8Ujgz2fHyigR9/b5n79wK9HObSOOR9Q+05xRRWN79eBFkDI1lZ1PGBjNYWxWl9XT9/ll9HI0akiw1sXyTE+MM89vnSb5cqKEentPeYDjD0cc87oPjR3dB8x/mUwrrC8ilpEeNcH8MWSRv1p93eCk92baR8YL/A/V22Y4HOu2jf9/l97hA/73W9+Ydwvrk9YSJBloWKGYRiGYRiGYS58zrqIDmDdYrJvAf/5z39sP/vGG2+coVYxvqAuAUeRPSuclqTjfYiGFdX2D9EMo9K9dQuKiYkxvocMbYgkT45Po1OVNVRaWUshQS6RmXmipEr0N7titzn5ZaLIJLIu9cJ2JqsQiElThnYTIqsueOJ1vO8LENqfmpBOTyzL9BDSIaDj9aSEhsBAU7AqIIoCnThf6NGmDOqGIojmfX55MN/2mE6F+LDveWNSadP+PFr5zRG/7RrgT+9Lpr+a7XtAs69xmqd88UFWt5HCuI7JOgPb5eSVehWVHZ7cRlgOIUMWwUi08fipSmE7NG/ldsf2MOcnst8gC3zrwQLR76coq2FgV9U5NlLY/liNVfSnlV8fFv1Efh50ioukdo0BPRTbtCvADJ9xgLnyvh90p4yeiVRTWy+shDCfIst87srttC77uHs+hW85BGcExuKjwkQw0g457pwKEqPdTjZduh0cCqEuHJ9G1bV1tOj9He5zxTF1+yYnER9WWu0t5j+GYRiGYRiGYS58zgkRnTk/0TNZp1/b0zKD9nhxpXiY1f2MdR9VJ6GNYfwVoiBWjnnBsxCenoWoirLoj2P7dnB79Mvs9WXThtDRokr6/GC+ENQhXqlWIciS1H3CpfULXl9yzyCf2w2h/Nnb+ouMZNgOwOoEgpQvmey+YFVAVGaZfvDzq6imrr7BCzksmIKCXFReXSvEX1UUlmJwQVmV8JP3V4A2icn9O8fRY//nWfvCya4B9yw0OEgEVXwluvG8cG+lBY2ddYZqDWPld475D1n0JnCueaVVIsiie7tjfzJwoh973c7jwkN+0fg0Ye+C69izdQsa8cdPuQjzBY46Tk2Bo49/dbXlagesaFADMnpBb8wvJRU1VKgV89UR9Q7CgunFiZfS39Z/S8+v2+N+D2Nl+rCeNGlQF+Et/sLEAfTshzu9Cu7OHJliOa6QNR8fHUZvTLmCWrcIt/wbAvuB8I9CwFarZXAM7GvtQ1d5zZvZucUeYw5jHf7qaludgmjRYSG08+gpiovCPq2tqRiGYRiGYRiGuTBhEZ1ptkzW017JDQVDJRDPu7eOpqkZ3Qh5XuqDNB6YH70xme54dZPPmZ4M4w+mgp+mLEQJfkdGtprxDJF14aodooDfV8hKn3IFdY2P8hBR4LNtZ/3ib99uyPqOcAvNCFrBekG1SggUuyKoOIei8ipKbBnh4YWs+iTDbsKfIJrJm9xkJ4Ptfn5dL7/OBcLZ1KHdRMDhq/ICj8xuO3BNETAQBVCpoQCqnMOQia+eh24NA8F7hmYHJFcczF+5nX53az+P48tz7dc5VvQfk3UGVj6Yrh34tHGVTv+kOPE79sEC+oWPU7Hi4vJqETgy9XWMB6sMc/QzvI/AmC+rxDAXYmxY2V+NSm9Pr0+9QvR9U98O++cuoy2RLDQ88o+fimP8fdMB42oeuQpHrOzAiplxaTRruWfASc4DP/zTBmE5NbBbvEc79AA9ziejR6LHa3ZBNLRhTVaue36/qnFOwFzIMAzDMAzDMMzFAYvoTLNlskLUkZm4M0ekUE5BGXVNiKb6+nq65c8bxTamLF08zOOzeEiFrzTDNCemgp+mLEQViOZThjbYGOhZ0PhMsMslMkBNPtumDGWrApcmIJrDrgMZorBI+upgAS1ane0WTVUhO1CciqC2igwz2r1In+Rnbu3nexDN4E1uZSeD/d9/dQ+HtoUK72I90x/3Q/oZ+3KNIFCqc5acl0JcLiHGoYhoVU2d0RoGXvAQtLGd3g7sE/Oj3F491ylDulr2OaeMYGTW+nr/mAsDp/tsF5hT+4vV+wnRYfTRzuO2WeKYi5wKfmLsVFXXWYr2sHqZMSJZ1FEoraoRYwTjGFYwAKt65DE27c83/p2AMSdBkA8BTdOKH+zbtKINWe5y3pC2XRU1noEodQ7TRXyI+9i/BOMZ4xoBs+ZaIcQwDMMwDMMwzLkNK5ZMs2bIyUzcPu1jaNpbX4ol2nhglQKg6UEc1hr++kYzjK8+0yZx25SFqGPyx5WvYV+qUKr6bENkNnkU+5I9LjKW39vmthcBGBtqQU0pZDelwJ2T4A/BymSXAPAZBL7sgmiPj0gWFk5tYsIpIiRY+NP7YicDNuzP87BYUYGY9Z/dJ7zmEdUSSrbR6RpJgdJq9QD81ft0QN6rN7C5sRIVgSriqedq6lPSR7pzvH1QBNYUvtw/5sLBl8Cc1byn9hcTeB+f35VbLIJBJuH4yQnpVFFdQ/klzpYvTqI9rGPkSgodzJuwW7Ebj6gNIGkRHmo7/vTgwsG8UpqrWShhzrihT1uPAII6h027pqewiIoMC6IPtx8zFjTGuN53vIRq6+o5I51hGIZhGIZhLgJYRGeaPUMOohAKgCHrC57DLSNDhNWDWphRLeiIfT18fW/6dM8JauNjti7D+GINIrORdXEb/bBemAZYY7I5UF8zZTviWFYexSom4QvMXZ5F/ZJiRRa8mjG5ZPNBD3sZk4ivYyWu+SL4Hy2usL02VoKZHkSDQIXsU+/PW4tymCfgPw/7HFXUQ9vgC77wfc9imtLGQc0S9eUaNWXlQItw+69OVcRTz1XvU6ovvzwXKysJeDtLrO4fc2HhNE4x3h6zmPfQX6zslWR/wv4XjEujeSuyPDK746JCqVNsJC14v6FgKL7L7UC/bhHhf00Edd50CqCrnzeNXbWoKTLV950oEXNeRU0dzV6WKQR0vZB0eVWtmJ+OFJWL4qdyvs0+UkT9O8cK+6yTJfW2gj1WkDQ1qMkwDMMwDMMwzPkBi+hMQFgJUHhIfX3yFfTM2p0eWV8ZSjYtsCroOK5/h+/xLJjznW++K6B2iS764mABbT1Y4PGemo1sErdhHWQlouqZzabXrEQh4dtrI6ZYCf6zR6fQjwYlGccFRGLYjKjYFeF1CioAeU1QrBIWC6VVtRQbGSrGMKwW7HDKcpViMQRh1Ybh9Oet9w9hMLewwi3qoS0o5CeDEYvGp9Mj5dXi/KPDQ+iDrKPGLFGnaxTIygEEJhBggABnlS2vC/Dqueqey6ov/1c5hZZWEvCDhsgIL3QZEDH1aebCwyowB9ZkHRUWQXcMTHILwAhCyXlPFqv1rFGSSPPHpor+hP6M/cOSRJ8bH/nHN+75w84rHK9j1Yn8v5UtjJOdFeYdqzGlf14fu1ZFojEWnxiV4hbQ1W3k73/UvNVxrF/d0JvuefNzMQ+EBHnOu6a5zpegJsMwDMMwDMMw5z8sojMBYSVAzRndh1769x4PAR2sV0QjYFXQce6K7fQiZ3QxPjLptS0UFB4lxBvYAiG5PKFlGJVU1Ao/8WPFFZRf2iBumMRtUx+GiPLAsJ6i6KRVtrM/Hucqdl7gKBxpNS7AIzf09njdSjS1OwZeXzw+TYjluBYQzhet3kHJ7WNEduaJU5V0sqSSOsdF0ej0drQq86jX/nHuyGL1NQBhyjC1ywLH57/IKXCLYcunDaEebVq434foh384z+1Hiv2ydTBl6MPfHW1EkUarlQO61Y4U4LCaQS+iLAsgyuMgK/btewfRZ/vy6J0tOaLPAYjmsJPAdZ80qIsQQTMPF9IVXePdGcHdEqOpZXiIKPCKjGDJ9SlthBCKPqOvZmAuPExz14GTpbR62xGv+gMrp2dQVU2t6M9JCdH07G39qaCsStipwOMfdkljXlwvgk5qYE3ts3kllZb1DjwE554JNG9sqrA3qq6tp8dvSqbn1+2mj3eeULZJFLYwTqtmNuzLEyvWgG5nBWsVtF/dhxpcqKuvFytU1LZhjPbtHEtFZQ2BNL2QtFVhaXHe9fWieDRsWnbmnrINIMi5zi5gxzAMwzAMwzDMhQGL6EzA4CH26ZvT6WBemVjSjIwseCDPXJpp3B4P+7NG9REPppYFHfecFIXMWERn/AECR5DLRSPS2tG0JV+6l+wDZEJDpDH1Kbssz/enZ1BheRVVVjcITzLbGULVwnFpAbXTzgscieZWhfnw+owRpzMi7UR8u2Pg9b3HS+jNDQfE2J23cjv9aKB39rv0Q4aQ+y9FvJVZ2iikZwpAmKxVTEK2VRDO18/L88R98Sf71S5Dv3vr00K9ZWCiUdxTvZN/dk1Pqq2vp+qaOmrdMpyqa+uMx8E1lef8kyu70IIxqcIuQ/dpxvnjs7gvXRKi6FBBOf1i+CUi2xiv49i3D0wSNh663c3f7x5keQ7MhQP645zlnhnmAP1twcrtdFnXOPriQL4I6EBIB/klVeJ7+ooucSJ4ExxEVFxeKwR2gLUjjzb2WRGQVNAL8CJAicANih6PffEz9yoQ9HHMjfdeVSHsUWTBz0Xvbxe2MVa+4RjLKPwJe5WR6e3cdlby83e/+Tld1iXOK8AugwvwJVfHkZp1Lr8H9OKodsVSsa8ppyrpwbe/opcmDqDpw3pSELm8xH11rsKqGIZhGIZhGIZhLmz4r36mSQ/yM5ZmeghF79w72PYzyI5zabYUXvst54wuxn/QD+8e2s24rP+qRvHXJOJY2a/I19DPE1qEucUYiDoj//gpXd4lzsMexRfsvMALSu37PUQpK7sRNbu6ps7e6x3iFIRrBL+QgW7KxoQ4N3t5lrB5mDGixujvHh0WLFaeQJiLDA0W2aD/3nXcw1rFzsZBBjAQNMvJL3NfW/XzdsECnKtVhiwErgVjU72ukVWGvpOnsSkwIf3f8Q+e0Xe/+YUQH3u1aUFzDcfBNcXc9/a9gyksOEhcX33FDs4BwuFrsMT6cKdXYOOtewbTRzuPGu8Ze6NfPGDM6H1HAqH3oeG96Pl1e0SQZt7YNJq1FAEgT4sgFPKWYw2/zx+b5i7uaaoHoRb8/OSRa2g2CnUa+jgKeKKAqC5QV9ZYj7GSympqHxshxtnMZVnm87KxTNHnVTXLHLZQmA/0or6mIr/6+zjnB5Z8ST+9uruYT2DldKqyhtq3ihBZ/SdKKunFiQPoWFEFff1doRDSucAowzAMwzAMw1y4sIjOBIxJWIoKty8uhkJdTiCLjGECoVVUKP3un7uMS/SbUvxt8ersgMRXr/ZFhgrLAlnYTvUxdhK/E6LDaM3PM6hjo/WCRM96dioCiGMCiN+22Zh7TgoLBWmlAmuc3KIK2nO8RAQV5i5HFvVJL2FOAuEKtji216MxgAHxyR9vcuk1rmfIqtmrVvOVXlxQ3oO8Rtsff4MfqiCHY2Oljd1KAKyYwL02eT+DPh1a0bMf7jQGNhatgiiaSr9du9u2PcyFDcauHXIuSenQyktAl30JW8hixfh9/sosMd4QDLLzQMe4LK+ptezj2BcytHXsfMNjI8No9vJMumNQF9vzsrJM0efVpPgo8fquo6coNNhF80anCpsqFVOgwPQ+5pjf/2sP/eWT/bTmwQw6WlxJv1nrOT4RLITIfii/jI4WlYtzVAs5MwzDMAzDMAxzYcAiOhMwVsKSL/6hlhYMPRMpOoy7JRMYIcEuS0uUQIu/2dmj+LtPZCCjOKReOBTZ1PAhhsewKcMUAjVE7C7x0Y7Z1XYCGPaDzG4IyRCJnLIxpWiVk1dKM5c1FOD7xfBetPVAvlGYQ6b1knsHUV5JlWgHfOVXP5hBFTV1VFCKTPkaiokMEYVCYQljstUpraymVpFhwoYHmZ9l1bVGQQrnAUuaNi3DxXng2Dtyi0VAAqsE7m2sv6DOV1YFCHG9JvTvaHkdINL98vpeNKx3G7ewFhocRJ/uOUGv/He/uJaiwOKpSoqLsi/wifOrqrUOmNgFNnCNq2vsgy3MhY9ToFm+b9eXMJYReFL71uMjku090Hsl0rRhPenbk6W2x7eaV6xEcIx1YaHS2B410IX32rSMEGI4rJL2nSjxmg+s5lWs3PjN2mwhgGN+UQuXOhVL1QNxGPOYx1DzxRSk1TPw9ULODMMwDMMwDMOc/7BayQQMMkF11u89QbNGptDTa3ba+odaWTDMGdOHYh1EKIYxgf7jZIkSSPE3pyxkX/cJwVsK0Sr4HQZHv/1hXxrYLZ5mLfP0OobwPXdMKv1x3W7hU66C7Ol+nWNpypAGD2FZnPLuRgFZH18QqVD4DwJV1pEiuj6lrchc17PipZ1KRFiwyHSX7Ya4dV1KG2EVYQJi0kPX9RLZrFLohrj98P9+7dEWnJPq16xmpdv5lquCFIqirtmW6zXPoCBg1/goL9Ed85VVMUH8Pn/ldvrdbf08xH1VpBvTtwPNg4WFR2HFRPrblCvoYF4pPXhtL3FctMsOBAgOF5Zbvu9rYIO5eIkMCbYVgP2xLFFBQWagr/BAEAn/vjhYIAJjEKTtsMrytqpvIFeoQbi+Nrk1TRzUxWjJNWdUH5ry+hZRcFfOB3bzKlZuQNhGoVP4m+PvjjqqF+/JQAHmXs/iwIk0e3QKHS2qFNnt6nxYXdcg9pvAPn55/SXu7QNZqcQwDMMwDMMwzLkNi+hMwEAgg7glLRggsCW3i6Hn/rmL+iXFiuJgUWEhVFZVQ5mHi2j7kSLxQIkH99CgIPFwPuOmZPquoFyxYKjnB07Gb0SG5DU9qbzaXsC0EnH8DRYFsk+7jHYIMOXVdcI65dc39xV1AZC13SIimI4XVwoBHUV59bGBnGRTBmb/TrF0T0Y3mjWyj9hXi4gQOl5cIcRptONXN/QW4pEp2AVhCQLapUmxtGpbLo1IbecW0PEe2mOHaksDe4hZy70FLpzvE8sy6dnb+nuI1r76lsvttuYUeNnjIEs2pV1L43w1pHuCx7XSrV2QLR8REuRxnSGQf7b3JK3OzPXOQMW1cxE9NT5NFFqUbVPnRRW8DiEO/VTNilWJjbTvT7iXCELoRSWZi4eQIJcodmkKlE0f1kvUJgAQvv0RuzHf6B7o6LNylciiVTvEeEEBXbtVMyY7Jbv6BnKOhQD97n1X0m/XZhuzvReu2k5/v2sg3fqXje75wBRIlMFA1VpGDwzgmC0jQ8QchfdgkYPiwChWPOHlDQ1FpHsm0rJpQ8T/ca1OVdjb0RWWVbvnTymkB7L6iWEYhmEYhmGYcxMW0ZmAwYMhssGklzEeTv+6viHLc93OE2IbZLnKDDBklsFbVH3gh1fpI//4Rjxw4iFbt2BgGDuW3DOQ2rdusChB0dr1e0/aevlaiTh24DOj09vRhAGdqE1MuMjWbBkRIuxVln15yOd9+prR3ik+ilo2FgrFa10TokUGui7EQKydvyLLmIEZRC4akd6Opr7RkBEOcF0wXiHwoCieyTte/j57VAq1iYkQ2w7tkShek1ncqgWEk9VEu5gIS3sdCFwQrVUR3VfrHPzcerDA0prlyu4JYjvcI2kj0yoyhMIU0dDK2kXNekdWPMR+nLPVeaC9CAR2DYb47j0vqvvFaoPS6lp6a/NBmjy0qzsrVm17x7hIS5Ecr7cMD6EnRqbQk2s8hUY1A5m58Gs/HD1VQaPS23vUAkB/r6iuFfYl6CtJcZGWAR3dsgTbl1Z6BiHVugQH8krd40VmcSOPXe2D2H7x+DQhtlvtRy2CjMBTi/AQqqd68bdCSFAQBQe5bLO9jxRVuL3bIaBbBRKlmK1m26vFUf/3voYi6CHBQdSmZQgtfB81HryDZAtX7RDFSXGMGY12N3aIObLRax7wyhGGYRiGYRiGuXBgEZ1pEtLLOL+0SviF9mkfQ3dndHdnguEhHYKclYUCllvjgfObnELx8M0ZW4w/9O0cRzExDYUv0XeuCw2mwd0TaO7K7V52IHZFKu3AZx69KVmIqboliUnctgLCu1VRUYg7aka7tDaxQwjOVsLu3pNiJYiKbDvGm513PF7/5fBL6M7Xt4h2yexU6a8MQcnOSgICPs4TWd+waYC9im4TI4G4HUigAduZrFkgjKN9EL9RSBB+yhv25bmP/dY9g9zbWlm7qFnvyOLH+5McCh4ii1XNlFc93tFm3FsEWzBHHiuqoFsu6+xejYP5EsInsobxs6q2lhaPTxeFFtdbWODkFpbT6L4dPARU+LEzFwfoY53jomjfiQZvchSrRYAPAbeCskpa+rMhFBfdUHfAFNCRRYClvZrsW+iDHz18tUeflfMQin/+9sPTgTd89r4fdBdzBYrpYoUEBHHs43e39vPq+1ZWTWpb5KoQOzAmO8c32DrhuBC/rQKJGIOoUYB5QZ97TlXW0G2vbBLHnzO6j3EulfPJjaltxd82wS6X5QoSGZTAsWeMSBGvYd4JZPUTwzAMwzAMwzDnJiyiM00GHsC6aCkzwfDw/repV9ATy7K8rBOkiDgirS3d0KetyF7DwzcL6UygIHsavGgQMAPtV8ju1AV0AIFzlsGSxARET2R/W2VMvrslxyujXc/Y1IvpOQnOJj9knANsb5y84yHIStEJ9i0QmuT+LIsO9kykeWP7CHH4G5vMUFXMiokICcg6B9vpRRPtiobKY2/cn0fXJbemlA6thDBmVXRRZr1jdYOdx7ME7+vWDTIQgvuIjNmTpQ0rB1SxTtaKkKtxltwziNq0iBCfQ79yF2ONCHGLoqB9bCSNTGvn0cdRTJW5eND7QFRoiJhDYAmlYgroRIYFi/+/MXWgV9+ymicRkNLnwLSOrej363Z7ZaNDuNfbYWXVhHkU2eS+COhyrEnvdojodoHE+6/pIf7O+NOkAfT1oULq1zFWZPGjxgGsWVDPAJZQuYUVXp83zSd47fXJVwgLJ/3vHbXmy3f5ZWKuRwAxkNVPDMMwDMMwDMOcm7CIzjQJqwdj+VD9o4FJdKig3FbgGtu3A63LzqV/ZR9n/1DGL3YfLaYOdaEeBSd9zeT2VbCGkOmPJYlp3//ZfYJWbTtiWVRUz5L3pbimk+BsJfzCLsGp4KD6WbTjrXsGi8xu1VsYWaiwN5Ae6cjChG/4lm/zLW1iVJsDCPMQ7+zqLFjZ8eAn7CVU7IqGyvff2ZIjzgXeysgsteNUY1+Q52aVfY/gAWo+yM+oyPsIz2aIak7XJTz0tB87+pRdv/K3jzMXDuhXom5CebXI/EbwUJ8DnfuK9fZ2xT8lVitB+naOpQMnS+loUbk4ppxL7ayasA+5qmJHbrGocWHaVmZ7j0xvT0/fnC7qrdiBa/Tyf/bS6PQO1D4mgmrq671srODtfvOlHb2y1U3nh/fvevNzUeAUBZQRbJT1XNQAIV4T2fAulwjoMgzDMAzDMAxzYWCfXscwDjg9GCOzDFlfdgLXotU7qL6xFiH7hzL+cPOfNtJj730jij82RZCa/vZXdN1zn4iCctc9+4nw8cfrJssRHaf3MUbatAy3FeIrqut8Lq6J96WQDLHJhO53rAKhBytArDy09c+i/S98tJu6JkS5j4d9oIDorz/YKbyJ8Q8icFqHVrY2MTLTVNpH6CIx9jttWE/RBohasIWBVzL+zR7Vx70dRLlOcZ4iIPbtdGwE9SCg43en7HJk7EKgRFuRfY9MU/2aQUBHe/t1ihXtVa0b1PvoS9ukZQbD2IG57tH3vqERf/iUbn9lE930h0+bPAf6gh600/u0DJQjWDTxtc1iblbn0lMVDfOWFdKWCGMNIjXGnYrM9s4+UiRW9qzJzKXocPs8EClmw+omuX2M8W8QZLLPW5ElbOfszk+do2YuyxQri6a99aV77pMCujp/Yuxj/mQYhmEYhmEY5sKARXSmSfhiKQE7DPgj2xXmS+/YSvyf/UMZf5G2KlL09gdfBGvdckQnJjLEcYw4ZX7L4BGOl1tUYVtc83BhOe07USL2Ob1RcNaF3QVjU8WYgp0AhGhZ7BPbSn9yCFK6UAWR/MFre4n31QzwWaP6UMe4KJExj9+tRCan84Qv/NqHrhJWJfD2VsG5P/Z/2+iuNz6ngd3iafm0ocIWRor0Nzz/X4/gBoqWyrb4cmy8r7ZZZpebkFnvyO6F7/2ApFiRaQp/ZCnq4zwG94inu9/8nF5bv1/4KqvWDWqA0Ze2BVr4lrl4kIVuraylApkDfUWuEpHofdqpxkArhwCRzOi+NClWjKlF49JEDYOXJw0Q4w1j7+3NB+nxESnuOfvLnEKPNqmoYrZsq+XfIHvzKL1TK4/5wGnMhoYEiblWPybmVXX+5MQAhmEYhmEYhrlwYDsXpkk4WUp0SYiipPhIKq9iEYk5c0BEwtJ9O0sDf1dSSI9rWI5AbFaLPErweoswB5E9IlQU3rUDwSMIYHNXZNGdV3oWBNU5kFcmMiAheMMC4Yqu8eInPIuRnZ15qIjGvviZR2YkMkQhQN0xqIvbdgA+7BDFkQWveseD96dnGP3kVX9l+HzrOGV3J0SHe3klm+5FdW09LWjMGLcq+ok2wd5GCmq++JarwpiVt7tehLZLQjT99pZ+on8VllWLQquwsPnxXze7s0zx+bmj+1h61ju1LTYyNODCt8zFgyx025xzoK/I8SaLlOp9Wq9RoILtMfbsChJD8MaYfHHipfS39Qfo1r9sFGOia2I0FZVVixoGOMbEVze5xx3qqKz5+VU0B7UGbDzK0daySs/CojrwWX/4+t4046YgKq+uoWiHeR2e6v2SYumxEb3pu/xyo60L4MQAhmEYhmEYhrlwYBGdaRLSUsIkRA5PbiOEuNLKWmFnYQce/H/LIhLTBALJ+HNaSYF9QvRFNjIyPVUhHULNlKHdaMH7220L4mKMbDmQbykgQbRtEREi9g+7EXiW2yHFK4y5uvp6kaGJTG1knP/PpoNGyyR48zYI5g3FK+2KrUq7GOGw5LLxVz5e4vWenXe4U5BMvRdWgpz0XEa2/v6TpcKz/KnxaVRcWU1VNfUiMxQFBXWkDU1c1GlBS3q7I4NW+jF3T4ym9q0aCnvq8xNW1Nzx6ibL9pcrwpkeYLT1VO+VKITC8upaYYVhKiLLMEAWurXiTGc9R4cFiwzx0qoaMU+p3/1OmdvwVIewDdRxkNE4j0rxOa+kSnieTxnaVeyzuKzactxh++LyKjH/7jteQoXl1V5iNsYdxu4lbVvatg/+6ne8+oXY/u6MbpQQ7fm3jVoYHcDqCXy887ixDgTgxACGYRiGYRiGubBgEZ1pEhB6np6QTjOWbvMQGEelt6PHb0qm7wrKGx+uXaKAF5ZN6+ChNTu3mBKjzcuyGcYXAsn4c1pJIfcJLfnxEcn086o6ig4PpvCQYDqUX0aPvPeNyIpEgTmrwqT4ec0lralbYoN9CcQWKcjA5giiT2FZFd0xMIne2nyQ+nRoZZuxCWBvgHEVERosRBpkcNplgkIIQttQXK97a3MmuK8FTe2KgMrsblyv9TbZ3U73wiTIWRUnxr7nj02lya9vFO2so3qPa4drNnlIV3p7S47IFr8+pY0oYgwgssl9YT8yw92pfb70P3l9vjhYQCFBLncRVpfL5bbUubxLHC0enyZWIKxrbJPdNWcubmShWyvOZNazPjdgPMIuCviyEgSi818+2SesmvC3AeaI8uo6YfGE///fz66kqNAQqqmvo2VfHRE+5gABRgQIMV7UDG9JWGgwRYQEiUCUPndh7MOeCnHJzd/m2f4NIq1f5Nwxc0SysMWat3I7bT1YYFkYHYJ7346xxuAAxjYHwxiGYRiGYRjmwoFFdKbJdIqPEkJ6TkG5WE4eFRosxB8U35IPleKBe/IVRC6X5bJr+A7/+ua+Yn8M4w8QLGRmoD+YhGA9ixDiEbLEVfEF/RZ+5M/c0o8eWPIl5eSXiWxwKxG0fWykGANPjU+nsuoaCgsOpvkrszwEGWRRTx7aVdgl4LO6KCO8zseliqzKgrJqIaBDjN15pEgIPLBzsWP/iVJ6anW2R7uQdS7F/xbhIULwhWCkZ34fOFlKR4vKhSCE7Uora0TW68JxDQKwvH52NjGqmKQeVwYd1HthEuTsPJchdP3q+kvEPAIhfNo1PcVcpGelohjg0zenC5Fevee+iPy+9BUV7Av7PJhfRi98vIeeX7fn9L3slUirH8ygwvIqOlxYIYoebtiX5xYJddsahgGy0K2VtVQgc2CgtSPQV1G/ALUAEJxyuUiMLaw6kwE+NViE1zFfYDz8Zu1Or0AX/g7A3IH6CzuOFHnMjTg3zHG6VQo+t2pbLm37rlCMtRfvuFQENMXfIWHBwpIlNirUvUpkQFIc1Rnm1akZXWn6kgbrF2p8H/NXYXk5PXZjMtVTPT2jtVluB2CpheDAwrFpVFFTK+bHkKAg2vxtvrgObbQCygzDMAzDMAzDnJ+wiM40ywP2E8tPe5Iia+yb9fs9HjjFA/ebn9PsUSn00HW9xEMuMs0+yj7ufjCGMIAHbDyMo4ghw/gCBBbYrQSStav7/OqiKnj8vW1e2Yuyb49Kby/EXR2TCCptUDBepr/9ldc+YUOCLGpYuug2IxCDO8ZG0uLVO+jjnSe8xKclmw8K4dgO7ENtV2lVrTFzU4pVwJR9qdovAIhos0alCKHKzibGl2x3XHO8Z7I/ccq0x9xyWZc48fuk1zYbt8P5QxyTvu5WIn8gfcX0eQh5L32810t8E+1dkSWseHBO6nVXhXS0kUV0RiIL3erWUk2ZA5tSOwJ9debSTPr4V1cLsXjNtlwPOyX0a2Srd42PauzHVcbxIH/HeJi9PJP6J8V5zHPyXDEnyjlADcCjHZg3MK57GW1bquiFj/bS1pwCr3kVQcnMw0VeWe4nSirF6hMI6PA/N2Wwy7bfm9GdaurrRWBUD7Zi3qqtqxeBVIZhGIZhGIZhzm9YRGea/QHbSuzCQ+oTy7KEFQWydsUDZlKcx8MrxPWDeWUi25XFI8YJWAB0bJPgt3gkM6GLyqsoOjxEZHgjk7u0olZkc0pRFT67Jo9tKZ5AjEHhyY37vQUWXQSVx6ysqbUsZir3qdqMSOBlrgpLcnuAcRQfZV2fQLUrQLtQIBMirr6t3J8MDJgyvyFo1SuCFkQ01QoF54nrJrPMZeY6xnZ8dBjNXgahyfO4qriPfyhaOuHSjjR/5XafPZdRewGZqLsNXu0mn/tA5he1sKovAryYGx36j/y/LhLKtjKMilroVvZBzFln0vrHqXYEROJPdh0XPuZ3DEryyEJ/+d97xZjxdTyg/0vvdH3emTkiRWR8V9fUeRXxtAo6YT5CDQV5XNPfJvibRAcCOuZ1ZMXff7V9gLJVVCj97p+7jMGBBat20IRLO9B1yW35bxqGYRiGYRiGOc9hEZ1p9gdsJ7Grpq5eZKtDbIeAiSXW8oFb+EOXV3MGJuMTvdvFUEyMf+KRKRMaIvM9Gd3pZEkl9e3UqrFoZRXV1teLbGKTF6/s6+jD6LsmpAiqHvPlSQNs22caPxDHNxiEelV8KqmsFhnReqa0mrEpQWFAOyEf/t319WbBST2mBMeD8G3Kblcz1yGmWYloUgRTBW6I4ngNticRIcFkR1R4sPgcggm++EYLW5xSWMrUUExkCMVFhVFbH2wX3IVVmyg+ol8ltAgz+tvL/nYmPa6Z8xcI5t+nX75eD0AtsongIwocI7D2oCJqY955aeIA2pFbRLnFFQ3BLVGt2Hnus/obAsV37/9/Wy3nYz3oJOdd1Jvw5biqxQu82uW8/tiN9n8qhwUHGWtYAMyFWKmDoAf/TcMwDMMwDMMw5zcsojPN/oCt+hmrD9sQzzvFRlJwsEsU2kOBvfV7TzYURUyKFWLSlgP5lNahFWdgMgFj8ttWs8F1kRd8lVNIEaFBtOLrw/Toe9s8xGuTF6/a1/G6lagDEVQ/plMBvljN1xhiFKxKJry8wVYEahERStFhwcJeBZnmOB9oVv/eddoySQKx247v8svJCYhnMhgmRKh6aX1z0jJz3SnApo97ed/mv7+d+nWOtS8MmFMoCqf64l2ek1fqUbNBiv1PTUinpISGArC+4CTEWxUjlUVSn/1wl8f54Pxkf4M1DYoqMszZmi8l6IdylYtVgV/dkgjjEdtu2pdHz3y42zLjW0XOjeocifGK4CDs38ora+l/f3qlGHeYU9FuFTXopM67U4Z09em4ch6YM6YPTXx1kzgPzHFf5RR42Eupf9cIXGRb/PRwQbnwag8JDuJiwQzDMAzDMAxzHsNP6EyT0UUr6WeMh2j5sI2HS/z/6Q+yPbxc1Qfvl/+9j8b0ay8+P6F/x7N4Rsz5KAIhE7tVZBjNgT+/IuSqRT4hLkNQQWaiajkgbDT+bfaurq+v97LZkH0XwogVUrDV7Y5Mft/qPoOCXLT8gaEii1IWxswtrLAU6kF8VKjIhkRxPN2TWLdGQLt0oV7HSegHneIi6X82HXRfFwhkvliX2BEWEkT7TpR4CHny+qHg6fJpQ2nBqu3GooSYQwZ2jReZ7Hbe5RDydQEdYF56YlkmPXtbf58y0n0R4q0EfasiqRDUEWZA0ATFCGcvy6QF49JYeGOafc7EyhEEt+bD1knph3pRZMxDKB48eUhXkXGOIppvGPqubkmEnyioq37fO819eD9DsZ7C+HnrnsG0UBvz2AavT3ptk1tI14v7qvOu3XERuGrdMlysEIItDjLQIaDL/UIoR4Y9/k4R+1L+rrELIuigsCoXC2YYhmEYhmGY8xtnpYRhHJAF9/AQCyBKQtSaMyrFLRRJ0Uh9oAZ4D6/jfQhwKR1iaFduscfDMMNYkVtYLop0XvfcJ/Sv7OM0a3mmpd/24YIyUbQOfvzT3vqS7nrjc5FhCOHj8qQ4y+X46LNDuid4vAbB5MFre9GwS1rTNZe0dvd9U7FJ3dJDjg/sQ98nXke7IkKCxPJ/iDcQar7IKRDCkQm83ik+SniT6+euji+1XRB09Dar7YDoJIUnExCeMg8VeVwzpyxzvG+3T7y+JusoXffsJ+K8Id4Bef0gTH2bVyr83yHYQ/TCT/wuhSsIgxDhkZEPseqjh6+m5dOGiJ/4HcX98kurPNqNuQb7ef/BofTAsF7ifXlsK5AJayfE432A+79wXJrXOV/Z3SzoAbx+SduW4pzQp9F3IXoyTHNwpHHOXPrVYSGO6ys75HyJPiezudc1FgCHH/lNqe28vsfVviuzs/FT385p7sN3P4JQ+AkwV+kCOsB+F63a7i7+bCruq867VsdFdj2CVDW1dUJAhwc65l8Ud5ZzDGo6YG7B+WOueee+wfSmRRBBnWvVc8O8h/kP1/Zo49zAMMz/Z+88wKwszvb/nO0FttHb0nVhKYoKCBhFiUoVjTGW7x/sMYoxMRZQqtiiST4T0ZjEGOMXUZOoiIAaW4y9KyxVRFiks5Xt9X/dszuHOXNm5n3P7gq7y/O7Li/ZU97zlpl537mfZ+6HYRiGYRim7cGZ6EyLECCiycN70C1nZ1FVTS11So6jXmmJNPf5HGexUT1Ldf/BSiGCrv5zAAEAAElEQVQ6caYW44cFK9bRh9+We7YxiBcoWKsLRlIIuenMY52/g6z1V3/xPSFsYyl/clwMpSXFBtupq9ikbukhBRmILWj3EGmiowIiCxsF8JZePEp4/76xYS+t/tkpVFxeJaxaLjyxjxBo1axmiEB3npMtCne6ssBvnzJErO5Q9+teH/7pMvtSzwKdPz2bZj70bkTZ63hfrkjRt6n/rlpoVD1/sIGyXWOA83/BH98PZtMiK10H1isSV6brXecOF0UcTcDCxRV0wfsymx3FayG+4VpDSMN5QCFGF1jh4FUwkWEiRbc4cY2XMhNbZnOjPVbX1tNOjwCTy9dcHftuPTuLKqrrKCWhYfzDf7/+4UjRzvF//D4so1z97PapQ0WAzFTcVx038LsYTx679CQ6WNFQ5Bj9cO3OIvp0Wz4NF97u1TR+YGc6c2g3euC1zSErbOQ28BruMyZLKbWexNMf5Yr9V8c1WVz124Jy6p6SwP2ZYRiGYRiGYdogrUJEf+ihh+j++++nPXv20MiRI+nBBx+k0aNHGz/75z//mZ544gnKyWkQZ0844QS6++67rZ9nDs/E/JbGifktZx9Dk7N70G3Lc+iSMX0jylIFfdKTRLYow/jh/a/zKCo+yVcbQ8Fau/CBMJAdZCmaBFk/xSZNlh5SkDk9qwv97Ixj6P5XNoaIRShsN2t8P7pr1fqgsKSK9Si0WVldR198W0CVtfVCmHGB3xPnp/EwsT3YNajiPwIFK9fuDrEjUMV+nAN4fsPuAL//xOWjqaa2npLjUfAzQHkllTQpqyu9tnFf2O/LbEwpomGVysJp2SJbFIIW3tNtEKSQp54/P3YQ8rs26wSIdhJXpuvtz6+l+84fabRScRUM1YX6DvGxYWKlX29oCdeIYFoC1eLET30CPdQT9ACP0NdcRRWjMzOSaHC3jtbx9KNv8j32sUZkx5u83eHjro67yC7/1cuHxlnV2/3mZ9eGFUL+YGt+g7e7NuZ4nbd9xZX0z2tOporqWlEHprTRxz02Oop+8f3BFB0IiCAZi+gMwzAMwzAM0/Y44iL6M888QzfeeCM98sgjNGbMGHrggQforLPOok2bNlHXrl3DPv+f//yHLrroIho3bhwlJCTQr371KzrzzDNp3bp11KsX+2gfCdSJeVb3FJr3Qk6YB7KfLFVk1cJmgmGagp82ZqO4vEYI16Zsbt1rt6l2R3rWN8San086JkTYkWA/6qheZDCrWchqoU30OYixi19c5+k3Hh8bRdMffNfoeQwgliXGRdOaRqFbF7zQN1GwNBAgqqqpoyUvrg/JxoTINHviIJo3bYjY7zc27g8TpWSWOYoId0lJoJjohuxT2Ou4hDzV41zNZIc3sVrcD5nfr23YK8Qx7Lctgzs9OU7sE4RyFCt0ZbpC4NdFdNhhJMe5b52qUG8KovgNBpgKJjJMU1GDP17jpanNQUBev7vY6S8u2y6EYlmMVAffh+XRoC72wKTej1zvo0/qBaO/P6Qr3TlzGM1bniP6nr5SyVaXQC2EjM8jq1zNYO+T0RC0dYG6HCg0euGfPgwbI5PjYxqCh2W8uoRhGIZhGIZh2hpHXET/7W9/S1dddRVddtll4m+I6atWraLHHnuM5syZE/b5J598MuTvRx99lJ599ll6/fXX6cc//vFh22/GPDFHgS45KVWFIi/RaF9xhZjw8qSSaSrO4nGDO4cJkyqJsdF0y9nH0jUVA4VQIouOwpu3JeyF9KxvCFQJsVGUm1/m9MaGOK5nIatBKykCQ2x39S9kjEtklvY95w2nOfBRb9wWxGeIRfikKkZBcEZRQdi3QFj6MrfAaoszbXhPsQIF/0Fww3lEYVZkXyKjvk9GIr2ybq8Q1JddOSbM6kYHgpN+/korq+memcOpluppwfIcZ3E/UwY3xHb4LsMap6TCXqwV6N+H8AUf6VsnZwWFeB28DqHeFURBMADnOioQCDnXuq1NSwRxGEai9jfXeKm2OTUA5GXJdMfMYcLK6JyRPUVAfEz/DFr4wjr6NLcgJODVPTWB6urQv2AZY7ZM0gNetn6mWtSooJ4AuP+HI6mkooYOlIQWgfZjMYcxEX1XDXRCHLftkwyA4T2MEfo2wdThPWhYr1RR90EPZjIMwzAMwzAM07o5oiJ6VVUVffrppzR37tzga1FRUTRp0iR6//33fW2jrKyMqqurKSOjYUkvc/iBp7NEFaXUybb8N3LfVAHulEZ/5ZdydtOSlevpN4p1BcN4MW5gJ/qg0RPdJu5ABIJoioxtExA+kBV9r5YRDuH9nnOHt5i9ENp1RU0dVdfWiQKYKYkxYom/CwjRekaoGrSS/c127NIWpqis2uwRr1nMoKgeMs4XTBsqMi9hSfDe1rygKO1HeEJA4uJHD2VgqucZYr/8vvSO17O01c9/sr1ACOkQmlTLHAhnKI5oE/NlFilsHXSbh87JcZTZKZl+c8FxooioC/3cYztZPVLot//eRPOnZYvihu8YvNSlH7oriIJjX6q8hpUAn+WG2tqc0th2bWOifmwDPTJ7maMbtDlkaB/bI0UUU54+ogfduXJDyAocvUinGgCCQIyVJKrNk/T5R+Z5RlIc9e98qA1inBs7MIMWzcimRSvCA153zRzu3F8UWF40Y5j4rt7P8DreV4OKOqIw7+QasZoF/uoqfizmrv7eAHpcy1ZXx1p1n/QAmClAJ8dIrOZxWU4xDMMwDMMwDNM6OaIi+oEDB6i2tpa6desW8jr+3rhxo69t3HrrrdSzZ08hvJuorKwU/0mKi4ubudeMTlx0VEMGVm4hpSaFFvNSJ9vwB118zjD65kBpcOKNSTkyXKVoxF6hTCT9ePGMbLrr1W1CkAj6bTeKwOVVtSFFPtH2KmvCC2neclaWKCQXZqny1QGRrdwckUMVOZHV+On2Arpz1YZge3/yyjHO76dB9NWykNVs0g4J0ca+JvtX/87JlJtXRh0TY0UGJQQg+dsmj3i8N/e5taJYHzzQz/vDe2K/ZRZpkoeNCX4XBVd1YVwXmGSmq83qRv38S33Tw66BSziTQhXEQoxNQmxXPqva2aDApyvTFedABddRBhI+3lYgxEZknEIww7WAH3KdpWiozTdffQ0ByUd/fKK4NnJ8RPAHbddkK6Nn4G67dyq1VvhefORBW8P4OPf5taINy759zWkDRXtDzQO9SKcMAO0prqDdhRU0Y0RPETxSBXFdeJegwHhGcjwtWNFg8aaCv7GqwzW+op9f+Kf3jf0Mrz9z9cnO+gQ4vrr6evp6X4kovrzsqjH03td5Yhz0srPBKpozhnSlB177yl4cdXIW7cgvD/ZVNQAmx2bTGLm/MSueiwYzDMMwDMMwTNviiNu5NId7772Xnn76aeGTDn90E/fccw8tXrz4sO/b0QSKDELwmjq8gorLq0JEKemprHpAuzyQYaXBMH77cQ9Lhq8qSkDIhohSUllNS2YOE1mAEF5QmBNZ1rAfUD28VZAJnVdSRbuLK6isskZsF5nMfkQPk8ip2428vzXPKeL27ZQU9ltq9jbEJPl9ta/J76Nfyv6m/7ZLRJJFBdXie9i2n4KYaYlxYQVQ1Wx27DsscrbllVKH0ipxPpecM4y27C8JCa7Jz5uEJq/CngDZr6pdjUTNAIVAiMxxFBE1ZZQjE//z3IJgBjtE9d1FFeIz2CfTWLb82nHUFNBOTfsLEPxRxUabhUVrhu/FRx60m9uXHxK05ZiB/9AvXYI2gn9obxh/IGrf0ihqw5cctiqmFTvY1qjMNBGYM6H2bTXgiH6GFSiVNbVirAgEAsIGSg0CynHKZgmF/Xx01kl0B+pHaH0bY9ranUVWOxt8BjZUGF+9iqNe++Rnxu/bvovxDcejHgPDMAzDMAzDMG2DIyqid+7cmaKjo2nv3r0hr+Pv7t27O7/761//Wojor732Go0YMcL6OVjFoHCpmv3Wp0+fFth7RtIhPpYu+vOH9MTlo+mav39Kz/zkZFr4gnn59bcFZc5tQbRjmEj6sS3D1yZky0zk5LhoYbsBywETUkBeuCInRIQxFebUMYmc2B7sTGB38sj/nCBWZqzd2VAcE6KK+llpJdMrPbyInZq9jd948sqxRluRBdOz6eI/f2C0OvlyR6HTIx7BCGRw6sX38B1YMOk2KsHaBgcr6cS+6WHWKzjPk7K6Bi1Lpvz+7aAYhvP5szMGexYYVfHyUu+dnkgV1XVWkVkV7/p2Sqb7zh8pAngyEIOMcGSAv9boqyz3E9YqGcpqG9u5awqu7Hrs787CcjrQGHRAm21LAjrge/GRx9TG1JUmm/eVUEZyeKBQfk96hD+mWZxgvPqVZUxURW8T6HPqOK0G7nTPdTUI6LKEkvUd9KLNeP24zHRKio0WVlfwbl+woqFIswTbQrC1vLqWdhY0WIXZ6JWWGBYElc86yJS31X/pqtg9cdFghmEYhmEYhmk7HFERPS4ujk444QRRFHTmzJnitbq6OvH37Nmzrd+777776K677qJXXnmFTjzRIzMyPl78x3x3YBJ7Qt90IaBhsr0rv1xMym+bOpSKyyFKxYiJ8mV//Uhkh2LyqnqwqhNMFtGZlurHtmxdNRMZXrm0r8T4fVVAVoUmZEtvzyul6KhA0JNXzZ5EETtkUOoCuprRrbb5Eb3S6PYpQ4RIKuxQ4G3dtUOYr7aKtFjAd/JKG4ryllfXBUVgiFIQ0LFvKjiW604bRBee2MfqEQ9BrENCjMjCHj+wU8O5aLSISY6Loe8P7Ub08qaQPozjuP70wdQvIzxzXgJRHh7k2Gf9elxz6kByoQtNXl7qEOqP7eb2B1eFeZxPKQAG/dYN7Qb2PnefN9y6eqA5RUC9suu35ZWJrFf8xsIZ2aJNeQmUrQm+Fx959DZmG5f0QKH8nh5Uk7zt8Pf2UzxYHaflb8AeDhZUcsyFvcreogp66qoxlFdaTXuLK6yWUNgGajroArp+rHht3tQhoqg07L86JccH+++WfSWexarjogM0Z/IQcS9AEA4rVvYUldPuwnIa0j3FOEYieFtcVi2ObdyATmK1ztf7S3yvcGIYhmEYhmEY5ii2c0Fm2qxZs4QYPnr0aHrggQeotLSULrvsMvH+j3/8Y+rVq5dYCg5+9atf0YIFC2jZsmXUr18/2rNnj3i9Q4cO4j/m8IOJH+wYpDhWUl1DP/37Z0Hh8azsbnT545+ICeyTH24XhQ7rqD4sy2z2xMFCiI+LiXZm+TJMS2T2ykxkmyArva9tQhNElOsmDhLFOIGaPfnwJaNCtmUTn+Tf8HZXM7HhSd4txX182Hccw8V//ij4GvYVWe6urG6IUb0zkqwe8bPG9aN5z6+l26YMoS4dE4SdiXrcp2d1oVvOzqKf19ZSXR1EsGghrsMLXReB/FjaANi94HyarpdJmMbvwObh9uVrw8YR6aX+3E/dtiq2DFCvdgN7mnvPGyF8pfUMVpMvtF+8xEZpv4N9WLRiXbB4KsM0tY3ZxiW96KX8nquwsM3f2xXwwuux0aGrcPAbsninKeh4Qt9smr3sQxG4P/WYLpSaFF64F2Pc1gOlnseK8ee253PEdu88Zxj1byzMC/svV8FmfB7e8hf86QP6n7F9xdgVFUAx0RrxrINxGEVJb5g0WKw4kskBsIj539c2i++uf6/IGbhgGIZhGIZhGKb1ccRF9B/96Ee0f/9+IYxDED/uuOPo5ZdfDhYbzc3NpaioQ969f/jDH6iqqorOP//8kO0sXLiQFi1adNj3n2kgPSlWLH/GZLJLh/gQ39ChPVJCJrAfbM0PKYCIzFtcYmSCwSnUltHGMC2Z2SszkdHOkMmNLGNTdrEr+1JangD1M7rfuEt8wnfQd0z75oUUqODd/pNTB9Dk7B50oLFonQ2I3gBizf0/HEnf7C+h+NhoiokOUEFptSi2eWyPFLHNFV/sDDtu+Mej38Ka5tzjejVk8xtApuit//oyzPpFtZWR5wRi1YvXT6DFK9aFiG0uYfpgRZUYQ+YECw7GCKsEiPYYe5Ad6hLvbBnjftrNwMx0WurhxR8pXtn1qv0O2t5PTx3IIjrTrDbmVxSX30O/d2Eat2zFg7E9jLtb94eK3fgNV9AR1lVy7FCfFVQLKQT+Ih2Dq2vrQ8YA9LfjM9OMBZsxzlTX1NHSi0cJYfzNTfvFGIZ9ARh/UJBUL0qKmhIYP6tqcoStjFqLQwYunrjCXWyaYRiGYRiGYZijWEQHsG6x2begaKjKtm3bDtNeMZGAyevegxUioxY2EMhWHdozVUxcu3SMFxNPOYHVCyCCf11zMl237BP69Q9HWjPaGKYlM3shfMK6o7CsWggzEDWQxQx7gVIUEU2M9SW+QFwB6md0GwAv8WlnQUOxSrl6A6L2R9/kU0piDKUnxVmtXdBHIDJvzy+jrftL6N6XN9AlY/o6LZNgddI9JUF8F8dZUlVLD765JSzTEitIbv5XnvW4YQtjE6KRgb7tQKnRO10/b3JMQADNq0isSseEOLr35U1h+w3BDsIXRHSbeOfKGPfTbry8+JuCSWyUdhPDe6fStwXlwuf5s9wCIdjFx0ZZRXeG8dPGvMal0srqYMFP1C1APYemrO6QmeJYaQbbE7TrjqLuwHq6aExmyGfxrOAaczGmXNo4dtieFdCHX9+4L2Qc9DrWsqqakO8fykL/Rvxb2nmBEX3S6NX1e+lP/90qxi65umbjnmJnzQgZCEOwFvcaHe7LDMMwDMMwDNO6aRUiOtM+KK2spdLKSrGs+dazh9AdK9eJibD0NXWByTUmozJ7zG8mLsM0JbNXLr9fnbNHCNSvbdwv/gNor8hkRKY1hA8v8cX0vm4DoGdF6sDSwGYbA/9tFLTM7JRs/C6+99AbW+iKCf3p4jF9rZZJEJTwOgTm0f0yhPAEqwFbxue+YndGO0RcVbySYltReZU4J9i23/OG69Sp0RPYjzCN35q/PMdqjwO7BLm9SIR5P/YTTfU894NqS4HziKLNGEdhOSGRgh2CPPqxMUwkbQy1G2wIoTsxlmYv+ywoCmNsjKQegBwTkNmdHBdDn+YW0JKV68W9HlnZr23cR1k9U0ICjiID3ON5QR07TM8K2I9Nu4tp3jQ8h6z3NQar/QffR4FkjJVY4bNwWrYItOrWMtKWSm7/55OOoVGZ6YS908feyyb0o9nLPg++FhsTJc6B9HuXwTGGYRiGYRiGYVovLKIzLQayt5BlhuJcEH7kJBITw2d+Mtb5XUxA1UwtFoSY5mKzEUA7Qxb0C1/uopP6ZVBMVCAkw1cK4Ms+3C6yBb2yL03iDEQi1Qagd3qi1fNbtnubhQEEK1jN/OaC44wZ6cLDe8sBuvHMY+jX/95ktEyC4IoVITMfelfsmxSe6upChfZISEuMc3qfP3nlGF/nrSle4vKYTeB4FkwbGtxepBnjLvuJ5nieR/L7YmVPcQXd+I8vjIECZO3PPn0wJcXFWO10GMarjUHktgWMEIhasDwnJKtaDQ6qQrqpb6hjglxhc/KATvTYrJOEfRVqKOB1PeDo93lBYnpWwH6g5kNuXqkIhmIczEiOs67Q0QMA6hgAm5fFyvOMzZYKK+/uf3kjfZpbGGb/gr68dmdRSCHg6ECAfqzUrpCiPMMwDMMwDMMwrRcW0ZkWA5PQ/SWVwt9cL971+oZ9zmXOmGTKgoDfdbYnc/Sg2gjk5peJ13J2FVE91dPH2/JDPGvVzEIpgMcEAtQzNcFTAJf/1ts9xBW0Z+zDrxpFGXiNq9YAENjjYqKorDLc5kgCwaqgtMoooksPb3iay983WSa9eP34oIgjhaeSykMWBjo4Lj+iE4Q4XUAH72/Ns2at4nwO7JJMb/zy1GDGeCTovuVSpMM5hXCF4AD2qymCN74HS6p504YKz3tcFwQhmut5HinF5dVhwp16nGB7XqmwrbHZ/TCMF7dPHUKzCsopEAgEA4nIwh7RK5XmPrfWGhycN3Wo6Cem1R3qmGAtzDyoc9h4K4XnQH3A15jrelbA2I++8dB/vg4pEK2v0FEDADJzvqSyWvT526YOETUiXHZecyYPEf9GBrr8nOnzyDqXYFzE+GgKjk0a0lAPiGEYhmEYhmGY1geL6EyL0qtjPO0trQp7Hd6hDRNYfZlzJ5ExBj/SS//6MZ3QN/2wZHsy7R/VSiAxLloIL9Lb9i/vmC1MAN6Xy+ohbsNWY8k5w2jBCzkhGZsQea6bOIguf/xj8Tfad8CRoZma1OD5nV9WJTI8dcuWG844xnk8By2Ct/TwRlFQF+VVdfTwJaNEEWAU4cT5qa61W9XgHCy/bjwtfjE0C1PPOhVZ4QaxS2aYBigQIsQLW5lx/eiuVRtE329KX1d9y20iHfYT2aQQ0/xiyqiX21FFNrSpFAjrSgDA9V5TKCwPDxQYxcjG6xHJcTKMqa2jLa3+2SmEPO91e4qN35MButOO6UIn9ssItvutB0qD7T6v9NCYYC3MvOWACGbKTG61TX9/SFe659zhYgVOyJg7qDPddNaxdMXfPjaK33rfQ3BJBi+xHSnWo54DxnYI5V07xovPyvPx6fYC0c/ue6VhVQ/GTBc78svoy9xC+t7gLr4saFRbLR1TwJFhGIZhGIZhmNYDi+hMi1FUVk11gUOTRT07NDYqSmSa3TZ5iBAEMRlH5hvee+DVr+j/Lh8tJrM9WAxivgOBSGaaI7vclVl4xYQBdOIl6fSXt7cGP4e2DHsDZG2WVx3KvgQvzp4g7FEg3sBypaSixuq/XVFTR/MMXt4QT356mtt7vbqmThyXLpZKD28vD3JknV/75Gfi3/j8HecMow+/yQ/LoJccn5lGL+XspmkjetKi6dmiCKnpmPSscD1rFbYul47vF7SVQfbq9U99Lt6vrFkjAgt+xWasWEFG/sGKGnrqqjFi/4/rnUZ/eWdr2DFANIN45nf7tox6bGfhCzm0cHo2zX1+bZjoeOc5w0TGq/5eU0R8VQzsEB8jPKgRjMC5soqRER4nw9jaOv5GsBCrMOKi3R7iyfHR1qDTohnZ9PNJg2l4r1ThhY4sbdiqyLasjnvXnjYoLPiFsQlj7l0zh9GOgnIRUIItCgKhD77xFf3rmnEiGKiK37a+lxwXTUtmDhMWMjsLysX7723NC2bc43NEh84H+pzaz7y81PE+AgI/PW1gyOv680//zsm0YvZ4qq+vp4v+/GHIeWAYhmEYhmEYpm3AIjrTYpPyPQfLKS46RixTPj2riyhyaFrCvWD6UApUQvCrp/W7imjKsO6iuFhUVICzKZnvTCCSoggEYVNBt6DVSXwM/f71zWHWQzsLy6lvRhIlxEaRSDm3+G13S7HvGwRgmwc5+o3LwgDCzyNvfR0mlkr/3rc277cK4ngdx6kKw/NfyKET+6ULGyX1/MjP4/VnPsqlO87p4wxsqVnhOjin+aVVdMXfPgluE8K6PNfYD4jGfsRf+BtDqNYL9k0d3kP4EJvwu320md1FFXTR6Eyxj3qbOLZHCs19bk1Ym8C1evfrA/TS2t1h70Uq4pvEQKxQkJYXEONswZ9IziPD2FaPyLYEOyQI1rbxBP2uQ1yMcZyFXRXssz7R7LKw6mz5tePpm7xSio2OCimk+e+ff0+sRpNBuoqqWiooq6bbl4f2d0lVTZ3oVwiqbTtQGtZvZd+757zhNOe5tTSyT5ooFm0LtGGlkTwO1ZYFuM6Dai2D8VnaX9lWjeDzKFLKMAzDMAzDMEzbhEV0pkXA8u3OHRLomwOlYhL79NVj6VcvbzQu4V704jqRlfbljkKR3QuvaghELn9mhmkJgQjtcf/BSiHqmrzQIZrC6kQVRFvSLqS4wt7G0W9WzJ5Ai1esC7E/0cVnk1iKfUAwCoX7II7rGfjy+yr4zKXj+omscGRMIgMfvurI8KyprRfH/esfjvQUZmUmvKk4IYICvdISRdACYpMqoEtQjNgLiGW6gC6OYcsBuuPFdUFLCBOyiKpJOMe4hXDeIpwzzWYKVjbIxP/jW1udAjYsI0y1HiIV8U2CpLR3wPHJFT42bMfJMDq21SMS9NFNu4uNATYEduZOyRKrakzjLNoqssXD+2qeKNCJez/6khx3IYhjJcdxmenBvvBNfpnwIrcFHCHUQ2Sfv3xtSN9Tx3L0ve15ZcFxzhWAKqmqEcWl1+4sFOOeil741Dau4nPPXzuO7li5XhyjadUI/l6yaj3NnzpUjGc62CbDMAzDMAzDMK0XFtGZFgFWEkteXEeXju8fFPpsE2C8DlsXTGrxnZvPzqJvC8opOZ6bI/PdC0S617Tqhf5lboFMMg9is9GINNMYpCTY23iDvUkN3XjmMUH7E2lhoIrPBWVVxqKZMit+6UXHi/4HURW+v6tz9hjFa/V3dYFJFkP1c1wyE176DqvbgB8xrocatNCBX71XEVBXBj9ENIw7NmQRVdUqJTkuhj7NLRDiPArMGgW/F9fR9acPotOzulJJhd16oSXEbVfgB0L6bVOHUm2d+3fkcTKMF67VIwC2S6hXAGsXCMKy4Cdez0iOo4zEWNpVXGH8rivgJO/98t8YayFEq30EfQFWMTvyG6xXTGBM1gV0uU35PvZBjvVefbS4vCG4OaZ/hsjCtxVTxb7jOQXWVvq4jP/vLqwQ5+us7G7Wc4B+fsvZx4Zlt0tRnmEYhmEYhmGY1gurlkyLgIknJrQjM9PFZBC+xy7kpBbfuaFxcg7PdIb5rgUik8ftu43evDNG9qRardhmS9popCfHiUxOUwE5vL6nqFL82yU6I3Mb2eO2LHjVYubrfSXWfQe90xPDssj1wqF+wH48qIj3qnf6wb01TjuEVWt305odhc6sflcGvwscC/bD5pE/Z3JWiOWEqU1Mf/BdkUlvw8sz2Y+47ZkZXFkjjsNm9yOPk2H84Fo9ItsS+u5vfjhSWLNgzEGGdnJcDKU1epGXWIJyXoK1+j7GwTmThwi/8q/3l4iCoCWV1VRW1RBAtOFXqJfb8OqjsJLBmIv6DbDV0scrGWhE/5syvAfNfc6cRV5bX9+wqs4RdANIGlCDE2qwdP0dZzu/yzAMwzAMwzDMkYNFdKZFKK2qCVn6nBgbuiRaR53UQkDq3CGe8ksrqXNZuMc0w7SUQKR62OrAp3dvYQX1ykgMEVFa0kYD1h93nzucbnt+bYiQDgH9rnOHi2AUVnWoYqlaoA6kJcXRiD5potill92KKrzqhe5g24Jt2cTvSDH5w4OYqIDTd11mc7qy+l0Z/ADiux6cwN8oKAhsHvn7ihuCFjak1YzLFxnZ7LB/MVm6+BW3vQI/6Ulx1K9zBxHcsGX887jJ+MVr9YhsS7Y+7Rpn/RTiVIGdm17wOCa6WtQasPU5LzC+YdyTY71fX3P0d5d9y7ypQ6iuvj5krMG4itfhpY66GYFAQGTS43Xb6h/0d/yOOh7j+72mck0YhmEYhmEYhmnNsIjOtAjSikUufX744lF0z7nDqWtKfFgBx+Mz00KEzO4pifTjxz6kR/7nBC6Ox3xnAhFElVnj+oV5g0uqa+uod0aiaKuzJw4KiigtkWmsktkpmX5zwXHCogQZ1hCIkaEOgV0ixVJ4/5r82FHA7pdnHSu2AaRNSUpirMjmVPvQdRMHUWx0wFjoV/q6S6FXZEQrRVNbgk7JcXT36g0i8xKZ37Bp0G1qIDghMIDinlsPlIYdhyuDHwL22m8LhafyZVpm55KVDf7DNqsUL+S114U1GZCABz38nG+dPISmfFtIS1ZtCApnkYjbfjKDvTL+GSYSmtuWbOMsMtddBZL1IKY6vmI7sJCZO2UIbdhVZPVkxwoar2ODsA1RG17na74tpCsnDPD0Nce+6PYt6ngCu5ab/vUl/fMnJ1NReQ0VllWJ31qych3d9nxOyJiE1SvIbteFdPwmRPTHLzuJtuwrCd1x3UuMYRiGYRiGYZhWBYvoTIsQFQiEZGPWUT2tXrsrrFjfitnjhdXLpX/9uPG1zvTv9XtoSI8UemfLATrtmC5H7BiY9gG8r8uraunnkwbTbVOHUHQgIIROBHpuf36tMTsQwga8sc8Z2VO8j6z0W87KosDZRPX1De1ULfbZXBsNCOaqaG4TuPJKqmjhihxjQc16qhdZ7b/855f02oZ9IfskrVEgkF3++MdiW49bfN2Rpa1bFDSlaKpLbIMoBnFsaI+UYNZpJIVbbRn8EOsWTh9KM5a+a836vPH7x1j3DcKYLYtcFfxUYe2qCQOod0YSLV6RExrYGNyZVv/sFCouh6dzywiSJiHelR3MMJHQ3LaEvnn/D0ceCggmxohVE7iP32KwT9ILHJtEdbT/2wNEc6cMpXtWNxTphJiNFTp90hPFWI5sb5tQj9c37CoOKdyJ3xnRO5VG98+g604bJAooH6wI9zVXM9Z1uxhZ9BNj6uZ9JbRxTzGde1wvS8Fj/B0QQr4qrstz8P7W/TSiV5qwstJF/YtGZzbpWjAMwzAMwzAM893DIjrTIsCyYf60bJH5OTIzjf7yzjfGieXCFeto6vAeQjB6+qNcunhMJv39g+1isnnuw+/R9BE9j9gxMG0fk/c1RJVFM7KFr/TtUxv8d3Xh4ooJ/SlAASH0hgR+Gr97x8xsWvDCupDtmgROtXilKSs8EvA9ZGabBF4AMXlHQTll9UgJEdHVgqfYDykQ2baDY7p0XL9mF011gQRLiGF9MsJFeb+FW0Mz+BsyZxNio2hnQblVQAeu95Bhvvza8SKTNDTg15lmjQ9dtSB9kWefPoj+8s7WsPOJ8zi/0WLHFSBxtRXOMmfa+niLcREBr7vOGUYHq2qopKJGtOUvdhSECNYmUV2CLO+M5FhaND1beK+XVlZTp+T4hjF4y4Fg4K2+vj4kqIbfvnbiIBE4VMHYgkD/nTOHUVpirCjODBEdQb2lF48KrpKTK07wWVcAAM87n2wroDOyujkKHh+gGyYNFhnpSXExwnddivZPXz2WfvXyxrDvNsW6hmEYhmEYhmGYwweL6EyLWTb8Z/N+uuOcbKqoqfMs+vX4u9vEZ7/NL6ehPVPFMukT+6ZzcTymyUCUvPVfa8IyxiGGQByHiLtxdzHdec4wKq2qpfyyKqqprRcCytqdRfTRN/nhgZ+vDtDiFeuEuLnUIHDK4p0ohpeaGEfzl0OEP+A7o9tLdJe1BqzHXF4d9Eo3FTyVXtuRFPvTt9ESIi7GBxQPBbo3cSSFW/UMfpw/jB0uULTYlrUKa6mX1u2mE/pliAKHe4oPbevJD7cbBfhxAzpZ9xe/gfZQW1fvzOK3iY9oKwO7dnAeD8O0BlAL4NZ/fRkWTBLBr+fWCHsl2U8mDelK86YOpWd/Ok6IyVgVhOAXVgkh6KTavaHPYYy94I/vHxo/UxNo9lOfB8dWdWUIiv/i++jnELcn//5tY79FX0MAFRnti7RgKcYkiOdC4P4wl24561i65tSBYnzVraewcqVHagLdcMZgZ4BOWttg5Y20dpEEAiyYMwzDMAzDMExbhEV0pkWAyHVcnzR6b8sB6uqRhQnBDpNhiO0fbs+nz3MLqFdaIhfHY5oFBFCT5YoavIGoAyEFgjraHbILIdxAJP/fV79yCrkQN9X2qQqhyE7G9ryyqf0KqRBg8X5ltVv8hsBjE8ghRPXvnCy2GWmxP3UbLYG0K0ExVN3nuDmFW7Hdvp2S7H7pgzsLYW3h9GwRDFHbB8Sw+dOz6ZsDpeIzr23cSz1TE2l471SqqKqlBdOyqaY2J2ivguzX+dOGUmpSLD18yagw4U9SWF4dvOYY41Sri4ykOKonom0HSoVtA86F3EZLZ/8zzHcFxia0YdcqGdnPAVbKVNXUBdv2t/ll9Ji2+kQK2cs+3E45u4rEmIoA24bdxeL5QA+CyZUh+O+lG04RFi15JZVOYRs2X0v+vT6kroEs7Im/4Z8eHSC67PGPxXiFQJq6jxhPYAdz/iPvi9+BOO41rk7QLGtwnBVV7jGPYRiGYRiGYZjWCYvoTIuAjNB5z6+lS5WJs5dgh+XUyOr8waheQlxi4YhpTvv7tqDc+Rkp1qqCOoCQ4oUu5Iqsd0UA95tNje/llVaJTERkUNuEVPgMY/sj+6RZ/diln7ApEx0gW16K129t3h+WAa5vx7aNlgKBAWSd4vhh04BsbVlU1IXXPvRKT6J7zxshvIl1Gx9kqU598B3xG6JY6+QsKqmEoB1LReVVdPGfPxDXRrVsOO/h98SqGHxe2qvATiKlcaWB6h2vZrBK8Q7jGwrCYqXDvOWH/OyxDxDdHn5zizULtiWz/xnmu0COfV7e3XpwTLZtYPIRx9+wfbr17CG0v6RCWMLJMRVBKxcIhEHwvm3yEOfnILRLAd1YsHlwZ7pr5jCREKAWFwU9UhMpZ2chffBNnhgXqlCIOj3JWUQVmeg3n5UlAmk4BpnV3jGRH70ZhmEYhmEYpi3CT/JMC2YB59FFY/rS+t3FvgQ7TGTLquopOS6GRSOmWUhxxm+2tSqoz586VBSri0TIxe+pwomfbGpkb8JW5sLRmfS3d79xCqkQXbD9T7cXCP/cKTu7ixUe+B1kQO8pKheizt8/2Gb8PbXgKcTrKcO608kDOgnPbj3z3eQhrG/juyxkCFEOv6UW1Ix0H1DoU7XbgQfxJ9vz6Yq/NRwXAgl65ivEr3/85GTamV9OifHRwo5KiuGy4CrEMqxAwD6qdhISuT2IbRDj5PiGvxcoAnrwM29usfogy220VPY/w3wXyLFPr6PgZ3WLbNsm0VlmsP+itjaspoqflTT4/JffFjpF7YLSamcdBnwPgS+MF8i0x6oSgD4dExVFGR3i6YUvd9EDr30VEhjD8hJ9lcuCGdliHK+pq6Oy6trgypVNu4vpopP6WIOjDMMwDMMwDMO0XlhEZ5oNBKadheXBySwKhj466ySKCmyyFufCEmd8NjYm1nOCzDBewFMcQoffbGu1zVVU1wZtT/wKufg9Fa82DA9gmVluEm9E4TsKCNH2+qc+F/YfkvzSKlq9drdW+LITzT59sMjovmPl+rD91a2RpHht8nWHaIzMa/XYTdv4rpDZ8sjAV/cBYtjCGdkic11+zo+vPK4lgnq3PZ8j3octhHrOpY3DqMx0Ubi1S0q8sFiZnN2Nzhrand7YtJf++NbWkKxwPWiiIlc2qOOb8NDXVia4VivIbYBEj8x817EP7MJ+6kzLYarZgPoPIJLxVoIxRx87dapr68O26fe37ly1gVZeP0EEC3WrGPRN+KH7WTkE25d+nZNDxqTnrx1Hv/73prB9+GhbPs2dkkVzYDFT2bCyBmP2jvyysGAAhHMUqe4QH0N3njtMrN7Tx3WGYRiGYRiGYVovLKIzzUYtYAgvUwhIv399M53QN53mTh5Cu4saBHZZnAvF/GD7cu9LG2jOlCFCNHQVX2QYL9D+YIeCbG5gElDQ9kwCj2p7ogu5qpisCkoQOiHOSj9sl8iDbcRFRwWzN61FKbccoGtOGyiOIbVxuT/E3j+/vTU8YxLWB4EG0R0WKbowbhOcTZngqUkUtC3xs43vAqwDmDy8hxgXIELB6uX9rXk0/cF3xPm1FWi1+covmJ7duNKlNkQws9k4yDaCAODcKUNE1n5pZS3V1TeIbl7CX8eEGLr17Cwhyi+9uMG2QcdPcVfsx2e5hdQ9JcHz/JuOfdu9U53fYRi/2PrWHecMa/APt4y3CJBfqoy3ka4qMdk7+R3bAbzXUcQUdnHJ8dGUEBNNK9fuCtqz4Dt+Vg5hBQrGxd3F5RQViBJjkvrb6lii1tPA8d997nCjZQ3GeGS6Y/+Wvv6VOE+3wGKqopZSEmIoLpYTChiGYRiGYRimNcMiOtNsIDDFxUSJLCtoTtLz942N++n4PulB3+ahPVLEpFSK6RC4bvz+sWIiCc9mWE6wrQvTFCDOIJtaCiVXTBgQFGM/3pZP6xqDO6BbSgK9tmGveB/fUW1PbGKySVCaoFiw2EQeKcLvO1gh/oaProui8mpRWO++80eK7/rxWtcLnjYFk7h+uEBw4pYmFGjVfenVzy5+cV3QHkUVzGw2DvJvFJyF5Q7+j++e0nj9ZJDQlT17wR/fFe0Fn89IjqOnrhorxPW9xRViP71WK6QmxgYFQbRL1/WwHTvDtASuvoX+gQK7qA2g+oajn6UnxVKf9CTR/2SNAFmQd1RmGm09UCqysO85bzgtWbk+rAgoxlQT+Jz8LQjQ8ECX/uLyWUKK2netWh+a3Y1ioBMHidUlcpxOjPVXhwF9sKCsmm5fvpYuGdM35DO2sQSWNDsKyo0BVYDXkam+KmeP+E8FAv+TV4517hvDMAzDMAzDMEcOFtGZZgOBacv+Epo/fSjtP1gZ9AsF0ZpuhOxZlbyyKuHHjMkjsj9ZRGeagppJrmYdL56RTecc11P4U6vZgmhvj116EvXLSBLiz8bdxcJCJSUxhtKT4oQw7SUoQSwBUqyFmAOxaMG0ocIOQBXhpVjUpUO88zggDGG7xeXV9LMzBosggIv24J+tWqX4LdAqvwff4hWzx1NMdBQdLG+wnKiuraPrnvyMrjl1oNiWFK/RHs4c2k38BgQx6VEsVxOoBWeltcrbSqFXm90PLBgglj/yPydQv05JYptYXSOv+YRGYey1DXusqxUQgIStkBQEEUzxe84YpqVxtS/0gdunDgn2B9lfZcCwR2MBYVdBXgjbGH9x75f9BH0DRThRngJ9ShXCAT735Y5C+n9j+9I9qzeE9UWXzzn8muZPHUJzn88R/Rm/bfNOVzPmEQCDgK7aLUlOzExv+N3GAII6nnj1X6xMwriFcQqCu8QmvDMMwzAMwzAM0zpgEZ1pNphwHiiJEZNfTA6lYPWTUwdQr7RE+jK3IEQYg2C07KqxdOXfPhaZa8ECjy/kCM9mFtKZpmDKJO+QEEO3P7eWRmamixUPqtjx6NtbaeG0oTTnX6HL7uVy/MxOyZ6CEgRvZEZOyurqtEHB68LWJSbKl7cvMjavffKzhqJ1ERQ8bYuoVil+bBYkFdXV9MQVo4U9gn798PrB8irxb5zTSVld6MIxfen+lzeGeRAvv248vZSzW2Sqyt9X9wNiXWlljdW3/drTBtGFf/ogRAyUKxTwGtrInSvX062Tj6UT+2ZQVCAQViti1vh+IcK7ydLCds4YpqXxal8IErosoOTKFltBXrT/+OgAvTB7vNhWRXWdKO785qZ99PcPtgsRngz9BH2tsrqW7v/BCHpj837q2jE+OKZnoOaDwyrrhkmD6amrxlDXjgl0z+r1NGtcP2HXZFo5JI8DhUHl+6plF/onggVfvLNVe7bpREsvPl7Ut/A6v399/RsxTv34Lx+FCOkMwzAMwzAMw7ReWERnmg0mnL3Sk2jus2vosgkDxGQamV51dQ1iIF6DiCkzPjGhrad6+r/LR4fYW7ytZZoyTHNtSbbsO0gXjsm0emB/Wxi+7B6i523Pr6XfXHCcsH7xEpSQQXxcY1aia78gwm7ec1D8LkQWVVjSvX1l9rSX17ofj+HWjmqVolueyCKgyB4XYllctBDmcD5TEuJojsF3GNcPma/3nDtcnHNkqP/whN7impq85WE9MXV4DyF8xzSulEmKbfC8l78L4a5TclyIcIhisZ9sy6cr/nYomxa8q61QaPidA/TT8oHUJyNJBAp3F1fQzkbhTLWkALjeXiK6l70MwzQHr/Yl60h43attAUi0bwS17lixLiSohbaPPhtNAZo8rLuoIYH+J61b0NdgC3PveSNo9RoUWz60ba+A476DlbR+d7EI6uM339uaH2JFk4bCvF07iDEfYJypra+nhy8ZJUT6Nd8W0pUTBoix+4R+6XTnynXB1UiShmMJ0OUT+lkz3WWwVI5Tj112Ep2z9N0waxuGYRiGYRiGYVofLKIzLUJJZY2YQJ7YP4OeuHw03bV6Q1gBMD07E16j+mS9PdhTMK2Hmrp6pwf2TWcea/yeaJ+lVUJQ8SMo+SFZZC8m0Mvr9tC8aUNEAAnFK2OiAvTOlgPBvqFmpHt5rbeHgJPM0keGt57taSoCKouMljRasNiuH94f0iOFiuKraE9xhdOjGEIafgeBjNOzulBacpzwZjf9rrT6+WrvQWEPYdvmnMlDxL9l8LCwvJoeeX6tEOKTYqLF8S19c0vYODl74mDPTFb1nDFMS+NqX5EE72wBSK/aBLDh+n9//cjat2GXome3e9E7PbEhiNXYp9En9cz11288lbqlmIuqom9OzOpK86cPEQkCqm2dCvbrprOOpflTh9LileuchVBxLDW19cFnIxRdZxiGYRiGYRim9cIiOtMiFJfXCFFoRK9U4Vdqmxyr2ZkQlWBv0d7sKZjWAwrdusTTOZMD1sxnCDXwSoffdXMFJYgyKMg3+/TB9NE3+WH+7BBWTCKLWlDv9ilDqKqmzmkbIzMokQEKAQse4Z2Tj1zR0Ej97NWgAYp7moQ2WWQUxQKtGeuxyGVtoLSqlnYWuu0S8B0IWtdOHEQ/n3QM/erljc7ipgcra6iwzB3w25FfJoR4KZAhmxbbwL4g4R2Z7MiAl5mweB8ezFjZUFheRZmU7OucsZDOtDS29hVp8M4WgHTVPkC/q6x22zqhfoUs4ts1JZ5KKmqFtQus4kziOsbVf6/fK4qbu8gvq6JEg4Au9wt2UFh1NGFgZ+d2ME7PXvYZnXN8L7pt8hDanl8WUggVyJUuqH+BWhmPX3aSCKoyDMMwDMMwDNN6YRGdaRFSE2OEWBQXEx1WEEyiF+fCpHJ/SWXw71PaiT0F03qAl7ULrIaQ2DKfz8jqQktmDhNL75siKMnCpCP7pNH9r4SLs/g7MSaaXrrhFFGYF33iD5ecQDV1daIQL0RViMLJcTE0tKddWAWmDEqZQQ3P+LbgZ49ihHfPHE7l1eGZohJch7lThjivG8YTWLosenEdXTQ60/n70kYGQRfsgy3wgt+FFcuSlevDCg3qYn5yXAxdMWEA7Skqp0XThwZXF2zLKxN+98h4h2CP35PsKqqgO1dtoBdnT4jonElfaoZpKUztyxW8iySj3av2gZe1CQpAo1jvHUqmN/qesHQJNFjDyb6IguXRgYAYTzp1iBOv27YPQbu6ps5ZAwNBzqR4t91SYlw0LTlnGKUmxVJUVIA6xMcEi0Tj9zEem8YrfIdhGIZhGIZhmNYLi+hMs9ldWE4JMdH0+Lvf0P+M7ef8rJw8S8sKiE3ybzWzlGFagtREt7AYi2q4HhYDr2/cT0Tr6J7zhosCeJEKStIXGP6+yLT+xfcH08Rju4r3IOagGG9sdICWvLiOXtu4P0QU1i1cXGK4FOt1AUjNoG7tGenq/iGL20VibJQoHIrMUNN1w3mY+/xaEbzAWOPlUQwykuOopMIdeMkrqaJNew6Kfz955RixYgFBjrU7C2l4r1T6yzvh/vsQx+575f0Qwf6NjfupuqaeLh3fj27655dBYS8Suww/vtQM01Sa275sGe1e4zJEcvRt3XMc4HWsYFu0ItQqBf3nir99QvOnDqH504ZQVCCKFq/ICSv8CaEdnwPq6pW0pFhR5LTIw1IOK0ggkrsKROO2UlNfT7/+96YwOxfUizGtdMHYhOLq/3fFGOfvMwzDMAzDMAxz5GARnWkWEO7g53xMt470WW4h3TYlyfl5CEiYyM4a35+e/iiXzj2uFz1z9Vgxgd1TVEH5pVxYlGk5xBJ/i3iK13unJQbFGpfFAIT0m86qER7bkSJ9geHP/tDFKFIXFSaiYB8uHd8/WOzOZWNiE8OLyqrp5rOOFf9BUIqNjqK3v9pPf/rvVvHdtla018uLfmd+uVghsKuwwnrdZPDi+qc+pxWzJwhRTS9kKO1z0B4goiOo4QJWLHoWLLj73GH013fMPs8LX1hHf710tBDac3YVHdo/FBw9bSAtu2osXfm3j4XdRHvxumcYW0Z7fGMAzCSSI4jUPSWB7jp3ON3+/NqQz+A7d84cLlYYmQRsjHuoU/DGL0+lhS+E9nUg/g4EhHUK6riYAl5zJmc5jwe//en2fLp+4mDxty6S4/UDByutnu8HK2ro89zCkMLFCMJ9llsggqwMwzAMwzAMw7ReWERnmkVeaRWN7J1GOwrKhPhHVG/N0IJf6YDOyTR2YCd6+sNcuuKUATR96TvBDEyI60tmDj8CR8G0R/Y3+kvfMSObFrywLsQrF4LpnTOHUUlVDd1wxjE0f1qMEJ3/9OMTKCYqKihoqMv+m1r0VorBPVITKGdnEa1auzusf0AoqlcyI102JiYxHKtBdhWV04NaoUr0uaUXH0+zl33e5or2uoobYox5f1s+vfD8TvrNBccZvy/tHCDIPfI/DfY4l03oT7dOHiK8x4H0KEZBvzvOyRaFZBNiqpy/i2zVO94MFdABvmuzskLbu/RgBb20dg9dNqFfiKUEakM8/J8t9PxPx1FcbLTIhEcWvh8/exwHCuDCIxrZu1ndIw/yMIwf9LaWnhQn2rwXskZDUXkVJcHWpL6eamvqhEg+b3lOSIAT4/LCGdniuaJTcoPnOeoPYHDE+Ii+UVFTK+pU/O2y0VRaVRMiQMs+hT5q7YtfHaBffv9Y+us7XxlF7rXfFjm91TFmYOVQIFBvrGmAIFtGh7hgcWS9VgOsXRBMffSdrWECvqwHwTAMwzAMwzBM64RFdKZZILt2ycp1IosWE8UdBeXBIol6htas8f3ortUbaN7UodQjJYGu+NvHISIlJr3zlq8VopifyTnD2NiRV0olWJpfhszHGLr57GPpytIBQkjtlZ4ozK8Xv7hOWGroWckoCAdRVRaElG20qZ7TUgxGsTm0a1ehUynIuNDFcIhU/9m8n1au2RVuESCEoHoh5LQ1z2ybFQSEtlnj+gWvjSk4YPNJRyYrzgWywYf1TBWZ38iS3VdcITzM5e8iwHL788hkPRDWPuCvbLqGXtcN72N7dY3XQ+4XxDes4sH7t2m/6bLwyc0rFXY16r5su3eqcx8YpimY2hr60t3nDqfMTvY6DQjuYWzC/R7+4NW19XSwvEp4k3+5rZBO7JcuVoqg7cPiBWP1j/74vujXsD159L9f04Vj+oZldcuVO9IGSQrQckzw8lSHEG8T2VGTYOX1E4S1yruWVSsYMy57/BPRj9VnFVnT4OmrxzprNVx72kCRja4if2vSkG7OfWcYhmEYhmEY5sjBIjrTLOrq6sVkdGRmuhDRY6ICwjoBk0x4nENkT0+KpZraeiour6GsHilCdL9h0jHG7SEjF9luLKIzTQGCMjJ7bzMIPvOnZdMlj35AQ7p3pMnDe4QI6EB+XhU45b/xfS8fXy8xeOOeYl9Cq/TMtqGL4cjyhG2NTZxH//zpaYPaZNFekxUExpjJv387KJQhM1Rf/WKzxJHWEPBRl77IUgzEef96X4nImK2uraO5U7LohqpaMYZBEAtQgN7YtNea7e113eT7aoFlmdmK/UVQ522fFj7IeNVFTYb5LrC1NfQljLO2oDfG4u35ZfTq+j108Zi+Rn9wiNJ4XpB9Ga9d2FgE+ME3vqLjLfUO1JU7GJ/VsfuL3ALhW+4C/dkG9uVASaX4bfTTqto66puRJMaB3UUVtPTiUeKZBthWDGEbtjEImfB19aGBNAn3Z4ZhGIZhGIZp3bhn/YeJhx56iPr160cJCQk0ZswY+uijj5yf/+c//0lZWVni88OHD6fVq1cftn1lDrGrsFwsuwZYSt0jNbGhWGhmmsjWxETyj299TdMffJfOffg9mvXXj4RNwUVj+gpf0Qb7l3CwXJxhmtIeIXLMswg+CN7AHgBCpS1Ig+/JYrfy3xBZYT1gK+jpB3y3T3qSL6FVisImTEUn4bnuJc7Dg7it+mxjvwd27SCEb/wf9RNO7JsefB9jD8Q49ZzhutkEKbQF2DA8ddVYevH68XTlhAFUV09CxIY9RGJcDEUFApQYG02/e20zXfinD2jG0neF9dRH3+RT/07JRhHOdd3U4qUA10uKiNh/7K8tM1Za+Kgg0MiCG3M4cLU1GfQ2UVxeTbV19XT96YPpbxZ/cIjM6nOAHHNl/3X1Y3Wsln+PG9AwVm/eW+zsi14gWAeBGwI/bL7uWb1BjAE/+b9P6fLHP6bfvrpZ1DF4/NKT6OFLRomseXicy3EBgb6TB3Tyve8MwzAMwzAMw7QNjriI/swzz9CNN95ICxcupM8++4xGjhxJZ511Fu3bt8/4+ffee48uuugiuuKKK+jzzz+nmTNniv9ycnIO+74fzSDL7NZn1wTFOwjmb27aSxt3FwthCJ6gtsJaeB3eoLZJZEoCL5BgIm+PC17IIQo0Fo+zCD5dU+LFv12is/oe/MzvO38k9XVYFvgF2eL7DlZaRZwJjUKrFIXxty6gm4pOYh+9xPm0xLYpoLsy+3E+5NgDi4VpI3rSqp9NEKJWcqM1i41vDpTSRX/+QAT4PsktoN+/tomuP2OwKPg6+Xdv01tfHaB5hsKE7zYGY+ZPHRK2TVy32RMHidoOKqpYLumTkSgyXVW7IBe6ZQ0HGpnDhVdbM72PgCay1C959ENRLPztCMRkjL9yDPazckclNiZKjNWj+2XQ4unZwjrF1Bff3LTPOg7DDx3Z9+jHMps8rEDpVwfo169sFGPHtU9+JoR1JAjAvmXSkK60dX+JSCSIZN8ZhmEYhmEYhmn9HHG18re//S1dddVVdNlll4m/H3nkEVq1ahU99thjNGfOnLDP/+53v6Ozzz6bbr75ZvH3kiVL6NVXX6WlS5eK7zKHB2RGYiI5sk9asAjXQ29+Tauun0BLVq2nX555rDMLa87kgHESCeEwPbn9CH7M4WuPsAraWVDu/FxJRYNg6RKd1fc6JMQ0KwNdF39PO6YL9e/cIMiHFAAd3JluPutYyi+poqE/TKGYQECIPZdPGCCKo/btlES90xKN2eTITP9oW761oK8pe72tY7J5wTHib4haf5l1ovP76jWGiHfm0G6iyKE8f67irhDUbp82NOx8YwVORXUdndAvQ9hVFZVXhxQvlWI5xrhX1u0Nbh/bkcEdvxY+HGhkDhdebU1/XwbYpfAcqRCu9k2/FkmSjo02Lj3Tk8R+3D1zmKjTAosvucoHfREgexzffttQuwVe68uuHCtsXWzjAIKysv4LwFgA2RzWUM9/sZOG9kyNaN+BHjhlGIZhGIZhGKZ1cURn4lVVVfTpp5/S3Llzg69FRUXRpEmT6P333zd+B68jc10FmevLly83fr6yslL8JykqKhL/Ly4ubqGjODrZtb+A6irL6M+v59BfZp1EVeUl9P7WfNqbl0/jM5NoX17D+za+3ZdPMRQI+czJAzJo7qS+lEhVVFxsXiLOfDd07NiRAh6Zc0cSr36M9nhMejSVlhx0tjuqLqUxvRLom937jZ8bOyCD3t/4rXgP7TGqupxacqhIjiLqlVRPt56eSaUTelJZZR1FR5GwKPnhg69TeZVZcHrupydToEOAiosrwt7DVTuhezx1je9O1eWl9MHW/OB7Jw/sRPO+348CNRXG77ZlcNxdEvAfLBTqiGoqKK6uisb2ThTXcHSvhJBzYbrGAG2mY3Q1vb1uR/AzBYVFzna0c28+DekUSz8aeSzFxUQRHNM/3JZP1/z1bXEN/xAXJVYwLPtguxgXJeMGdhJj3J7CCvr1OYPFd9d8W0Sfbt5JY3ol0vtbw4Mg+E5cHa7fobYRU1sh2rG6bVBfX99q+zHfi9smtrYGMEbiffUSfrO/hN7KyQ3+XVNR6uxL6vuybwL030j6sb4v6AWpsURlcbX0+5c30Htf54V8t76ylM4Y2JF+OLKh6LPsi9c9/g6N7J1Gz3/0FZ3UL8O57/o48d91ZbT3e73pNyu/pIPFA6z7jnF5m3YPks8/rbkPm8D+gqJvt1JdjfeqGhsl+3aK/xfv2Ubx8fFHdDutaV9a23Za0760xu0c3LNd3NNa+zM1wzAMwzBNJ1Avn4CPALt27aJevXoJi5aTTz45+Pott9xCb731Fn344Ydh34mLi6O//e1vwtJF8vDDD9PixYtp7969YZ9ftGiReI9hGDuwT+rSpQu1VrgfM0zb7sfchxmmbfdhE/v376euXbse6d1gmFZFW+vHDMMwDMP4p92vCUeWu5q5XlhYSH379qXc3FxKTXUvt22tIMuhT58+tGPHDkpJSaG2CB9D6zoGBKdaM9yPWyd8DK2DttCPuQ+3TvgYWgdtoQ+bkPvbHs49H8ORpT0dQ1vrxwzDMAzDtBERvXPnzhQdHR2WQY6/u3fvbvwOXo/k81iWZ1qah0l7W31Ik2D/+RiOPO3hGFr7slPux60bPobWQWvux9yHWzd8DK2D1tyHXfvbHs49H0ProD0cQ1vrxwzDMAzD+Mddtek7BpH6E044gV5//fXga3V1deJv1d5FBa+rnwcoLGr7PMMwDMMwDMMwDMMwDMMwDMO0WTsXLO+eNWsWnXjiiTR69Gh64IEHqLS0lC677DLx/o9//GPhm37PPfeIv2+44QY69dRT6Te/+Q1NnTqVnn76afrkk0/oT3/60xE+EoZhGIZhGIZhGIZhGIZhGKa9ccRF9B/96EeiMNGCBQtoz549dNxxx9HLL79M3bp1E+/DLzUq6lDC/Lhx42jZsmU0b948uu2222jw4MG0fPlyGjZsmK/fw3LyhQsXNqv6+pGGj6F1wMdw5Gir+63Cx9A64GM4MrTFfdbhY2gd8DEcOdrqfqvwMbQO+BgYhmEYhmkLBOrr6+uP9E4wDMMwDMMwDMMwDMMwDMMwTGvkiHqiMwzDMAzDMAzDMAzDMAzDMExrhkV0hmEYhmEYhmEYhmEYhmEYhrHAIjrDMAzDMAzDMAzDMAzDMAzDWGARnWEYhmEYhmEYhmEYhmEYhmEssIjOMAzDMAzDMAzDMAzDMAzDMBZYRGcYhmEYhmEYhmEYhmEYhmEYCyyiMwzDMAzDMAzDMAzDMAzDMIwFFtEZhmEYhmEYhmEYhmEYhmEYxgKL6AzDMAzDMAzDMAzDMAzDMAxjgUV0hmEYhmEYhmEYhmEYhmEYhrHAIjrDMAzDMAzDMAzDMAzDMAzDWGARnWEYhmEYhmEYhmEYhmEYhmEssIjOMAzDMAzDMAzDMAzDMAzDMBZYRGcYhmEYhmEYhmEYhmEYhmEYCyyiMwzDMAzDMAzDMAzDMAzDMIwFFtEZhmEYhmEYhmEYhmEYhmEYxgKL6AzDMAzDMAzDMAzDMAzDMAxjgUV0hmEYhmEYhmEYhmEYhmEYhmmNIvp///tfmj59OvXs2ZMCgQAtX77c8zv/+c9/aNSoURQfH0+DBg2ixx9//LDsK8MwDMMwDMMwDMMwDMMwDHP0cURF9NLSUho5ciQ99NBDvj7/zTff0NSpU2nixIn0xRdf0M9//nO68sor6ZVXXvnO95VhGIZhGIZhGIZhGIZhGIY5+gjU19fXUysAmejPP/88zZw50/qZW2+9lVatWkU5OTnB1y688EIqLCykl19++TDtKcMwDMMwDMMwDMMwDMMwDHO0EENtiPfff58mTZoU8tpZZ50lMtJtVFZWiv8kiBlUVVVR586dhXDPMEzrh/sxw7RtuA8zTNuH+zHDMAzDMAxzNNOmRPQ9e/ZQt27dQl7D38XFxVReXk6JiYlh37nnnnto8eLFYa8XFRVRSkrKd7q/Rwt7iyuooLSKiitqKCUxhpJio6mksoZ2FVXQX9/9ht7dkhf87PhBneiy8f2pR2o8VVbX0xub9tFj73xDz/10HGX14OvBmOF+TPT1vhI647dvWd9//cZTaWDXDr63NX3pO/T7i4439tEl5wyjaQ++Q2VVtWHf/cusE+mKv31i3TbexzbvOnc4LVm5nl7bsC/sM98b3JkevOh4Sk2Ko5Yef9KT4qhbSgJ9FxSVVdGBEvxWNaUkxlLn5LiIjsH2fRzDTf/4gt5WroN6PY7PTKelb2xp0rVuLXAfblpfRpuZ/dTn9PZXB4LvJ8VF0+UT+tO4AZ0oITZKtCG/bbE548j2A6W0ZX8JVdbUUUJsNH2WWyDu33KccH0Xx1FQVk3zl68NaefymeBnT30utiPHj7vPHU6ZnZJb/BhseG1Tjnv6tk3jT0JMVNg1+y7GvqOlHzd1jDf1Hf06gOaM6ZG0x5Zqt029D7nOh3qfwX6Alu5jfvZbniOMcabnk1MGd6Zf/WAE9UwLn++1BLZr5PXc0xbvyQzDMAzDHAUielOYO3cu3XjjjcG/Ibj36dPniO5TewEPxHuKK+jbgnKRgSQn1KMy02j+9KG0r7iCLh/fny4Z0zdkwk30Dd105rF03h/eEw/ueFCG6M4wR6ofN1cc/S7Q96m2vl5MLE3CNjhYUe1729gmRDh9ggrw98IX1on3VeFWAgHNBd5/Z0sezXs+h0ZmphlF9P9+dUAcW3PPcW5eKc19fm3IMUwY1MkpwDWVXYXldOuza0IECAgx9/qc0Nu+f+fMYeI9k4AOcGwYR5t6rVsLfC8O7X86Uhg/vk8a5ZVWEe0vEeMQ/q0L6FJcUvun37Zo+m0/bQttdJ5BAMe+SAHc9d23Nu+nlWt2GccbIMcbOX7c9vxa+s0FxxnF0qYcg9cY77VNOe6p27aNP0tmDqMNu4tp9umDxPXUgw4tMfa15n7ckvfT5ozx2AeTYAw+2V7QENR5IafJY3qk7bGpfS+S+5Dr3LvOh3qfwX54+XxGeg/ye/8sLK8S/7c9n+D7c55d4wxENaf92a6R13NPW7wnMwzDMAxzFIjo3bt3p71794a8hr+R/WLKQgfx8fHiP6ZlEQ/E/1pDb285EDahXrxiHcVFRdGqtbvDMlzlhDsmumHZr3z/znOGHYGjYNoK32U/bq44erj2CRlYqmCl0zEh1vf2UxJihbhjEskB+vWl4/sZ34uPcdejlu+7ttESk05kJ+riCvAS4Joy6cb7EAEvHdePLhqdGSKIeU3o5ff16ymDCdjXX555rHP/9Al8JNe6tcD34tD+p+ISxhfOyA4JntnEJbQlvS0a23Wiu+2Y2law/XoI4K7vou/o+2wS8OT4gX6M7GP0Yf04MpLinAFFfT/8jPH6NdGR+yW37Rp/7lq5gR6ddRLd/8rGkOspn4FKK9uu4ObVj1vyftrcMd4lWqPN6qsibP3I6x7h1XZkm/H7uabcR7DP95w3nOY8t9Z67v0GivzcXyK5B3ntt3quk+IapqWu5xNXEL657U9eIzWoifOSmZEkgmLqypu2fk9mGIZhGKZpuNWQVsbJJ59Mr7/+eshrr776qnidOXwcmlCHPhBjooPJ/WOXnUQLXsgJmfjggRRLRRNjo+mR/zmBoiggHkjxOj5XWevO8mCY7wKvyR3eby37hL8ff/cbMbHTwSSxc4dDwhmWJH+eW0Bf7y8xHoP8bFPAChMI+iYgEn2+o9BX9lZzJ50Q2GyinBTg/IBJN5a4Ywn3uQ+/R2f85i26/qnPxevB3yqrFlm0WM597ZOf0eWPfyzOLwQxZDRiQu/ClQGIfZVBRRtq4EK91kzbBNcP11HiEsYXrWhYFSKBqGNr91JccrXruOgo+v6Qrsbv29qWVwYr9snru35WsOjjh7CFMxwHsocfu/Qk8fzgdQx+x3j9mqjI/VK3bRp/sD94rrnmtIGUV1JJV0wYEHzOkecK1zk1sX3235a+n7rOMSyAcvPKrPc4L9EabfZtH/3Izz3C1XbUNuP3czZc/RD7vD2vzHnu/QSK5H40d18j2W/1XAca+1tTMr9bov3huDA+4t6Oe7y858Pe7ovGe74+7vA9mWEYhmGOLo5oJnpJSQlt2XIo0+Cbb76hL774gjIyMigzM1MsG925cyc98cQT4v1rrrmGli5dSrfccgtdfvnl9MYbb9A//vEPWrVq1RE8iqMPrwl1VXVdyOTElmV3yqBOtPza8fRNXinV1dWLB9y2usSZaZv4mdwd7jbpJbheN3GQ+LfMkEpPiqU+6UliP/1mYeGzvdPdWVldU+LFZFZfTdI9NVF4piNQhnNk8jaWpFmyXlti0gl/3Oa87zdDDiBj0WVD4ZVV75UBCJFeP9cSVVjE5H7RjGzRRrYeKG011kPticNh7YTtoU+ijaGtOVeFfHWAfnrqwOD7fsQlr5UPyFjFdtT++71Gr2HTseJc6JmZoRZt5PyunxUsyJDXx49OyXHW44DdxPxpQ2nuc2udx+B3jNeviT6uPfNRbsi29fHF9pyjW96IZ6R2mjTQ0vdTv+fYlmkshWD1evpFjul+s6hNbUdvj34/19T7SGF5tfPcu84H2um+g5Uh+9GcfTXtt20MUVdmoDYt+hsSblyYgvCRtj+b1z7usbc8u8a4AgKoVndNOR8MwzAMw7RtjqiI/sknn9DEiRODf0ufxVmzZtHjjz9Ou3fvptzc3OD7/fv3F4L5L37xC/rd735HvXv3pkcffZTOOuusI7L/RyteD/L6xMfqbbgljxavXCcy1H/yf58ecQsN5uijJTxKD/c+xUZH0Ze5BSEiAjxi7zl3ON22PNTf1bU8vXtKgnVCjUzzQH1A1C6YMzkgRN6a2nox4b1u2Wf09FVjxPb2FlfSjoIy8R0IvarVDPYJS6D132ipSWdKQkyz3o8kQ87Lrzw5PkZk/9uEV68MQJxbCAdym+p1QMCiuLyKzju+l8gidi3XZ9qOtRO2hz6ENiY80B3ExzZkiKJNeonREJe82nVFdV3wtzHG4TsQ2Gx9EgK3SyDu2ymJeljOj2z7GB9sgaJTBnWmiurasPGjurbeehx4fcG0oaKgn+sYIhnj1WtSVN4QOIiOCoj/fv3DkVqfDh1fXDUm5Pvy3JW20xowLX0/9XuObfc4l2jtFUSWIq1fYVZtO6726Pdz5vPhz3LIBH4LhS9N50PeZxCQV/ejOfuq77cryHT+qN7Bv9OS4ui+lzfSxWP6inFBX/HqCsJH0v5cXvsYd1yr3OZNHUqTsro2+XwwDMMwDNO2OaIi+mmnnUb19fbyNRDSTd/5/PNDmUpM6/BzxeRmVGY6xUQFKC0plpZfN45waWOjAxQTFUVnZXcXGR+1dfX0aWP2mszKkl6otokQw3xXNNej9EjsEzK4dFEXE7sdBeURZWG5BIY7zhlGU37/tvhbzRxDH6cJRB0SGibb+C8hNkpkt8osLXUy2jsjyTkJjzTrV80cS02MoXvOHUZLVm0I7ueJmemUmhQrxGZYQWCpv2ubfibdpjuUmlGXHBcjxrJXN+wNjmu68OrKAMS5khm92CbGQ5xrZPFD9Gjw/E0W5wqWAn6DJExkROLbG8k2Xe1b9iHaV+LcTlpiXLAf1dXXC9HL1NeluPSVx/akoOb3eJAxuuzD7SLgLdunzCJ96sPttGTmcOt3ZdtH+4aIZgoULZw+VNRQ0ccPr+AChO7BXTuIY2mpMT54TbRr2LDyoyp4DdOT48R+ynFPX01g8lQGOA9oC62xmHVzsflJy7aC44wEnOMzsrrQkJ6pwbEW9yC0Q92bWr/HqecXKxZwTygqr6Lk+IZ7ELCNyVjx0yGhITCKNgjrIDlG637YqjCrtx0bfj+n47qPoB+pVkj6daiuqw/eDyMKoCn7inOK87H3YKUYh8oqa8R7Xm0X28c1sAWZsKpNjq+43y2Ynk13vLiOZo3vR3UUKmjrQXj1Oica7J1U/NQzwLPML75/jHM7CPgdh2chhmEYhmGOStpUYVGmdaA+yLuyS66cMEC8v/SNjSGin768WV2efqQsNJijE9ek9LvwufQjnHhNlN/fmhfRUm5XFqAt0wyMH9iJfjQ6M6xvQzi68MQ+wb8zOyWLAm/BZdEJMUL8kAXfbIJBpFm/pswxnI/HLztJCOZ//2A7HdcnjX79701hk27bNpsSRPFj26ALr7aARYOAmE13r14vxkK5Pbx+3w9GhBTNa43WQ+0Jr/P7bWE57S6uCC759yKS9u1nHFL70a8cNgugysPyJdLg4MHKapEZamrzWEGB94nMmb1q20ffuPp7A2jO5CzaV1wp3ofwN2Ppu3RC33RaMXsC1dbViWxUnGNkhHqJ6PCmdq0UaM4Yb7uGEPgra2tp0YxhtPjFdWGe764xAuMVBF09INYeVpRIP2k/9w0/90IpqELYdFnkBLfZeA/02/dMYzL2H4LvTf/8MuT7tt88nIF2V+AbbRJt0a/1jSvwZALnFGL3hY3X1u89Vu73qMy0EOslFRzLrqIKqkDAJSaKlqxcLwInMYHQ1XCxUQEa0EUGlsOvM7zy1cCWilc9Awm+e/tU99SYi4gyDMMwzNFNoN6VCt4OKS4uptTUVCoqKqKUlJQjvTttFjy84kF+RJ80UXzH9EB697nD6KW1u41WCJiQIJsID/d/mXWiKN4jee6n42hUX87yYA5PP95dWE7/2byfunaMD2bNIVNp4jFdqHsLChp+J/YQF/YUV9C3BeUUCASCGXAn9k0XgsKMpe+EZcMBvR/pwPYgkonzzoIyoy+o3O/mZD7bsqpt28b1uPEfXxj3Bdnoq9fuppGZ6daxyLa/2A+IcDaBTXqiq5/BRN32O+q4ZjrnUjhCwAIWMChK+pt/bxLChMzaxJJ8eNNOGdY9ZH8/2ZZP5z/yvvWcLr92XJvKjmtt92JcUxQNtPHwJaNEgTmZJY3gUVPaN0S6O88dTiUVNSECIvr0rRZh3GSVorYlNZsU2bPPf7HT2kYRoFkaYd/duLuYlqxab23z86cOpawe7mso9xcZrMgyfdtHP3X1T7WveY1H8nlFP7cIVCF71STmuq4h2gD6mlw9cvKATmLlyNQH3/EcI2C7hfHKZlPxxBVjqC2h92M/943SxrbudS/EuP/Lf3xhFEX1sRYsu3KMyPhf9OI6em3DPuvv6ysNCsuqqbSqRuxXF2RNL0f7dLc52/YOB7a+r7ZzVxuMdL9lXxjpeN732qaf8RWrXe6cOZzOf+Q9a7HuN355qqiVgHtkbn5ZyDMSQOAABdjVNqOPox99k08X/NF+L335hlPo7tUbnM8FHLBmGIZhmKMXzkRnmoTMYEX2iF4QTS4hHd47lW57Pifsu3gfE5GzsrsJ4QiZfXjgl0tl8T7DHC4QRVy9JlTUwETp1GO6RLwtW3adbhWhLrPesLtYeORCxEf7v0UTFyB6rf7ZKcKvFOI6QH/Rl8rn7CqK2EPUBXyTbdlazc18jjSr2pU51jUlQQhyl44/5Dnsd3/9FnrzWwRStacyZf+r2cRb95fQzsJy8Tu4jhAD1u8uDo6Do/tlBD8LMcmroCRnxzUPv37Dcsk/Vl/YMtJt7Rv9Hlm6N/3jixARWQqITbVZUMHYY7NOgQi4eEZ2cEzyaydSr21Ht+vA+16FweX+QuS31RjQ+6lXsU9kBWNfEMzfXVRhLbabHBctsouxWqdDXDQlxcUI2zmIpraM8PKqWmeBZ/y+XD2C/5A0IG12XGMECjabxmh5/G0dr/sGxM87Vq73ZZuEcd8koJvGWhSqR5/BucWzpy6i29oJruG8Fw7VEkEw2nZ91N88EgUl9T7bv3Oy1cO8subQyqbm3r/leHbpuH5N3qaf8VX4jS9fK86rKSEA1xBjjd5n1VUC+A9jE3zLYbtiGkexWs5VKBnFTVuqqCrDMAzDMO0PFtGZJoMHyc2a96q6hHSoITPNywoBmSgo4sUwh2MyCo9UTKBGZqYJr36Z4d0UH2RXpjkmc6qAbltmfe3EQfTp9oLwAnqNnqEIOGGSv/TNBuFG7T8/O30wTTy2K9W97PYQ9YvLLxzHgIxSVzFNFyWV1WGBgLU7C0UdheG9Uhu8kBU/c71YsYoUl71EZltRO7/F0+ZOGUKzy6uF2O1C3Q+XsF3fmJ1nsylQ9xdiEmx8rIUZvwProaMNl+0HzrvqNwyxB9fEJqLb+o6fwoiR2izoZCQ1eB5X1dbRjd8/lm49OyCEQ9QrwTEEmmClVFZ1qP/Zxi+0wUUzssX2OznGgtr6ejGG6cKVHHvVdo/9hEUHxgr0Pzwb7C2soA+354s+AlyWFTgW27Hec97wsCK96rX4+aTBzvOsjzd3rtpAK6+fQPNfyBHv2US6mrr2vfjTq84ErqffAKpr3FevAfrnrPH96Ud/ep+Oz0yjhdOy6f/e3x5c4YNzDsEZKyC87rle9xGIwf+9+TRRbPdwiql++6wMVuHe0lJFXuU1beo91s/4unZnUfCZAPdNkw89+tMiBDwsxXthFYVrjW2g7XTqYPZrz0i2P0fhdTxnITjfEkVVGYZhGIZpf7CIzjQLLGG2iQRqlpDpfRX8jcn3LWdnsYjOHPbJqMnvNJJsLa+ihPOmDfUlpEFgwvt6tpfcF0ziHn5zi7H/RFGAxg7MCCn+N6BzMvVITWjSxM+WOSZFNN2SIRJP3/TEhqJ8sDQpqagVRUIzM3rQ4hXr6IHXvgrbZkpijGeGsPy/DUyCbdm3rkJv2/NKReaxPOeYZLuQ++HK/sd+QAwwXUeANqAK8BAEXNnF8FXnyX3z8JP1rOIS+Gx9x5Wh3BK+9hjb5i2HyBS+/7BFgSXU/xvbN8zv2StwiMKmXuMXtrdoxTq6bfIQ4R9/sKKGamvrqLKuXgTcKqpqKC0pnpZo44Y+9sbFRNE3+0soKioQ0u8Axoz507Lp6Y9yxWchurmCEvf/cKR1XN6eV+YUc2+bMsR5rvXxBvtzoKRSjL/9uyRbkwVmjOgpxlCTJVd7wCvj2GuloSrEImPYRZ+MRDEeIzgk2w/awn0vb6BHZ51E97+yUZx/tJMn3t/m657rdR/BveN3r2+mu84dftjGXK/nC7Rz3R6qJYumy215nRv0XVsxb9f4esWE/hSgAD36zlan9/24AZ2cq8CQfV5UVi2KwmL11rVPfiqSefTnEhyH9TkqEBB2V3Kf+b7KMAzDMIwOi+hMs4AFhVzCrIsEmNjomZMuEQHZfddV1lDfjKTDtPfM0YZtMqqKl2r79Jut5WVPUltXT09dNZY6JsRQPdX7tgNRySutFNmlNisECGeXju8XXAbdXO9OW+aYn2xa12/iGlTV1dODbzRMYiGqPNjoY/q2ZZvwoLYVDMNkGUv5TeONBMeREOuvmJ8qtCfHwbc8nz7PPZSF7PodmbHslf0v2ovDpuC60waFCPAQkyAiyKXqMkgCMQC/V1NX52mnwXijrkrIF4Vyq0MEOhUEdmxBGVvfaU4mp++xTbOikAG2p68eK9oLRCbXWAW7DVexY9c9HNutO7teFAhct/MAjenfif731Y30Us5eq0ezOvbi/dU5e8RvPGYYY9D/l6xcF7R78ApKYLWA7Vi9CjFjwYltzNFXJkggwH25o5DOHNrNmiyA/Ye1jKnIIs5xW8erkGtynP+ijShQbbsGsC57Zd1e4/XP6plKv3llY/D8R2LB5Wd8F8Unn19L950/8rAUgvV6vsCKsIsf/TC00Oh59nsmXofQHGmxc1jGwbYIK3D0lSRYAYC+K2sUmALqqg3kNwdKg/cvZKHDp9w1NqzZUegp4mObqFshj/HJK8fSJY9+IMbF2xEUC5DIMkfAwfoc9dUBYbN2oLQqotV1DMMwDMMcPbCIzjQLPGBC4Hrnq/1i+SO8RiWmzEkvEQGZLPzQyrQEpsmhazJqErCRKe3HssRrCbs6ufPKZLb1EWR22optqd+FKA2RZlRmWqP3a9Mmg7bMMVc2mJ9s2uLyalq4oiELW2a1YzLu8kn+tqBMeJ7r3swQNXqkJtJlE/rT3z/YLjJugW5ngzFq4Yp1ntm3flYpIAsWWY5RtClEsEQwEX7T4KoJ/d3nwKO9xMeGjoOqmKSfe+wfgMjQ1ooStkZk9mGH4oow7/IQESouxhmUMfUdfeVWS/jay3EOHsi2sU0E2A42BNi8xh8U68O4p1tEyOPxDARU1ogARJ+MJCqvrqWLT+orRHQvIfPa0wbRcX3SRD975idjrb7a6AO3Ts4S/9b3RbdQQQa8Wm9FxUuQgwBvGnNw7S81rExAP8Q4f++5w4UAZ9t/tCesTNKFZhl4ay/PhHOfD7XKkceHa+QS2dXgIcRabAsrElQxGEHT+dOH0syH3jXug97WvNqs+r5rxY+6IgX7A2uawyGim+4XaluHxZhqfyLumfnme2bDucsW91QE1GBjt2Tl+mD/sFnEoCAuVpgsfeOrsJUkGFPghX/dss88A+r4G0G2u1atD15TfP9/Xz20Ak0F+47Cxbinej3/YGUCCpRKcR8rEmTADcI4/o/++/NJxzi3sz2/jH76988iWl3HMAzDMMzRA4voTLNBlu3qtSjMmBcyQcdDOR6k8RA7Z3KWsG1AMS8X6rJxhmlp/9CfneHf5xai6CfbC0IyBm2TKr9FCf1g+qzMgMOE2UXfTom06mcTaMHydb722wuTXzh85JuTTVvSuORezWq/ZExf53fyy6qFBYXMwkZGfu/0RFr7bVFw4o73UDRwwbShwlsd4w98ayHKwGNdLzSnC//Aa5UCBAqcx9+/vplO6JdON0waLDxYk+OjhagK8RHBRC+82os+DtrEJFXYaa/2EEeKurp6um7iYKoLE6E6013nDqNFL7qDMqa+g+xPvwJipOMcxCMXXkKiikkAw/HANuLAwUrnd1EkWc0GvXPmMCH4ef0+bDVkO8azgsTkLR4bFUUrZ4+jmOho3/VW9D6C8VRdRaeC19/5Ok/0d/z2LyYdIwRTiJW4Rg+8tjlkWxAmrzt9MPXPSCK8ClsXFyha2l79ltEm0TdG9kkThShxzRA86tspiXo03n8iKdqY2SlZFPFFUAMWSliVg6Ai7kO2MU9va2gzfu+5csUPAtGwB1EzpvU21JyVI5Gg3y/8tHXXPRPBB3kcev+wCeA19Vg99lVYZnvDSheiE/plhJwbV0Ad9zPY4SCbH9vzGhtQU0ZuxzZ+YqxRVybIe2P31Hjxt/wN/N5NZ7qfx7p0iG9ybRyGYRiGYdo/LKIzzQJZcPOXrw1mpqhLYfGgj8mSuiwbWWHW5blcHI/5jv1Drzl1oG8/axQcu/zxj8O2YZpURVKUEEuXIbqYMlwh0MGeJPS1hqJp0soDn9EtG+Tv7CmqpMff3Wi0RcE5uWNGNiXFx1gLIro8wyXIzI8km1bfpio8yIxBm4WNel0wQVcFAymu/euak6mqps4pRCEj34XcJ69VClL0h73LxWP60v++tjksyw/iAISf5lgemMbBoJhUViVEuJjoABWUVosgphT4mVD8WBXYvnfLs2tEwUHdPgd2JzjnXkEZm9d+JAJiJOOcV6BOvu+yq8DYAhA8NAlgsEF4ad0eT7sLCe7z819YR9dNHCiyRF1U19QFRbgOCdHuIqaNgQwEyWQ/ctVbMVl1bdpdLLJrEZjSr8XCGdk0/cF3gmMOxilpkyXHHQT+ZJtA7QkUKwRYnQDx2AXGqvbot6y2Sb1/qPZifos5S3C/0u9ZCTFR1jEU7UKC64Vtu5470adVUDvgtGO6UFFFdTAg1FIrR5qCfr/w09b1eyaevbFay0//MAngCI6Zzh/A8way3nVsQQa0E2S/H5eZLoTuLh0bRGuv82xbHYdri3pKKKcEKyUcd2x0FG0/UEIDOyeLZwTU831x9ngYNVFSXJRzDMOK2JasVcEwDMMwTPuCRXSmWejevupSWBTY0h/01ff1jMo7zuHieEzzcVm2vLc1z5l9mJmRRK/feCrFRAVo8u/fNma6mSZVfosSYkI/sncajemfEZbhKj47oZ8Q2bGiQwo0mGBe+KcPxL6g/zx/7Ti6Y+V64xLtyupap9cnxGT0ybsNQq8te1/PYI9EADZtc9X1E4L/ltlhTmFvcGej/7AUCM49rhcN7ZlKLvwUWfOyWMG+StHfVtAQ5x6iHMRuW6DC1V68xFRss6Syhpb8O/T6y2xCJvL27DWGmCxIVggxxo4rQzVSAdHPPvr1clbvwfDv1m2LZo3vR09+uF28X1oZfgzoI37tLiT4jdunDqHPthf4Ft/3FVcKYQwim7mfHQj2M9mPvOxibj07i0Zlpgubh427i+n2qUNFjQrTtcDKFXXsVzNlVWFSCuoo3oyxNTEuWhwvsrBd9Rnaa7KAl3e3XPGjBrb6d06OOHiE75dUVtMd5wyj+S/khLVjXFcZqMb1wcoBmzWPKBCaEEOj+2WE9cf6QrsvPl5XxfrvOvCH+8J/Nu8XdYjwTODl8a6vtIjEF940hpV6rHQyZZPbggw4PgRZZKAF91O//UWOn3uKK2h3YQVldkoSVjLYX6xmea9xBQl4bNZJtADtQxunbjh9kCjGvfjFdcYxbHdRaCLD4VpxwDAMwzBM24BFdKZZ6MKTWvzurOxuYQ/t6vvwNW14+K2hvUXlngWnGMYPLjEUk6vl142nJS+uD/OzXnLOMLFEvENCrCji6bLH0CdVRY3ZwT+fNJhumzqEogMBMaFbuWZ3yBJwtPtH39lKm/YcFB6maPsQs8qqasSkd/aycFsOFCRdevGooN8pJo4IUJmWaP/mgpHOc4PPv2MQel3Z+3rmvV8B2LZNTH6lMCGzY23CHK4LskUx2TXhV5BqSua3DvZVCgVeBZJhPYBz68qEboqYiu0teqHBT15F/j1pSDfP4zgaiKQ9m/AKqHhZ55jEo7C20CGOBnbtQE0F44sMtsGuYu3OQrpiQn9PcVveg1+64RT6tqBc2JTodhXY5t0zhxuDUdKm7amrx9L+4kqKikJmZzT9e/1eq60QAhp3rtpg7ePXaat+cO1QFDCvpNKzn2X1SBHXc7PHChkcK7KK8XvwWP5/f/lQCLgYy0zXQR0v5DilWsvAxgnfv+PFdcF9lJY6rvEs0hUHbQkvq6/C8qowGySc5zuUe69rtYgeGJP1P+acnUW5BWUUF93QjtGWll05lhavXBccqz/Ymm8sylxeVSOC56bfxBit2o7o4ntLe2XbAn9oM9W1dbR6zS4hCPuxbtJXWkTiC28aw7zqOegrYVz3VX18dfUXrApBUAuo1+j+VzbRhaMzaaFBJMe2cnYW0YNvfmW9V54zsmfD6rLG9oAxtL6+Xjy7wXZL9Zg/XCsOGIZhGIZpG7BqyTQLU4anzNQa2iPF+B35/qmDu1D3lHh65D9baMH0bF9ewgzjhVfWcYCIpgzvTpeO73fIoqG4Qnifwl8b7XPZle4CjeqkCgW85j63JmQihwnknecOpw27ikJEJTWT+VcvbxQTOghh0irABAR2vC8nh198W0hf5BYEt6Mu0ZZeniqq8NNRmRwWljUIvX4zCHV/ZC8B2LZNKZAtWbkuJHtWBtfkpBaTdohb2MfF5wyjypo1wmZCHgvok54kipTl7S8RYqDNssOv8G8T2jGZh2CGQAnwEiTg3esnE9qvpQMsfiAYIuhy+YQBIqsSk/2y6tpgETW2c6GQtgcrFvQP1Utbnifb8nwpdHtZo2Clip45KfsZCu9CEPx6f0mwLTYnK960jwVl1bQEYqQmHo3olUYn9csQfQh9ATZH729t6FtAng+AtnzJox8afwPHhYCbDvr494d0pR+NzqSq6jq6+NEPxTZdxYZV8V3v49IKBdcGFhqy7+EaPPj6Zpo1zm3zhP6waW+xqCGQ4dGP5DXFNbhj5Tp66JJRYoWPKaiijxcYp07P6iIsnKS1DI77ife3hbQB+Ru2Yx3UpUPQF7y9sbuwnCqq3d7jldV1xsDW7cvXisAwzqutX5gCYzjPqP2B8XnK8B4hdUC+/LaQpo3oGbxX63Zgku8N7uLc576dkum+80eK+4u81yEDHfvXVLuoSAN/yECXAjrQxye9bkDfjCRaNCObeqUnBe/TKDyso34vOe7QswEEeF0ARwa8bRUfggroI+oYiH1EgV2gnxP9GU3vLziXsHfCykFpq6S2CxwPgmcuSxvUMXjgtfBipdhHtLUhPVOotKJW3EM37z0oVgj+RdseVjOsuG48HawIHc/l9Wqpa88wDMMwTNuCRXSmWSBjw7bc1auIKDJrdhVViEyiqrpa8VDKD6FMpOiTGbRJ22Rv3tQhIqvZ1F4hQklfUEzebO1azbDaWVBGtz63Jmwih4nvvOfX0l0zIf4eymIzZTL7tWFQM6jmT8sWIrSeEQ0vT3VbrgJkM4/r5Tvz1rSc2UsAtm0T1+qSRz+gZVeNperaWrEfuCa4XnIfZXbinqJyYV+CCSrEAIiHqMGgHguuE0RlmQVrE2Fswr/0ecf+opDcp7kFwq9VBj+k0A7xC2I22paXyJqSGEO3/guBlaZlQqvk5pXS3OfXhtkQ4JhROA77yXYuocDqwVV4z2RVogrdLnsBvP7OlgMiuxvI+h+m30PbgXWSVxFSv20B+/jW5v20cs0uq3gkbdSw0gT2Tn/ILRCv6/vnlc0KD2Qd7CfEOfjFz57YUKQZQYkfHN/LOl6qHsMmIfMfPzmZRvfPMPZN3VZBB0L/zoJyWpNbSCP6pImAJIp/ymCJWjxR92r/qQhINYz3pqCKOl6gvVxwQu+QfmhajaKO5fqxSk/w9sqCFevopGN6OW25cF/1shMx9Qvc49EWLhqdKfqdfn3Rt1BQGlZsavuBBQmCjy5QqNSFXGWG4padOsR/J4Exr0A2BGw1YKbXHrKNPXJfsL84DjVIbPse+jHGLFMgGpntc55bE2bFePNZWVRZXSOs1RatyLHuh2tlmOwveH2yFhDR2wXu1V72NNdPhHlPKPYaC52ExR5qnajgnC98cV1YgAeJGLe04LVnGIZhGKZtwSI60yww0TZ5TeLBGr6Nrok1JlRf5hbSjON60uBuHWh9cbFYVovsGYbxm/1256sbQiYzyJSEv/685aG2F2hzw3un0m3P53hO5J/+KJcenXUSBQKbjEur5aR0e16ZUTCQk76q2vqGYpClEPlrRCa4nskciccw3ocVQVx0QGw3N78s9HwUVYSIe64CZBCuf/3DkaJYoJco3JTlzK4VARAMduSXiQx7mb2GYnwQxZDxjcnsFMWTHuf9nvOGN/jfaseC8SVAAXryyjFCZIfAgiXeODaTEKC+ZhNCVv/sFCour6Lk+NAMe2TF4/pDyHSJrMgANhV/jbRQGUR7XUCXx4wxV4qAbOcSCjKT73tlk1Vo1q1K9CxQv31SZk7CUulOrU6BvNa4fvDINhUijaQtyH1EP7GNOXj92tMG0XF90sS9eUCXDmKcKKusEd7ApqzpSPs8LNiwnTmTs8Tf6KNfHyilm87KogBtCmn3No9hk4hpCsphlYnrGeL9xmeIycO701kPvB3yHq4frtPxmWlGr3ZkFsMj3eV5rO4TAm3q+TOtRrG1m6YUjm1rvP91Hq3dV2W15UDwBVnFNtTzqfYL0xitXl95j8CqBGSIC+k0cCgQAly+5umNBWFN2O4PLRkY8xPI1tuaV+0h077oqytszwY4T3h2Mh0D7s+yGKhqiXPRnz8Q2/syt8BY1Fw/J7hmKNwOSyq9nSB4jnu/Cdku8GzhFWBLig9fFWE7ZuxznaH4sC3AA5G/Ja89wzAMwzBtCxbRmWaBiahchjl38hDKL6ui9KRYiomKEssxIbBD4DJNrOUE6IZJgym/tFr4WGJSc+95I6h3BgvpjL/stw+/LQ957dUN++jM7O5iKbfufwpfXBf4LERdTDZ///pmIX5BtJL2In07JQWX42MyV1juncEtLUmAzAZTBSzT0v8BXZKFVzrE2Ef+5wSqrasXGdKYPFfV1IpCdrJIm+rdCZuJ65VtuQqQYRJ44GAlvbRuD8VGh9tTNLcQnsuHXM0MVTM2kQG87IPtxok4Aha2TD2ML7DnkbY3GF/go+rlL25bPg/B0TYZhjAzZVh3GjsggxYsXxexaBhJoTIEX1yCqVoMzva5oxGIPa7zpluV6Fmgep+EoIyVU9IaRQp3MjsRq6lcBX0xhjS3Lch9RDauCwhT2EdpSYWxBwKwvn8ymxUBK9UKAtYqCN6ofV5d7YOxC/20oKSKThnUWbR/aJYXNwppqk0WfgPC0hOXjw7xb5fj1ajMNKeIiX2HYHn78znOZwj8pn6NoyhAT1891urVjv2LiQ74DhLqIqcpCKG2GwQ7kb2cHB8jvLr3HawQ1hHt2fbBZmOD5IiARy0B/XyiX9jGaNm3VdET5/q8P7xnzAy+u9EbXPc1x+u2AtCu+0NLBcb8Bp31c+NVe8i2L+rqiooas72N6xjwvG/7jiszXN0eziuyuGG3pbeTfQcrqbDMXo8Gz2Z19Q0Z5l06xNGLsycIm5r9JZUUHxNtXIGi3gciLa4qiY2JEr+N7eJYZlnG86Zee4ZhGIZh2hYsojPNQnqdBq0pcgvEw6hcKg67AWSI6hNrdVKLAl14QMV/mORggrKUszkYn9lvUfHhAZeFK9bRitkTaOGK0OxLtEUXaJ9qttIbG/eHvC+X5KNtSkHJhS7OyGwwPZNZ7UNnZHWh6884hu5/pcEzXV1y/MJ14yk+OopmP/W5MTNv7c4ikXnp17Jhe36Z6LMoSAg/ZVMGJTLDtuWVUofSKk8BCBPkwrJqKq2qEUvpYY8Cb1pcDzWr/FqtkKDE5a3sFbCAWAVxr8Eb/BtaND3b+flIfeBVZGbfry8YSfmlVcJPXx3bvGwb/Gb2Y/WCCy9v9qMVWABFYlViygJV++Qf/98JFB0VEH1FFXhkhvHuIu/gnKvd+kHuo9eYg+A19lFtY6bjQz956OJRlBAbRUvf3BJqbzC4M516TBdKTWrMxtWsiTAWQby7/vSBVEf1ot2r444E93SI5/es3hDm347Xe6clWkVMSWanZJo/bQjtKCi3PkOYzi/296cVA43jiQzi4RhwrBDTVTs5WYMA/Q/WTOno71phRZsNF/ZpzY5CumpCfzEGtqTlR1vAZNnzys9Poa7J8b6CqhK0X9cYrYqeEMR1qxg1MxhtSF0RhtUPCN642p7rt/0GxiLxzXbZ0EFcRp9T+5A8z7LGgde+qPuDmg3VtfW+v+dH6Pe6F8ntqefV1DdfvuEU4/elFQsK+X6aWyj+/cDroYVD5XPQsg+305ub9tH1pw8WyQjy9yItripB/RF15YNrO36DogzDMAzDtF1YRGeaBbLV5IM/JuVLLz5eZIBhogvRAQ+cEJlchRPxcNxQMK8hq0hkyHI2B9MM0O7gt42lzphoI/MUlgsQz7z8x/1mVGFC+frGfU4PWFMGN8STM7K60kl90xu8wLXsuBsmHRMsOqqCz2ECaVpKLD8Lb2FkaCLrDwEpL8EN78vvoiChPF8QjGA985nBVsUmAMFaB6L8g2+ETmxPMdijYHtqIUG5bdf+4j29gJqa1YprC5FTTnaRve/Cywe+oKzKs04DRBiIjNc++VnI6y6f+0gy+738er2u79GKV3FhPYjh9Xm5wuMnpw6gJTOGiSxOCKRYnSICwB5CuC7AhviFR/u7hnIf/dRQ0NuYrQA4AlyfbMsPH2saBcj7fzjS6O0vxqyXN4nVGBgzTsxMp+kjetCdKzeEfHb+1CH08JtbwrLgRaZ4ICCC5SZ08RE+565nCFs/gBe7buUhs9ghtJ05tJvIKp38u7fFeHTfD0aIe4WpBgGylu8/fwRlJMeJsScxNlp8/4HXNocEW09pDKwAWyZze7R9GDewE32grQqT51vcR4Z1NxZ3NtmWyfa79UCp8zdxHXC+cQ11ux79fo2x2iSa24Rur/uDS0jFdiLxTMdn71q1nm4+61i65tSBIuNb3ttQ5BPB5W4pDUXD9WBU18bXvcY6fX8QxPLzPb+ryzAWem0P5xqZ4wjuq/duNTCJeYPpN9TkBgTLbTZ1ePa5a+ZwqqitpfTEODHG7C2uFOcUgQoXpnFE2kbh2ULOUVz33aZY3zEMwzAM07ZgEZ1pFmqxIUyUYN0Cf1I88CfFNhQd9Zr0Q6DAQ6qaUcPZHExzQftDRqAUxCF2QQRbKIpyrg8Re9TilPDSdiHbJiaUmOCqHuTq9tAvbCJJ15QEIfJOGdFT/C4m5H0yEumVdXvFhN5mRYEJND5vAt+5fcoQMTm97/yRDSJAPVmz2/SipRDPpVD13E/H0Z2rQr3mXQIQJsf/sRQ8fNtgj4IMV1MhQWlRYyJnV5GwroFIrxeLhCDwkSIGYrLrsg7wI5xi0g3h1Ctr1LSdlvJGRrakyxNazd6EtQbjLfaYghh+rYeye6aK1S2qkIXvLZk5zB5MG9RJBKT096V4iKxQomTfx2RrW/idWeP70zMf5Ya1MdvxDe+VSg+89pXx9/BZZO7avP3Rr284YzCd/8j74u9gbYPGVWf9OiUJW7e5lhoUtmC5SXxEPQQ/45gOxsJbzs4SRUTRn2UWOwT0i8f0pZraumB2KY53myEICND/YCkzZXiPEDEfv40x95dnHkO5+eUiIALrElh+CQudJq50aYvcPnUI3fv6dmsNgdH9MoS1mTruJ8ZBSA1dVaCOkSkJ7qKgAzpjlcJQmvnQu9bx3vUs6RK6ve4PtsAYvo/VJViF6ef+iXsn7o8Xjs4MC55jTL/rvOGUmhBDT32YSzefnUWXHqwMWZHx+gZ7IF+OdSZrGtdzuS0BQPdVV38HVneuMRcrXmwr6NTrDxHd9BvqKjVXogP6KoKcx3ZPCdlvsHF3sWOc7iwy/lV02yg8I+FY9M811/qOYRiGYZi2BYvoTLOBfzkmPSg4tqhRYPj5pME0tn+GEPye/nC7UWjEA+rsiYMpKTZaCAOqeMnZHIwfFk4fSv16dA7LSkZWYVpSbMhkDJOg/331K8r5toju/cFw0V6lgIsMJWQyw0cY29HBxAhtHFlf5VW1tHFPsVjiv+ScYaLYpczgVr3TvQrkQmhBdp4UFLA/mBh6WbC4MuDgoT60Z6r4d09qEH5/5TP7T90uBLFIBCD83bVjvLPIqv4dUyFBYJuI90xNpIeUIpq6//EJ/dJDAgImkUPNOkRGqZdw6idr1CRQSs9aCDywlUHbkoGCSIQz6Qlt8vOVQR+5v7DIORqxZZLaxB5TEMP2ebWf2IrS4fMIyt18Fgpthopg+P786dnCLxwimV6jAduFr68f1H1cvGIdPXTJKIqJjqKD5Q3HnQy/4Lp6a0Fd0/F54ZWNCys2m43H6zee6vl9XeC0+VDj/CKAhixTdf8ROLh24mC64m/h1lDoI7BlkTUiILxB3JTBegjpGCtV8TU5PtoRwGyou6CCz8Kq5oR+GcFgBI4bRHrsbR2sNFLvg7rtjjxefdzvnpIgBHY1mCrf9wqGydogroCp7VnS5XkuV2G4AjcIjOnvy/EFxbr93j/x72G9UulxY8HLA3R7o73h4nOGCRs4PVAtbU7k6jN9X/A7poCOq3gynmts9ynVV12/ZrYxF/cwWLp5edvjs50ax2/8BlaxBgJE5dV1VKzYuXlbx5jtvLAt21zksgn9qFdaYrB2g8k2CuCcBhoDe3jmUetITBQWWCyiMwzDMEx7h0V0pkWAYIgsD5mhd1zvNIqPjaay6jqRHYcCh4tmZFNldZ0oPlpTW097iyqoQ3w07cgvFw+pcokkZ3Mwfvn3ur304b+3hUyGILb0y0hqnKybM569fL3ViTs+v+yqscL2AGDSVFJZS59vL6AJgzoL0SqS7cvfEEW0yquF+IWMYwjgwI8FSySCgZz0otgllsfbJodq/4uKaii451cAgmDkNbFFJqgXron4iN6pdPO/1vgWuPQxRM86hPiAtgIZ8G1HgMGPP7ppnxHIOe2YLsFCtE1F9fOFOHCwsobq6+uFTyvanryeEBLX33E2HU14WSZE0vfVzxeWV4l7FXyWZT9x+fWjwOCVEGoNIuKXOwppaI8U43cjvdfJfSwoq6bbl5stR2zHh3EG4hjqFeB4bJm0tvHEZKWEfZcF95pyXPp4ZfOhFlmgj39Mq66fQHuKK6i6rl4UMK+ra7A8OiEzLcwWa0Fj8EIV9xGghPWSKYgISircq1fM3ut5woLrT//dKvq8PO5ILYXaOrDqWvqGedWBerymoBcy1E34DYZFsurEb00MBD7xzIoscVN2PdrjU1eNFbZE+vgC6w+/98+Symo6Y0hX64oQuWID5whB95MHdBKBe1mYE/0R4vCCadlizClSbNMABHQU2dZRi5PeenaWKLoui3uib7mwBcBtYy5+31SEVQ1669dUFCEtrw5aK6n2M17PSBiTTKQlxdF9L28MG6dRSybvYKUI1Ltso+QqE9x3Vq/ZHbJK53uNdSQYhmEYhmn/sIjOtBiYFOHhdfbpA0UmLiYf6sQWWWPzp2WLTF5YuGT3SqH/fW2zyAZTvVwjsTtgjm5gA6QWFsVkC+KiWtjRNuEzISf4PztjsJhYwh8XYhOyjFat3R02me7XOZkGxkZbRQATpkJ92BaKcCKzzbnMujG70sT3h3QVy+MRzFIL4iGbWR7/3as3ODOvZf8rr66N2FMaWWMuKqprxbF7FdSzTcT9+ONK4H+v283oYqsU5pAtPndyFm3LK7MGGLyyRiMVbF2YRCbp5yt8WQ0FWY9GvDJJ5eqBSK6B+nlsH+d8UlbXBj9fYbtiJzYmKmgfJQVnCO9oU+jbn+YWiIxq2a7Q112it42KmrowAZ0as1CxYgEBF9372RZsQDalS4DsEBfdMDY0FvJDJr5egBSBKLRJHBeOG/1pVGaa6K+u1R4mgdOVvY3tY5u6yIVtLL14FN0+daj4PsbAfcWVQkBX7aGwb1ndOtJLN5xC+w9WCjstXCPVk7lDgll88xLvIPapwVu5X00Rd9sqyCD2Ot5IfML9jq1+hHbTmOq1UgCZz/isK7seArp+78dvwS/f7/0zLTGOtuwvCXlfD1hV1dQG63Pgv6WNgbT5y9eG9Ef1XKrn2uZ/rhYnRXCpOc/f+jnu3zk5uB2vezeesfTVXnjOUWsTqM9FXhaRyXHmqS3GxYXTs8U4qdr84fygdsP2gvKQ7arXQd2vhrnN0VHrgGEYhmGYcFhEZ5qNfHhG8a9nfzpO2LPMW742rJgY/l68cp2YlHyZWyi80+FL+vRHuXTHOcPEEsmrJvTnB1CmWTTVb9Y0wYdofde5w2npm2YbEXDnOcMiE/4Mhfqwrftf2Ui3TcminJ3FNGNET1qyMrToaMOSYxQNDYT5ZENAnzdtKN3yry/DbD8g1CGb2SY2QAhbPCNb/Fv2Pz0b34+nNDzJXeI/snofeetrz0mmzZ7Dyx9XzaSHRYDfDNe5z62ll284RYgIctKMfVQtgrAfXkiBQ+4/hIOUxKrg/vvBS2Tyym49mvDKJG2u57QuwCOj0wXEMLQbZF1idcOiF3LCBOcV142nrw+UiiAyhCAUFoZNg1dgSQUrEmyWI+j7eF8V0WWwAZmrKMinZpK/93Ve0C7IJECiP1x/+mDaur/EaGWD84/79ks/O0UEGVIS42j+8hzRp1yrPXSxTvYZ2MPg82t3FlJ9fYNnu9oPESDVwfcu/NMH9NZNp4lzaqrLIPdDWEooYy/GJRRDn72sQRQtraz1XYNA5y9vb6U7zx0u2okcuxCkWLRiHb2qZOG210QB1/0F9UEQ/Nl2oJQuGp0pMrml9Zof8dErGOYS2m1jKjzcXWAbCAyodVW87oPyt0b2SfNdWBqBehVpz6IHrPRgA7LR9WdsnEv8/pJzsun9rfmiz/vxP0eGNWyImhL4Rd/F6hBksmMOoFrq2e5bepDAVPBTH+dU+xmXFQ3GK1j5+VnZhWSDLh3iaMELDc9anzYGC8U5cwQOUcgWY6e+Aqc91jpgGIZhGCYcFtGZZmGaoDx55Ziwh3sJHnivPW0QnT+qN1XW1IrJ9c/POIZ25JVRr/Tm2R4wjJ/MYZNIC0xZrWjHmBzaRCu8XuaRtR0m/FkK9X2wNZ+io6JoxRc7hdjTUKSvwb8TXuwoIAaxZ9zABmEck8/yqhpKTYyjuvp6mqf5ZpuyU/1mTDfFUxrWJcg+k+dFLdgFv1EpVLkmmcZARqMI46f4o23/vLIOUcwMgYgfjc4MmzRDVLvwxD6+2hGO75YIMy0jyaz2ym49mjjcntN+MotluxMF9AyC88IXG4LIoaJcjhBf4aOsB45MQPhxob+PNgoxzSQIod/AjxptCzYOyKiGwAXvcPwf+9A3I0mI2LdZCoTifED87tspufG4w1d7IEh35znZBL2wvKZWvF5SWSPafGlVbZjNkswMVS0u0A8nDelmtI8BsKlBpr9JXJs3dQg99MZXxsA+UYCumziQMpLjqVOHWLpz5nCRBKCOpRDbrzt9sHEVCM4h7CAwdtz0jy/Cis5irJ47ZYjIbG7OCpW2AMY4BA6255UJqzIENlEQ+tvCclqqnX+1qOR3EfTyGlMn5xb66s9+74Pqb8n+FnYvRMD6nGzaV1Ipgm0Q6dEPVJHbVXtB3gdcAUS8/vX+UhFMkufXq9B1Uy3HbKvq5O/K/e2g+Mf7DRLgvOhBvzXfFtLo/hmNNU9iRFFfjAX7SypFUV+MYepqEBO4ThhrsdquU4c4MXbJ/dctbu7XCr3K84vnLenj3t5rHTAMwzAMEw6L6EyTUScNamYJlri6wMSqsraW4mKiqKyqhnILysUD8gtf7qJNu4sjzsxjGL9+s66sNNukFGKAi7JK/yJ6bX19sHCVWghViE0T+tOSFw9ln+vZTzefdazIzMSE++zfvU3jB8IeaSjdvjyHLh3Xzxq4EtmpZVWUEBMlJt/IGE2CSBYfI7xUbeiCuyheGB8jJqBf7igQ/qLwccdkVwp/Q7p3pCUzhlFJo+8yMm7f2XIgKKC7Jpk2wQN/z3lujZjs+82k1/HK4IaIDv9bCOA2mww1U9LWjlDcU2b/SbwyLaUYj1oRyNBEFqNqMSG3IX1xXaLO0cTh9pz2K6i5BC7p/yvBfdMmvtoCL/AAN/mTy7EE76tAmLcJc/h73gs5dO95w+mOleutwZ/dReXOcyP7tO24UYAPNRn+9PZWYd+G/YalSk1tHd29emOICCfEKcPKH/TDetpoFa8giuE9PH/85HsDae7kIVRdW0dFZdVCxLMFAfDbc6ZkCZH7hS920wuf7xRjAb4PYR7tDDUrKqpqw7zXpT/2ul1FVuFTjh0Duvi3/GqrYCyb89zakHYAIfT3b3xlXcklr+d3IT66+iICLqt/doqw5rCNpXJVAe6zEGlVv3F9LFd/S4qxV39vAM2ZnCXshQDu3VN//45oR7A2RLZz99QEcZ+8csIA8Rn0DVvtBXkf8AogYkzQz68UhzH+yCx7v/VbTCvDgvdrw6o6+bsYj2A7c+eq9SJ7G+IzgoheQQJsH7/TMzUhbBzpkZpI1y37jJ67dpywq4sqrSLUN4Z9HQq06lZWKqb7tm51o1rcuJKB1HG8Pdc6YBiGYRgmHBbRmSYjJw16ZonNf1HNlDv/kfeF+IUMseS4GPp4ez6t31Uk7F0WvpAjCua112wt5rsFGcUQTdRl9a5sc0zeZhXYRSKvIlZ+CvTJCZwqkutZW67JM/YZQrnqB3xsj5SgZyiWyLuA8D171efGApr3rN5gDVyp2X3Y/5v++WUwy+6+VzaFZbVBdIO/w4yl71r3xTbJdAkeENCQ3ZjdM6VJ3uNeWcQQFLBN24oDNVPSld2IIIlJ5LNlWpom9WqbMPmyt6T/elvmSHhO+zn3fgQuiZ+sU/26wmcc91gIzXpWOV7H+/r4dObQbmJ8uWRM37DgHdoe+pbTWz7RfS5xHmzHDSER7fzVDXvF/V3NQMX+6iKcaxy0iVcY83HcqBmgnxOMcchUdYHjlwVHF87Ipusb+x7akbwGCBzefHYWXXqwMswfG5/531fNhSGPJosH0xju93p+F+Kjl8d+cXmVsT/jPbGqwhJUwj1Af75AgVB9+8hyvvclQzazYm2Ic4NVFiicjSzrZIuft0QEtD3OlXxmUc+vWmAX1i1+6ri47MVQ48QrWIjxDb7tOF7Yn+Dvs7K7eQYJwJ7iSmMdmtkTB9Hi6UOpQ1yMeB7xu+rLdt+24VUo3fR+e6x1wDAMwzBMOCyiM82eoOhCgLswYmcxgQd4mEX2GyYSmPxisrvsw+0iU+1omXQyzQPWJh98Wx4ipiBrzDS5gu++niXsB7RnuRRZB693S4n33MahrC17Np4XSXExwtdXCmCqOOEl9CNjXN9/+dvof16etOoEFJmFLuHv/h+ObJK46SU+YkWAzMaOdGzwk0XsVfxMitiRZBqbvu81qdczCCWqyBRpwcz2SKSWQy35u65t+xW4/Gad6r+F78PqxJTZiyxsFB1UQQYtbAlswTuIa7bVNnIfEJS0eYXjdZOn8aH3OwubGNzX9XHDJER5iVc6uN7IHJ/zbHixVfn3zWdl+RYd1b6nXoMO8bH0/Bc7xbOK/jte+4zjPxowjeF+xEjcRxGA/Hp/SUQ1JLzw6ovIKtf7M8Zl3ZILoC0gwQOFKRG81p8vYNOiWw35DSDIfnVcZrpY/eBCCv1e1ma28+9X6PWyF0MCjAv8rnr8UsQf2iPF+T3cJ5GZ/+CbXznr0CxCQoJHUWkV233bNl+JNHlC1p852u/LDMMwDHM0wCI60+wJij5RsPkvQkBfMH0o7SqsEEIcPicnEvL7EPSwPfYVZPxw//kjqCoqIZhFBjFHF9Dl5AqFuGxWAEIoH9TJuHwXKyRgpQID/5CidIM7030+xTov4RV1AjKSYsM8QNWMUVgfIRNdCmBqQTKvwBWKetp+W/Y/V+BK3X8v4Q9Z7xAx/7N5v1h+LY9lb3EFTTymi/U3/IiPzRkXZBbx3uJG7+f4aFEEGVYufn5fitiRZBqbvi+JRIznDDczrTErvzkCl46pvaOIn81mAO1J7ccQwoTgZxLcKSDql8BuAfts8xrHPsD2CfUZUMNEzwzF66WVNdbjrqmtDxPUXEKVl3gliyCq11v4vucWWMfP1IQY6/ioXxO978lrgN+B3RyC/fJzflcjIWsXWb3t3aZOHUNxvvz4bePcwepj5kPvBrP//dSQ+K5Wq7jGZbH667nwYDi2v2B5jhCWVdugSLKZIaTPmzpU3I9sQXsvr3a58gLBMbU/SfuncQM6UWxMlBhDUOjVZX3iVbi5uhajgR1bP/bq3+jTCCR41aF5TSnWq++b6VkGKwVM48PTH+WKc4kApHq88Fe3XQecZ/Rpac0nV6XoRWIZhmEYhmmfsIjONHuCok8U1OI8V0wYQB0TYqi6pk4Ieec0TpTUTDj5fTl5xd/sK8j4AROllJRDy5KxxNpVcAuWKCYgtCy/drxYYq2LRLAgQEG5C0dn0qXj+wWFHAjEfsU6L+EVk7AOCbFGOwL0E6zQkEKP3L9fTDrGM3CF7ChkaU5f+o71t2X/cwnU6v57CQOlldUUGx2g1Wt2hYgNCFLAx901nrgmrTj+c4/rRc0B4rl+jWUGmV/BJZJMY9P3JX7F+O86s7qt09qy8m0CF9r2dRMHhRSnTPMQX/X7IERxFDp2ofZjZwHCLQfEeIbA3CkWCyG5D+g3qqeybmey7MoxwvPbdNzJCdFUWhVlHDdMwT9XQBB9wTTubssrtRZOxes4J9efPpjQM02e5qroCNR9ldcAv4nVTKjxgLH3+on1lBwfTTFRUdQxPtqaqY/fwLPPI2997Vzt0x6QY+j63cX05JVj6Y5GyxL9eqqiLsTL6EAg6KHtVUPiu16t4hqXnZZrW/LolslZIcfqJRjr70OYRTb6r3zsswwgQuzNzS8Tr8n+KPswvjO4Swd6cfYEWrQiJ6xgNu57mZ0aioFHch5AXlmVMzCF/RqVmRb2nlf/RhvavK+kWXVoTM8ysKQyPV/J9vHsNeOE/Y4anDv1mC7WQIW0fFKZlNXVuV8MwzAMw7QPWERnmj1B2WawQZBLN5H58WVugdPGQp1IYPIKYYGzLhk/wKe2Z9eo4BJwr4mfjeMz0+ildbvFhB+BH4jAXTrGi8JfclKK9iwnsl7ZdTpewivsVnYWlovf0/sJ8qRvOTuLLvzTByGv33p2VFC4UQNXMouyV3qiKLyFLFFThqlE9r+EuGgh0knfb7WYWEbSoUxVL2EAn5de7SoYA1Bk7zcXHGfMgMPv3nPucFFEVBWj5KT1mY9yqbMP2xsbyIQ37ZcsHPrbC47zJbi4xHYIpRAPVGAxhEAGzicsY6SHrleb6NepIePWlFltK/bGHJ5z4/Ubtgx5AEFLXTmDtvTJ9oKwQqFor/p9UPoF+xXe/QZq0DfxL32ljhr8UT2Vbb9pOu7oKKK1xUXU1yDWmYJ/eA22VXpmqEv4RDazXqNB3eZdM4dRl47RNHfKELq0qEIUSMa4qIuOEjnGoT/HRAeC4yJyb1d8geBgaHAEPs24b+iZ+hifF0zPpov//IEIwqK4qjoGtLc+K58JIepCQMe5wD1NvcZ6DR2JmljREj7yah/1UxhU4hqXvQLICHDhGUIGmvAM4RUY9tuPTPssA4hoz7b7VlRUgOb+4wvrfU/ej/UxrUO8e3qIFSamVRk43iXnDKP0pIZj0e+Vss/juUa9z6v92yu4iCKitgLt6nmU4NjmL8+xjg+/PPNYSkuKNZxfCgYqEEhMjIumujqiNzbtNe4XJ/8wDMMwzNEBi+hMs0iOi6Y+6YnWiQIyjVyekLCxeF+xmsDDc99OSe1ucsl8N1zy6EcUFZ8UXALuJUz2Tk+ke84bHmIzsqeonHqkJtJ1yz4LEVOWXztOtN9/XXOyeB1CTSTZ55FYPCBTEVlSJrsZTDQvL6kKE3ryS6pEJtm85TliuzahHxNIL3sJ/H/lmt3CrgCCw+3Lc8IELAhbyKJ1WscM7kzl1XXWpdg4loLSKusy8t4ZSWLfUegPPs0y2xUCOrJAmzou4Bzkl1aJwooQu/RJN/YL72f18C5c6pXdCJFodL+MhgJwibFCvJnzXLiHLtqhK/O9V1qi8XhNxd5w3hGAwPk7mnEVwmspK43dheUhVkWwQ/nom3w67ZguIcE1W4a8/ppo7/ll9OAbX4X0fVxTZEJCyJFA4PLqf6rwHsmqCZOFkCpa+7XFMHlMD+ragTrGh/uqy+AfxpxF07OFsC373NIIbHpgTeGyf8D7/Tp3oN1F5SLzHsF9k7e5PibCZmTy796mE/umi/4q+rFWCBVtra6+nk7qlxEioMqxq7q2TrQ/XTRu6XbZWsDxFJdXB8+tHuBFAdjf/tse8JD3wOZYdzVnHHDdq73EXTxf1NcTBQIBkY2/4IUceuYnJ9OiFaH+3aYVELZ+JMXthuBLlTH44hLdN+4udt+Py6qotq4+7HyhvbsCAPIeqq9OwSq9fp0PBcz0eyXaA+7nGFsqquuM/Rtjq6sOzWfbC0VA3BSAQV81BR/1fivBuVkwbah1bCmtqhW1m7AvcgXFyQM60ZhZnai8ulbYSOE8mH6XYRiGYZj2CYvoTLMnKijWiAdYTCT1jBTpN2wD7+MBFGCCjezZXulHtxDERI7fopbIrlq9ZndoJiEmtI0ZznKSJDNCvz5QGpwsYpKECaEqavlFCq/6RFWdTGNyaStKiWXeOugrWIqtZkph/5GVhv/rv21blgyrGLkPOHZTtja+hyxLiF1LVq63WsdAdIK1gouDFTVCwLJlY6L/4zpJQQAWLshA9xLQbdnBJkFFL6wIiitqfNuDeGUKSvGjsKza6qELYQUZe/NeyPGdcSuLvWHM1f1d3/5qP100pi8drXgVwmsJewj8BgTvlWt2hdk+9e+cLO5naN+RZMGjrz70Rnih0LcN+w1R3FVz5I4Z2VSOgF/jGJUQe2i1ip9MWAQKETw0teemFnHFe33Sk0SwHIGwhZqgiHFVBiBUwRBjAAJQ8GMXaauuPu9RuBN1GvYVV1Ba435az+HgzmKM29VomSPHBxwzsqtdNQwQnFOteoLbHNTZWYi5PVq82PynYYGB47V5+uMczZncULAS/edIjAN4D8FpU/FQJIy4Cuy+sm5vMFAirUJQTGXK8B7iHitWuHXACreCMNsVUz/yCgaE3fM6xInC2yryvubqG3et2hB2vnCfR+Ac6AFb3OfVFXoqr/z8lGbXrcB7v/JpiQVk30LfxViib9trRQ7GTK+25FpBgfPUL4OTfxiGYRjmaOGIi+gPPfQQ3X///bRnzx4aOXIkPfjggzR69Gjr5x944AH6wx/+QLm5udS5c2c6//zz6Z577qGEBHuBHKbl0ScqUoCDVyjEPGSSxMVE0c7CCud2MEmWD8co3lhX5y5WxDA2MNlCJqNN7MHEWAg4eiZho5XBdRMH0imDuwgRDG04EKgVE38UFpWCa3NED0wmUXgMS751T2E5mbYtF9ctVKQ3sJ4pZcu6UyeyclkyhPmismoa2jM1uA9Oz1cUT5s2VNhRwPf87pnDRSEtnC9sC9n02A5+x8XByprgJNiWQW3KZoXfvU2ctIkNwexRTSCQk+6fnDpAFEjDcUOn+3p/iW+bBZfYLvcHHvw2wejVDftEZvzIPmlBr35kMnZPSQhuF5YeyNyHEJKa2CAq/vjkfnTblCH0RaMoJdsOJvNHm4iuikho0yf2S6cT+qbT8F6pYUv9pT2Eek5hCwDLI1eBPRUERZAxbsuinTdlCK3K2SPaE6w79iXFisxMV2DYlSWp21pAfILojHEIwo0cq+RYcteq9XTl9waKcwEw3tkKgpq8wHEudBFOXXUGkQorRDrERVNSXIzRAsEW0DojqyvllVaJMQSZr3J1jxTUbMEu7OdFf/4wGMSUY5r6eVg7uMA49fqGvTR+UGf6x0/GivMDX+U7Zgyjsuoa2llQIWq3dE2Jp3OWNtRt0fEqpAjbFxMdE2OtmcAtYVvS2sBKjYzkBqHYZNfiVXxxR36ZGNsuPLFPk1YbwQbolrOPFasccU3R39FOcJ79nG+0q0UvrguOy9JiEP34t69uEs+5AQqE9FkI6Jdq/UlaseH+Nve5Q1nTMlCP+yS2PaBzMvVIPTTm+w0GmO5t6moo2f9wDlwkigBs+PgjgvqPf0xPXz2WfnrqQIqPjaK0xDjRd3LzSunXPxwZMr4CPN9gJdpn2/PF8ch7qd+6Ffq4gaQIPNMhSAbxPSYqQJN//7axf+J8YzWLyWrPb9FwHbWmxNXfG0CPa8EwnGesPsG8ZUdBuRgbcb45EYhhGIZh2jdHVER/5pln6MYbb6RHHnmExowZIwTys846izZt2kRdu4YXaFm2bBnNmTOHHnvsMRo3bhxt3ryZLr30UrF08re//e0ROYajFb1gmcxIgXgAYQdFGncUlNHanUUi09ckJGHikRgbRS9cN15MuCDE9T3K7QiY5gFx7IR+GcbMp/0llfTahn3G72FidPuUoXTX6vVGsenZT3cExWEUvcKSdF1s9fJJxsQT78NOwIbJb/yMrC7i/9IDFF6jmNDLbGe/WXfqRBb97dyH3wv7Le+ioTWi8JkKxO3z/nBoWy67CfR5XAvpry6ybZ9bIyb+mHiaziGCBF7ZeLZzAFsYW/YovHohoukF15pqsyD3Hb67OI8QYbwEo7Lq2rDfhnBQuL9EeNnKiTnEiv9+tV8EdFDo9gd/eE/4+KvZ9Dahrr2ii65oU+gjD7+5hR547asw8a68qlr0QX2lhVeBPZXSqhqnbQjSpnXxENu/97wRIlBkat9eWZKqrYXMCH9r83761csbjftSXlMnAlwokofx7r2v84KWC7ExUUKIQuYlijmqQhhsH2rr642BJFdGrL4yR3z2X1h9ER7EBCWVCF7E0kBFOLT1Yd3iQ45pQP08xhxkfJuCETj/sJKBZRdsqiYP6063PZ8TfB/PJ4vPGUYHSiqFvYQscKkLdenJZqFNiqLIMP7D/4yi+JhDwiIKK+J8u2iObUlrAtdwb/lBYXFxv6FtYrw9Z2QlDe+dRg9fMsroZY1ziUAi7rmb9jZsy4+FGtocAkg/O+MYumNlqPc1rj+KnF7y6AfBZwLXMch2pT8rIOB78sAMsT+ocYHnVew36hq8sm6P0VsfGevFlaGZ4Hr2NlZ+mI7PVRTYdm9DbQWslMHKFtkXsCLAtRrFdY/CviLof+2Tn4naHgunZxsDXQ9dPEpcu6VvfBXSt0z3UueKMcO4ge+jaDHA2Oqq74LnExN+i4bryLEZx3bGkK4h9xVbZjrO9V3nDjfWgGAYhmEYpn1wREV0CN9XXXUVXXbZZeJviOmrVq0SIjnEcp333nuPxo8fTxdffLH4u1+/fnTRRRfRhx9+eNj3/WjHNvGHeIQJJYpKXXXKQDohM53OHNqN6ldvCCsWiMyd+/+9iSYN6Ua7iiroxTW7hQ8qwzQVTMxlEThdBMKk0wX8ck0ZphC2MTn/zSsbQ4JB6gTRa9m1LGqJrCWXn7GpKOW8aUNpHpaWa7YDmMjX1DWItbD30CeXrqw7W2aWV9FQU8aWPhZAFFl21VgK0EZjn3/gtc0h3u/4DLIP4SWrL6FHtp1uvyOPTQpqLrEBArQN7AMEdJPVSqQrDmxZtGdld3MKb30yEsMEpe0HSqhLSoIo+mYK6MB+Rz1/Jh/99o5JdBXn4c1wWxT5t8gIdRSWtRW8xbVFtndDNmSMEKVMIqv8rGn7+N17LZmjt09tsK/w2+cwniCAoma36scLsV8GxFTRDnYUT1wxWtRR0IXGJTOH0Y//8pEI3PgNUun9RHxWE8KCn31ujQjAyX1Rf8PVh1WvdjmmAfXzuB4rr58gPKhNY87vXvuKrj9jsPiOXPUhQf+f/0KOGJuxbyarJ1lIUR+7XRYPCOhAuC+vdovk7aUY4U3/WkMfflsujlsfU4XAevHx9Nd3vqFbnjV7WQN8976XQ+8bXkFN2T5xXWUxUxVsa8nKdSJQiwC263y72uGG3cV0xznZYX0HwZtZ40PblApWi7iw7Y9XcA1BVn0sEhnu2koZ1brIVLAbq9FcyGeCY3ukGK3J8FvThvek1Wt3Ge+luDYI1mFsda4Yeza83oD8/tLGMaapGeVNtaOSv4fzuq849NkMr6HfIzikWxe9t+UAi+itBKxaP3DA3KcjASvfMzMzW2SfGIZhmLbPERPRq6qq6NNPP6W5c+cGX4uKiqJJkybR+++/b/wOss///ve/00cffSQsX7Zu3UqrV6+m//f//p/1dyorK8V/kuLi4hY+kqMTlwgnLSHmnD2EfvXyBuEViskzHthNNhawNMADNr7T3pY2My2Dn34ss6r0NqROspsC7E50AV33YfcSmZAhj8kmJlw2L977tKKUmBAiy+2mf34Z9tvCWqVR+EF2lkn0AbasO1tmFvqlLWvNlrGljwXYh8LSKs8+rxIfG22coCPrz8vqwiU2uIICLusabHtnYTkdKDUXclOz6bAqYd7zEOPDs2jXfhu+EsclvOH1jA7xtEATauT2xH5npot9l6/ZfPRbGy15LzaJXa7r2SAs10Zc8HZ7XqkxmGHrbzbetmSOop1Nzi2MKEsSQtTORs9uG9gvWLPoIPA239C2cPx4He9DaPQbpNIDdQgC2vorfgPjgfpd+RtegqG6QgZjWr3hePEZ15hz45nHhm1LovYjPfs9uA/VtcH9Vz9j8jvH37AVGTsgQ9hb2AKnrizYttaP3/86TxT5Np1fmd2v31fU89grNUGsInknwqCmbJ+wcHH171snZ3meb1c7vO/8EWECOkB7r6N6azATKxH8Xn/dnsoFsq71e79pDFQLu+Ic7MgvD+kbeN22f2rdBNf4Chskm20Zrg1Wq9XU1hmt1XB99zssrfB5jCvCHqaJGeVN9WaXvyfvtyp4TQYoTPfyo81arbUK6FlZQ6i83J1A44fExCTauHEDC+kMwzDMkRXRERmura2lbt1CM/Xw98aNG43fQQY6vjdhwgSqr6+nmpoauuaaa+i2226z/g780hcvXtzi+3+04xLh5AMniqzhwRoPk65MSX2CzDCR9mM1qypgmWQjY9uVBa4X2fMrtkJ88xKZZHEvdUJ7uSL29EpLDHp5qpM6TD69MjRdGcmRZmZt2l0sbBcgFvjN2ILQrwvvuk2Jji60xERHGSfhXvYyGC9c2WnC5mFwZ+s5dIFr9k7OHnFOYPdg8mIGDZmX5u3fuWqDsLZarGRIuoQ3gGKjrsJ7st34PUethZa8F5vELq/z4FV8Ui/Ah+usC+gukRUZqbYxxLUqAgX8Vv/sFBEUs/U5Ka7BbmXJiw0+5y6k1zhWsiCDVGZJYowxBciCGflThgqvddVHPhK7GdfKD9M1kuOjV4apGgyDuBgTFWXM+HWNObCR0bdl2zcEO289Oyt43mCh1Ts9iRa/uE4EsWQfxEoSVw0JBG5hb2cLnHoVZW2L/dh0fr0CXHMmZ1F0IIrmKlYgejuBkGqyAZFFTKMoYLWJAaWVtZ7n29UOEWBzWTmZgpl43nhny4Gw4IvpnqrfV7xsWDDW6GORbQyUq1GG9kgR1iwqUghG0MdW9NxrfPUae8W44LBWq/AIRmIlUHMLHMvvq+MpChinJJoD5ervYRWCblMnV9267uXMkQV6AQT0MZcvpJQeTUuiAcW7t9GHjy0W22MRPRzO9mcY5mjkiBcWjYT//Oc/dPfdd9PDDz8sPNS3bNlCN9xwAy1ZsoTmz59v/A4y3eG7rmbN9OkTWcEihowPlxDbsERbfcjfuKuYpg3vESwg6MciQn2/vSxtZloWWz/+7QUjKT0tVUxwYHOBrPFzj+sV8l0pAqnLmnUxA8LllN+/bfxtT3HOY7l2g9AbY/VEBauunyAm0fqSdb8ZmqZJfHMysyLJ2KqsqqUF07LFknkp/kbS5zExhUez1+dMyH2zZadBAIeNB8RQ9X1khyN7zk+mH4SEhS/kiCXpQF914GofuNbf5JUGhTd53l2CEnyAXcjAi99z1FpoyXuxSezyOg8Q3tzbjAkTbvyKZhDQF84YSjOWvmvdvm3/0EaKy6usfU4voIk+NtLDFkr6SKMQKKxkZHt76qqxznOAY0YxQZltjwLCfi0UIEx1iHc/UprOAY63f+dkax9Ws2Hx789yC+n0rK5hn0fhUxd4X92Wbd/kShH4eqvBLNSmWDC9wc5Dnk+Itl591RY4HdSlg7EIYlvvx6aaGF73UGRHm1ZOqOTml4XUEwkKp4lx1iKm6moRFAf1Ot+ue0mJx31eB2PCZRP60exlDSI0rj8KQlfX1IXdU02WSV42LFLcVscirzEQ50AH5+eZj3LF/Q2BRpxnoBc9N31X4ud+7wqwJcW7+y76ZFMzytXsfgQXUZxbt41zWQbhNTwL6MEwddUt07qBgJ6R2bASiWlZONufYZijlSMmoiPiGB0dTXv37g15HX93797d+B0I5bBuufLKK8Xfw4cPp9LSUrr66qvp9ttvF3YwOvHx8eI/puWBdQaWT2OJaElFLcVGB2jr/hLh/4yJvJzUNhT9MhcXxYQAn4cnOrJukNXKMH778Y3/+FIsIZcTS0wGO08IFZOlCOQSM9KSYunEvunGyTMmXpGIbzrSlsWWVYbX9xRXiEKB+pL1SDI0VaEi0swsv6/rQOC7ffla+jS3UJxXmSHbt1OSs8+rotgtZ2UJD2cTriKlMkjgyk6745xhQjhBkGTL/pLgNe/SMZ5e37DPLkQ2ZhWrFiomL2Y/AgKW80uvZbRRr4zoskq3iI72+P7WvLBziXbUmmmpezFEEZxTfYWBqa1I7/lxAzoR6ju6ik+mJ4e2d6/rlBwfI0RUXH8U0EYhTxSSfCfClS4N24o19jldXJN93BUQhC2UzLZEIU31/Q4JbrFKvi+/gwKlGBu9LBSk0O9a7WMTsDE+2vqwKhiq/x7TPyPs83GxUc7fjo+NotkTB9MVf/vYuW+27NLXN+4nonV0x4xskcEqM9FdyHuHHjjFeZMFUtsaXv3Y1Db9iKxebVMH1/0/m/eLmhleq0VM/duE617iFYSD2Pri9eNFIU4ItXiuxbggRWjsB8ah7J4pYf3cZJmkPq/MnTJE2EHpFkUSOS6IZ2/LGIdjwH1Z78vyPolMe/yHcc10/KbvSrBKwLbiS/YtkyWK/jlb302Oi2ny84me3Y+Ay7sRWgYhKInnQ/X5ETZu+aUNzwQMc7TC2f4MwxytHDHFMi4ujk444QR6/fXXaebMmeK1uro68ffs2bON3ykrKwsTyiHEA9i7MIeXwrKq4MTw5AGd6MePfSwmT//4OJfmTR0qRAs8AGNShaJSRLB3CZ0gXz9xsMi8fG3DXiHAIbPEVNyNYUyomegQ0DEZ1CdBanaZS8zAd1FgTp0IYmLYN8M+ecTrmJx7iUxy5QYyolWRDZN7ZDde/OcPxERa93N3ZcbpotSAzsm0/Npxvrw+TVla6hJ5PwQFvsbjwXmVoiX+j+O6Y+X60PM5qBPNn55N3xwopSevHEMV1bVUXlVD732dZ5xEY+yAvUR0IOBcvu2VnZZfVhWSxYjJ9PpdRcZl9rgmN511LF305w+C72HSbPJi9hL60X4w2UYGsRQ/nv3pOOd57ZjoDrj0TEugpz/KDTuXKHrZ3pGiCArp4l5TV18fPO+yrUhbAt17Xv5dT/VhfRB9U7/veIlmyE6U1giwTTn/+F5058zhYWMI2iq2DysQE64VI7q4JsVIP9nNJmEOxfFcbUstnofzikC5l4UCkEKVvC7y++q2L1WyZ03HrvbhvNIq8fwQFxNFu4sqxOuqeIgAx4AuHUL6fGwgQLMnDgr7bfRNiOcxgQD1SI0Xxc715xA1s9eVXQoh/fapRI81iuwYR1ziH/qk/n5btXHxi9o2rzttkLiGuMYukRUi7DFdO3gKsTqumhly3Lb1bxu2ewnanKvvVNfW0YV/+iBE3Ma4L8F4/dG2fLEf+rW3rTiTzytThnUPs2FR6Z2eSP+65mRKiI2iE/pm0J24724J76s9fGRxu+6ltnFg4jFd6NRjuhiLa8u+hfZgu76b9hyk608fbOy7eB2BvEgxZfd7WfNhrGmweGl4FgI4D0XlVbRg+lBavGJd8Pu4n/zzJydHvF8M0x7hbH+GYY42juisG0tCZ82aRSeeeKIoFPrAAw+IzPLLLrtMvP/jH/+YevXqJTwYwfTp0+m3v/0tHX/88UE7F2Sn43UppjOHj6TG7BCIF2cO7Say8PCw/IdLRtGaHQV0Qr908QD84BtfiSWtV39vAN0waTDV1tWLZd94CEUGKoQ02HDgu09cPvpIHxbThhjUtQNRbJywcEEGuro8WhWH7zlvOC1asY5e3bAvZPKHrE0UHJTCHCZ6VyDLqEMcxUZHCYEXQpIUwE0iEibFfnw6Mzsl05KZw4Q3L1ZuIPMOopUU0E01AfxkaMrf6pEaPjl3ieR6lpbXsmYdKdJJ4XxUZjolxUaLImvvfp0nhF6ImvAFVgv9zXzo3aDQ8PINp1BZVY01s/b4zDTq1jHe1/JtV3aantEvfw8WQKrHMTJHIXzB0kIVQzDWwWsXq2vw2/J6qdvS910VT2W7w7lKiIlyijGBxoAOPLLVzyDDEOL+r1/eKERz1Jz4en+pyMpGZjr2Y/0dZ1N7RRdFVBEZZGYkCVFtaWNbgcB+x4uHvOhVce/a0wZRbEwUdYyPEUEwk8CGtmC7ThDEZNAKVgQ1tfV06/NrhZe2WJHRWMQY4lb3RtEMvvqVNeFjBMYgWf9A76equCYtDXDtYbsivZ9hM4Bj07ObTcIczt+TV44V1ku2YJ4eKPAS1tS6Dbq4j7GzX0ayEFJ35JfR0otHBf2qT+ibLtr5trxS6qAU8BV9eF8JnfHbtzwtZNQ+j/axr6SSpg7vERJYQHZudBTRx9sLaOGKdY0rZvpRINBwXJ9vL4ioSCyyT6XgZ+v7cnzGOHLh6Mx2YePixaM/PpFqYhKC7RJByhkje4rxqV/nDuJeaBJZcS77ZSRR97RE8Rn9Xgfhdda4fmEBGD82MRj3f3PBcVYB3XZ/tN1LFs0YRotW5Fj7jt6G5P7hOK+dOFg868IiybSfLpLjYqzBdNwXUCfggdc20xsb9wfvx9ecNlC0N9jkqPdLP1ncts/g/odVXXhux7FijJTWUQCWMBgPYN2iZ83brNVwXDgGBKinjegZ0lcQXOmTliiCaqq47ScAZQoiyushz5GseSDb7Pb8MvrJ/33acF4Hd6brJg4KPgvgO/OmDqFbJmcFVxvgWcG24o5hGIZhmPbLERXRf/SjH9H+/ftpwYIFtGfPHjruuOPo5ZdfDhYbhdeWmnk+b948CgQC4v87d+6kLl26CAH9rrvuOoJHcfQSFRUIZlnhQfPRWSfRn9/6WogZKBS4aW8JZaYniUkSCgeh2CAm/xAOj8tMFRmBAQrQJ0oRKNX7kGG8QDZiSkpKyGsmcRgTorswgZsyRLRBKQKB2U99HvwshN9JQ7qF+eEi0xRCfEV1nVHI9evTWVdHNP1Bu2+yqSaAuu3C8iqqrK6j97bmBSenNusWl0iOybD+np9lzSoQHvRsXwnGBfwOMrvkpNQERAV42toyazEJr49g+bYqjKDgXFpSHFXVNFyzp64aIzIBsWhpeK9UYb/xi0nHinEIIh8yCQtKqymvpEoIX2phOgj9yEyHYPL01SfThX96Pyiky32H//Si6dlCeFSvvyqe4viWrFovsnLrDdm6d547nL7cUUhZ3TsKq6zLtHOBfcDvnXdCgwex69y2N3RRRF9V8vqNp4YIRULc1cQN+R38h88PRBDOAvodxozbDatHcJ36dkoWbW11zh5auWZX8FraVrrYxggE8RBkVjNHg9nKjdnwsp/JDGjd+9m0CsckzOG3L3n0A7Ht26cOFfsBAU4P5pnGI1sflIUddUEK48t954+gu1cjKzY0E3v5dePpy9wCsYriumUNGbboPwjE4xohyH7/+SNoV1E5DeuZGrJdiHE4byYBFM8bCCyp4JkRQEDX28zpWV3okjF9xXWR/axHqlvgxr7BHxqr7SCoIyiKIqQYZ7AvKBK95tui4PjcXmxcvLjyiU+EtZq8xgunD6V1u4rptGO6HKoFcdHxQhjFPRhtOjkuRmQZu+6jEOEn//5tY5DDyyYGq4BsAnqkQWTsI2p3zD59cNDCMDUplnYXlhv7jgyiPX7pSaIgMFZcYsVsfGy0aLt+V5zhdZwjWzB91vh+dO/qDXTxmL70wdb8kDEO1wHnXP0t/HZhWbUQwjH2pGlCuA3T+cJz0aIZ2SH9ELYvfzUkLEhrNddzEjLu1fdwH0S/fU3blu0aYR/RtrBqAAI3xiX1Po724npmmTGip3gfn8dxIhArLYHw2m3P54jPIfCO1/7v8tE0a3x/gjSvj8sMwzAMw7Rfjvj6b1i32OxbUEhUJSYmhhYuXCj+Y448mNyodgjXL/uM/u+KMcIjOWT5MmwHpmWLAntgZ1E5LfnDejohM41uPjtLeBTKrNBkzfuQYZq7hBfg79ueWyMyg4WmEggX5jB5QuY0vMn15fmYEEJkwQTQJrz5EXq9JsuqrUOYSNQhTvw2XocwMCmrq1Wst50HKZIjm8y0rFp+RreVMQGRzuYfLP+GuBRJYVB9qTVev0rzuI/E7uO+VzYF9wXXF8vrH35zCz3w2lch1/z+lzeFipiDOgmh76Wc3ULUllYCEFORiYiMWizdl8AvFWKRKcMUk31k6EFcRyBxwqDOYjJ/BVY9TBggAglSJN+RV0Y3PP2F2E+vgmUuj+32iFeRXX0VR6SfByZh9r7zRwphRgo7ELalgAOxBj7g/Tol09zJQ0TWM9qfFNT0vqSPEaKf/uvLMLEffRPbQbtBHxjRJ83az2Bfg8/pYqFtrMH+/O29bQ1ibmqCyGT3Mx7ZsBV2/Oulo+m+lzcYj23Ji+vFSrXlX+4SK9SG9UoVxzf3ubXBz0EAvPa0gcKGSYpgCGAgm1WuHjIJoLoQh8xvmwiLzF2I6KrVE/qeugJBzVqVyQOBqADlfFskVixhZR1+T2bYYyxAwFWvseG3TkV7ANcFK79wrfTjRXvFKhqIyaqALjH1EQRYIPSqwRScawjyfu+nkdwfbUFkZMsj6ITrXVtbT8mx0aIvmQR09IE3N+2j7J4NbVtfpaQKwV6WSQ3nhMRnEHgqMmR6V9TUBQVf9Tqo4w8Ef2RbY3WoyWLItgLNdL7QL340OpNueXaNcQUWfNwbxOzQZxTXc5K+skRNcPC6RtvzSkWWuynIKM8RzheyyW1jKVboqOfQVLBdfe1gZQ3d9M8vjcF/hmEYhmHaL6xYMk2mU3Ic3bN6Q9AOoU9GEs1XBHR18rmjoExkqEMwOqlvhngfkyBMqPB5aJrIjGuK9yHDuJbwSiCKfFtYLvy3MUlCFtVPTh0YfB9t9WBFjWiPtuW+WFbcHBHEz2TZT5ac1z64zgN+11bI0yUw6mBijEJpNrFXeCrX1DWrMGgkopM60UcGmj5RFpPjN7eEvaYLCgDC370vbRAC31nZ3amwtJrOzu4eFEmRvYdMZteqA4kuXIQUu4QgR0SfNopCQ3uErqqw0Ss9UYifRxNelgf6Kg6/n0e7Qb/GSgTYsuDfEEZf37hPZD1jJcEQw3XJzSuluZpoA/EVdinI9rZZNKmgoLAuMqtjT25emVg9A+sArJIxgfZeUlFD3bRd9NuvmtP3hMDZWLxUHzMhlNpsDhCwgrUbglm/mHQM/e9rm8P7oJIJir4ht11QXh22UkgX19RAJwR+l1WLbgmC/v301WOFCPxZbqGwp8N4LD8LKwcE6QZ1SaZZfz1k+6QKdlix5GdlUnurT5KRnhYUuHG/3VFQLoJROO6m2ochYILiobqPPYKf/TOShBd3pO0X1wXX0LSCAvvuCiLrIrDLbi1nZ5FRsDUJwX5Ws0GUvuTRD437ZRJ81fEHfRWFWNVVM5K3PYIHpucJWwAdxwYxG9vCSsGm4vUMg1UgCBwUlOJ81VBNXZ2Yi8BSS/ZJvcAsru0zPxkrMspNYEy5YdIxIW0iPSk2mJ1usoXRV5tIbjqT/aEZhmEYpr3CIjrTZPCwjSWaeDAH1TV1wYmta8kkJhfwy8T7VTUND6aYcKGQWHueZDLfPV7Zp/A5P7l/Bj3WmEWlCiiYOMll5ra2C+/1b/aXiGXiTW2rXpPlpmTJQdwtKKuig+U1lBwP3+1o+sX3B9Mf39pqFJC8/H9NtjI62AfYoLjYX1JpLN5pKwyqLzOPxN5JnXSbCoj5fQ3gd7E8/qE3toRaUQzqTP/4yclUXF5FWT0agoEudOHC1bbwOoofAmSy2YqwiWK2SXFhma7tnUhWcfj9PIQ9eM/DvkcXhOS9auELOSLTW+1z6G+6gC7vY8hmRNuW2c2uvlRcHhrMsrUPkzivYhPq/Qhz6mfg14zPVNbWicA3xkOIoDaRU/S5LeFFXMHDl4wiF7AzevH68VRWWUu3TR4iLC+KyhqK92J8RVAD5wf/RjHQR9/ZKraNTHGbOG9aReMVTME4o3Js9460q6BCCG93dEoSVjcr1+4OL3g4cTBdN3Eg3f/K5jDBDucaQv7R9Dxz4z++FHYuajChuKIm2F6bkvl9qHh16PdwrlFsWn4v0oAFLIhc47DJt9yG3scgvKK94Pjxulz15Ket2rK05QoZ9EcED6TYb/NgV5HjD76PbH5TQNu2P7bnKvR31EHC/RMrOdQABPbJ72q2pj7L4frCpunGf3zhzDzXgwt4bf/BQ8WTTeAcqytTcB9+/tpxtKeokj7eni+OUdoIdUuJt9bNYBiGYRim/cIiOtMsMOGVWULqpNll8xBFAbrxzGOER2TnDvHUJz1RZCzBb5JhmoOXYILM6F7pSTT79IGifSJzSWZKy6W4rraL7EQUpYNPp98CnC57FlmksqFoVkNxPWTCRmK1goxY+DarwhKOafbEQTSiV5rwHNYn27CkaMoyeB2IuS6QQXu9wy9cBcL5vBdymlzoVJ10m8QEv68BWxvAOAfRFcvV/aALF662BflcBhwwUV/9s1PEb0VSzLY9E+mKBa/PAwh0sGNxWRJhjND7HLIfbWIUBBV4JvvpS3qQyNY+TOK8ik2odxUWVpHinckSASLRXY0e8LY+Z9pvL79qjMU/fOT9kN9BrQApgMkgxu9e20xXnNJfZJj6KSYJEUwt0tohIUasOlI9miW4PhC75aqS5PgY+mR7AV3z5KdiH175+Sn0oLZ6Bci/F0wbGhTRVcFOXeXg5/y3J9SxDv7YUpD2c0/Tz1ddXb2v70VSMwOkJcaFWH3p+47xPZJrp9uQrNnRkA2NwrrNXfFlyuA3icWmPqeOPzgOr75j2x/1uUoGzPTVIPo++Tm2pj7LiZoOmm2kKfNc3RaKQKNfYnWLDRxbl47xIlCnrk6Axd/QnqliVQveQ20V4XseCBjrm7AnOsMwDMO0b1hEZ5qMniWkPsCrGZ4mawws9b7yb5/QCX3T6YnLR1NheTWlJ7fvySXz3YMJoy2DFxOb97fm0Re5BbRwRjbd9/JmIcxg4gekl+XJDosStPU5k7PExOmtzfuF/66fybs+EZZe3A2ZzqECH/ZNXz6sok5Ov80vCxPQSZnQTR3eI2xCid+AsNsSFiqubF+cb5xPZExPPKZLg5dsINAgvDV60jcn+9416ZYFxNRxB3ZSpkJjJmwZ6kFboIJyEYjwU3xVX+3g2u7lEwaIf+OcYRn5g3ohvviYoPBqyjJu7/gt4Ovn86Lw6FcH6NJx/cKuidp2kuNixIoptRggMmxdoOhgsDioQRyUghz6hGp35NU+pDivYhPqI7XPwOd1AV3+LsYYeMPr35N9DvuNfqXaY6Co793nDqM7V20IG8smNI7F+u9AjJLjlRrEgA2TfN1LnIdl3Hl/eC/kmO+cOUz8G0K6aqeEbaEwqKw3AdDHXmpc5QF7H1uwBK/X1RM9c/VYcU2ROX/dkw1FUuUqh6bYl7QHcG6uPW2QuNeOH9RZBIZdoG+azhcEy0gCJn6DFBC3XdcVbWj28tCALvozPN57ZzQUT7WhBu+6dIh3fhbPwhBmbftuuy+axGL0KdWLW7+Xo6/CAsWF7R6i3ue96qDIffJ7P7KNja5ni+4pCc7rp9vaIJAmLbnwe3K76jiPQuMDuyTT4hXrwoIDCOZhlRiOCxaUd8zIpuraemHzZiuIzjA6ubm5dOBA85MeOnfuTJmZmS2yTwzDMEzTYBGdaTHPQjw4qlm9ruXppyhZKwtWrBNiOjwqXcWNGEbnyx0F1LNrVHDihf8WTs+mxS+uC8vcwkRIZklBHAH4t5wEIQNp464imjCws/M34W997ZOfiW1CcPfjG6xPhG1e3JjYIdsdwh8yuE1CuprlmJtfZrU2kJNJteCgXqisub69tmxfCA6LZ2SLf6MwKLLM9SJhqqDk5X/qZ2m4OunO2VXUUJzzzS1hthh6oTGTZ7tXxh6CfrbsSVUM0YULr+1CvFGvEYSlO1aud3rjt/fMVp1Ij9n2eZlFrV8T2z0L5x32ZUXlVdQxwf3ohNoeSxsDPy4xNTE2WqwYAep900ZpZeh4YAt6NSUoBUHSlV2P9/V7s+xzEKDM9/nOoh+qxUExNswa10/0QS8BTP6NbcrXbX1W9u/3NHEexzxveQ7d/8ORNHdKQ/ADFj3Ypiqow5oKgXz0Xzkueom/KPKIe4H87SeuGC0CLhDm5zy3tllBwbYOEiWWrNpAz/50HGUkxYVl96rBTAQuTO3VC1PARA9SmMbnMo+aIAiSmoqTz3lujehvWM3mQgbvMPa72ipsX2R/Me27676o9hVsC9nz6IemguM4BzFRARGQ9apR4nWfdwX65D5hf+JjozwDHF6BJlug36umizqOYl8Q8NaPBWMALP3kmIUA4BPvb7MGB6THOfYVXuz4zlnZ3dgTnfEtoGdlDaHy8rJmbysxMYk2btzAQjrDMMwRhEV0psU8CzEpUrN63bYIDX8/c/XJ9Mr6PaJ4398/2C4eqKX4wDBeXPLoR8KHVZ141dbX0e1ThtDOwvKQzCB16TMK8elgwnrlKQM9BTLZttGm50OM8WivpomwayKKz15z6kDjcm11oovtQsx1geNHcEAuZdZF8pYQYXVPZUyYMcnE3ymJMUJQwoTVJSh5edn7WRquTvSxYvthgw3DO4ZCY1gRgOwydf/USbetDdiyJ9W2iPMtl35jX9QsWtMKnf6dkoICW0tk5zN2ZBa1ntnsKpgHCwFkRp+YmU73nDuMuqYkhAmDozLTgjUT/FzDXmmJNA0rRsY3BPJc+C1o25SgFIoWRtoHZZ8rLKuiu1ZvMNofwfRtxewJtKuoXPhYQ1D9wSPvWVfa6IEE+bf8v/qcof6eSZzXi7RiPPpseyF9mlvoDJbgmJCZXr2n2HlO1LaDsQVFVhfNyKbteWXNDgq2dXB9pa3H3as2hBUGlfc3rLqB7ZfpfDUlYKKOjbbxGcEw12ovG7jGuLYd4mOc108K96hTYqoJoloX2fYdqPdF0/2iZ2oCvfKLU4Q9jRosV5HnAEkqD108KiRoJ1FXzdhIjosWtmw4Ji8WTM8WVmRvbGyol2QKEvgZG20riXYXVfjql9KKSg/+4W/ZT+HpfsWEAWK7GFtM4FzNmRwIGQtxPKiXwJ7ojB+QgQ4BfczlCymlR78mb6d49zb68LHFYnssojMMwxw5WERnWsyzUM3q7d85WWSbO8XCLXl06cEKsZx1xoie9PhlJ9EFf/zgqJhgMi2LOvHChBIZYCbvYHV5LyY/nzXauahCCjKSbBMjaVEiwQTQq72aBGI/vr7LPtweslxbzzrFdr2sDYStSWy0yLD8Lld4SDEe/ux6wUVko84a34/e25ofJlpIQcnLy97v0nA56cYk21bQTdpiDO2RIs7PjvwykTWPrFIZdEGGo028kW0AY9at//oybCWALoZ8b1BnMR6qopC0ETKt0MGkH99riex8xo7MotaFOq9My6tguRMgWr12d9iyf2Tb9k5LDApafq4hxNqY6CjR5wON/UUvpAgwJkHIQpBKWo+YgDiV7yF0mQRxbLcpfRD7jKCVLYsd56imro4ykmJp2oPvNhQTdYiX+pgm/1ZfX7eriG49OwuWxFRRXSeCC1hbNPOhd4Pb9irim7OzyBoskf0XNR9s10O/F8ixpQo2D00ISLQncM4QVALJcTHGwqAAouxpx3ShfQfNoqgMmOhBTtdqBtmvgE2khcCL35773FrjvrvsONRVSCZU4R7jgW730ScjkV5ZtzcsQK7uu7qSyb2iszPdde4wq4COAsjbDpTSRaMzhZj/5beFFBcTCOs7sHdz3Uv0Y3LRNSWe7n1pQ4iAbroveo2NuIc31IppEM7VMQ9BetszGs4JApMv3XCKCIabnntMdWTU1bGm8amgrDpkLERA4O5V62n+tGxRr0LdF+wbw5iAgJ6RyasUGIZh2josojNNxuRZKJc2YmI0S/MlNIFJBSZUS1aup7lTssRko71PMJnvBlWUguXC3Y2TSz1T9PjMNIoKEN173ggxudeFFDXTUZ0YqZYwKl7t1SQQ+xG/8dvzpg41Ls+W24Uvu80DHpPJvJJKkRV7ODKXMWHXBXSAc1xH9WHe7Or5g8jcEoVOAY4Rk28XO/LLgzYMAL7GatBFihZkKBiGNvD0R7nCD99mpSPbImxsFr64job3ThXCBdrdzON60cfb8q0rdOBL/ZsLjmuR7HzGjrqsX80W9QpwpSbF0q//vclaNPvXF4wMvub3GkLowX8QwJfMHEbzlq8NE2WQ3XnuH94TwR+XrznELvi8RyqIQ3CyCVO6JYIE+/ufzfuDQSIb2C9ZhNiVvakL0/JvjGUYX1Qx8X9f/SpkjLh96pAQ8cvLu/kXk46xBtrUewlESlPhZtO9ABws9w5utuf6BTg386YNoXMffk9c5z3FZoFcFOqenk090hKtQRW8jnvX8z8dJ8ZS1CLAagKcXxSl9aob4hJp0V70ew72d/70oSIYYwO/jSBVh+KKMPFaz65G28Xzhnrfe/iSUdYgnbrv6jP2CEvxY9xb5f1C3xcxFmhBXtluL/zTB+LcYVWLKyBnOyZbgBlCNNUHwgR0U5DAa2zEPVzeo/Us9vq6elo0YxgtWpETNk6iv2YaiiB7P6fkEUZ+23OKtACUYyH2BQFvJGyg5kJ5dR0dRPtMiOH6TgzDMAzTzmERnWm2CKFn++ABGx6Xv3jmC/rj/3NnrcjJJiYDN9fViyzA9jzBZFqW314wkjLS04ICuZyAxkVH00uWTFFkX8F+ACI0lpKr2WhyyTSKSP3yzGPp9qnRVFpZIybv+A1TlpJXezUFm1wTUVVIQkb0cZnp1u0i42pM/wyqqw8tgIdtXDtxEHVMiKYDB6s8M5ddvt5+KSitchb7QgavWnhQBjbwezZv9UgLnUq8Mtt1kUvPwlVX1SCDENcYbQvX5ZmPcunKUwbQjoJy528gs3hRozf/axv2BUU/tLFlV401ZkECiAI4ly2Vnc/YgRDy6x+OFN7XEPRq6+pFX9JRrRRgPWHPuj4grp0UtCK5hlIA37C7WLT5uVOGCFEmOT5aCM8X/7lhlZbNzkcVu0b2SYvY+1iKQhCMw4WpcEsEkfFeWkWr1+wS1hQucEpx3gD28ckrxxqzN1WLCyn4YUXOZRP60dqdRfT01WPp/pc3iuPS7S3q4Ac9pCtl9UgJFoQdlZku7HdU/22A718/Mfw6q8h7CQS5X19wnLiuuA/A7mvV2t3WjNWOibGiHdiCm5EGBdvSvTg9LVWMkbsLK4St0Z0zh9P5jxzyLNfBvRXYikjiGi+9eBTd9nxOSDY7zi3uF9ZrkBDrKdKWV9WGWIXgfgSP8pdydgvh23VvRvv65T++ED7kqmCrZ1ebrIciCbDI+yKyyV0Fh9UxJ2QsaPxNta+A/7tiDL25aZ+wX/PCdExLLz5eBAx1i57Zpw+m2OiA0/9e9qtI7tHqmAduVsZJrCpDIecOCXhWq/W0YvN6TtGLkspjw3EgmHfnucOCY+HRWJOEYRiGYRgW0ZlmgofJO88ZRsWV1SK7E8tCN+89SAcOVtJfLzuJPvrmkB+wV9aZfMhujxNM5rvhxn98KTzR5RJ9iKGYQMKb9m1jpijR9JE9KbegnNbs+Jp+PmmwNmE/vmGSqC2ZhvirCzF+BRGTQGzz4tYzHE1CqRS8SyqrRRAAWXHwUJ87eQhV19ZRUVk1fZJbQFf87WN6dNaJ4t+uzGUvX2+/QGCygXPbIy2BPn+nIKzQ5wUn9qGt+0vE/iELt6qmTogrTSl0KrGJMjYbhg5x0WHZsXJVjSzaFhcdoHOP60Uxo3rT5N+/HZzQu47ZJKJhuzjnXufy2G4dWiw7n7GjCyHoX+p5160UkEnqtx+o7VAXfdOTYoWtlPxNtQ9iVYQsyGnCFBRTxS6bb7hXUKpvp2S67/yRIgAkPYhNlghov1gFs3LNLrH9kZnpnvf5icd2CQrLV/7tY3roklF0W3SUyNzGuJ0YGyUCU49fNpoS46JE5ifGsqE9U2n2sgaxdFjPVDGum+wtcK6fvvpkWriioWio+vsmm4ak+GjndYQACKs5GVSEOI8s1vzSSvoit8Ao3mKsqKmto027i+mec4eLLOGWCAq2pXsx7pc/OL6XuGfuyCsLWquYkPc3WxAVlisPvbElzA4Gbai+3ry6ye/YqN5bEU45WFkTLDZr9Nwf1EmsrkRQB+BeoWeB68K9KRjbrWN8ROM6+h7qu0Ry71XHApet0fmjenueJ9MxIaA1eXh3unR8v6AF2sY9xZQQF013rVoflryg9j953iO9R0uLF1wnPCNB1DYVX0d2vdtez12UVAdjFlYE7m68BneuXE+LzzkkpDMMwzAMc/TBIjrTbNKSYml3cQU99WEufZpbIB6Yk+KiaOGKdUHvX9uERF0OHRMVoF7pie1ygsl8t6BtwZsXE1oxgdQm3aqAhUlcl44Nk16smJBc/b0B9Nd3vgmzGRDbChAtnj6Ubn52bZMEEVuBLGTBfr2vRPis6gVQTRNqtUgY+tV9r4TaSkgRXgr+EOllsSybIN9SxSuxjNkGzj0mn6ZCn7c9t0Zk26ve75EK+KYAA4rHwftWnaSbbBjwexDKXFm4yDaUGYefbW/wdnetJsA2o+DdYsErGxHnsqWz8xl/6OddtwXxvHaJMUbLmB+NzrQWscSKE70PetnK6EExVezSxTtsq1+nJLFyxavdSGsZG3LMgGWMPCc20V7tb9NH9KDrJg4SmaoXj+lLv2rMKNc/C3EMwXdbtijGcoxLj2v2FheOzhQCus2+xSS4uopWIitZH5Nwjq9+4lN64orRIlBrGit+99pmMfb0sIz57bnf4hwgU/dXL22g1Tl7hZDud0WE6R6JVSGuFTvXnjYorD+pY6NLrE6IjaLZT30e7HfS69vUd9DnUfT3gdc2i7Yr7x96Frgpu1oGY6XA27dzcsTjekflOcXPvVeOBba+AvA37o9e93jTMSGYpdufYZWI3qfl7wCczzU7CoPX3HZ/c1klqRYvtuCYLVlAPhtgZY+LTsnxom7DtwXlYvUMAmd47rpu2WfB36ms4cLeDMMwDHM0wyI602zgVfnof7eK4oHwPsZDMZaLQkCX1hg3nXkszZkcRQVlVSLDDA/S0pcRIHvpm/0l9L1jux7pw2HaKJjQllTAeiV0EuUqyoVMrO8P6UqvbthHEwZ1tnrkvt3oofrqL77X5CxpU8YrttUtNYH+8NbXYYXTFs7IFjYT8ruq4A1xwuX3KwUj9C+bIA9asnglfEBtXscnD+jkXI4uPanl7zbFw13PqMd1RybjbVOHUHF5gyiDDNvZymRYFS7wn1cWLn4DdkAu4fCUxm2WV9uLJ0qfZzXYIwM9OFelVTX09f4SkQF7tAlxrQFV0KusOSSC+bJiyi0UwpNsN2K11rnD6aZ/fGEsYok2O3/qkLBtReqrjfZjEu9kuxrQObmxUF9Vk+ya9DEDxQrV31KFx6raOuqbkUQ1dfUiexQCJQrzoe+hb9hEPXBSvwwxHiAEpY4lp2d1EYGAZ34ylsoqa+myCQNEBrwMGHoVhFVtGhDER4xrwbShdOfKDSH9ULeVUcek688YLLLlf/yXj0Iy6WHhggz0gtIKumhMX3EPiioOCHH1aOmrz/70ZOrVtROVVFULAd3vigiIlNIqBwEoeOdLn26sBNBXcKgWIfg3hGnT2OgKQmJlEZI81Huf2q9V4Vu2l5vPzhKrInTR1rbyREe9B5sCBliVgucBdfWDPBbXvRWv6x7cGH/kcw/OkVftDlcbNR2THuBrqGVU47RJue60QXTJ6MyQ39LPg7TUsdn0qGOiLThmShZQnw1cgR1RR6a0MizDHdf/uokDhe+5bIdIHAJHS/9mGIZhGOYQLKIzzUIV9t7bmteQcXrOMNp/sJIeungU7S4qp9r6hok0HpD3FJVTj9RE8fchAR1eioOoZ2pCWHEkhokETMT0zClbgTkIJyjgh2X3mBTJwlE2istrqHd6Ig3u1rHZ+6lO6qRIcO1pAyk2OkrYmaAvTX/wnaAArmer+hGMpI+nK8OtJYtXou9CnMASd70ga3TAnpVtmpRHKuCbMupx7pDFiN+HLzLOFybJ/7zmZGETgfEI2eI4rxByZAAGAsax3TqG/bb8DdVvWs9YTEuMFQIQzoVuC6ICuwdkbMrMd1ugBwGeRTOyxb9F63SfRqYFkYGVT7blh7zuyrq+csIA+vLbQuFhjHsdvg8xDOKYTchCm62urQ+rFwC7Cr9ZvGhrn+WGi/u2dtWc1R5yzNBFflW0x2/esxridOj5wW9iLLCdCzl2oXAvxiwErDAGwXoF4/MiCJ8WqwivzH35vswYh8BfUlEtigJC9Mc1col46MfwqQcQ0mcsDS8+iQzWmQ83vC5toFxFDtsTx3ZPoZSURProm0PWI6as7r6dkqh344qI3LzSsCKP6nlDENNmRYLXsQpyQJcOEa8AQ3AadSpUXEHRWeP6hSR92LLAI1k9pAbV8Txw0z9QBNRsqWa7t8pzpT834xgRQMZ5u2RMX2rOPd50TGrfR38/7ZgutO9gZcj39OAHrpUe6NPPA8YxZKubzjOuOWxk9HESxyoDaTgf0iLL9mxgvc6DOotEIJNFzKe5hcLCZf4LOS02jjIMwzAM03ZhEZ1pFjIrDQ/HPzl1AJ1xbDeqrK2jQCBAPVIThJCgPpSK4kMTB4mMMiyJRpZ6l5R4IRj0OUomm8x3h5wkq+KlS3DGhPTbwnK6/4cj6UBJ6CRQB8uAt+eVUnRUQ4ZhUwtz6pM6NesNWWimbFVMYOdNGxp8zUswgk0NsiwxybxqQn/rvrR08UoIH7DUUTMLP99eQGWOrGxb1m0kAn5hWbWwl0B2rF7MTM1ChUixYPk6uv6MQTTz4fdCREa5cgbtBSJon/Qk6pYSHzx3cqyTVjoA25bXDmLLfT8YEWwb+G0Ud0UQURdlpN2DPFcAXrK6AAoLkFueXROWxckT98MD+iqCWiq6MIi+BgE2Z1cR1VM9fbwtP2RFy/caV5XgeprEIbmaC31fHaeQeb1gWnZYAU6TIIe2uWTl+jBxyBZAbOpqD3XMgKClrqaQohkENazm0DPF5T5gVZpLbMNzAzL39UKJ8EU31bmQx+mVuY/M+JduOIUy/j973wGeZXW+/2QvSEgCSBhhSyABFJUhse4ish2to3VPhnY4cIGIq7W1to5atVb9/6TaKiICautoKw7cskFEdlgZhOz5v+7ny/k43/nOOe/7JUENnPu6vCTfeteZ93M/95MSbwzWq89ABQIAJkXwqTmduICqXFTx/Q17+f+dDyNxgGotoqq637j+hKACXSXQVa9x9C1TxpWwb/MLOQipm1vkfn3bmQO53yfFx1BDI9Hv3lxr9MCXVeBopyhYiloryIBCe8F6IdNrPfASioCGW6phnfBIUx8Nm1sTY/nYuraMz6OwK4LIukKZkczx6jXBdjEhJprmXTGC9lXV8jwJ253kuJgWB+9sFi+X5yM7JYqeWroxLEsAx4JXPax2RLFaU7adOn4L1T5w7l8+1D5nfBaWXK05jjo4ODg4ODi0XTgS3aFFAGmIBShU5/j/b94IV5/JvoViEQq1+jX/7zN+DZvOzHYJXLgHxJKDQ3Mg1JnqRsyLcIbNAFTIKfExVpsGbB7Pf3JZ0K5DbAQjLcxpslCxkf24jgbs5pvgRRiB8P9mTzkXL8R5mzZ4ftPPIwkUYFMvb+yTm8gkvwWGIyXwcf+RUaCOOygSC6IP/q3J8bFcyFWQ6/htjDsg1B7817pg7Qbbpl8ocE2eudkZycHxC/cK5DcId/VzUOyJTbu4V/DFVwnCg0GAOkQGtHdkhahtVxCDcpYDFJJ/Xap/XlBQ6zy5BVAQWP3eO2v3MOeH9lfdpMg22fmgberaZY+MJOuYsrO0KuI2JMYMJJdMPbkvW7iZ+o9u/p85Nirkt566+Dj6/ZtrQ4mx/h1p7qQ8Hr9wfro6FwIiSOZls/P6qp2scrUVBPYKKsbGRGkVwSDQEeS8fUEo0YbjjuyTGfY7kQRd2xpA7ILY1GUbyKQzyGCT/YfwGkdmlu0zmLePSDWfi2luRhBTF9QS/RoFpFE/AJ7pawpK6fkrRnJ/sqnAbesA27PFfGBq2/gtvC++r86tNggy2at2h60Iq84iDfOoWuwVwbRfjxnAgT+MW5HMXcLOp6y6joMNyMqRgxAIQi9aXsBzua5WQqCdRXGRUwh2QO57ZdvJgZ2XrhlF4x5eyusBU5DTa20WSdacg4ODg4ODQ9uHI9EdWgRsOrFghm3LkhUFYQotnW9hwHOyLqg+S4mPZbIA6jUs0t1i1CFSqOpM1dPYBhCbIKh6d0yhGaf059dUImTGyf3prTUBn9f3pI0gEGlhTpOFihfZX1Rew+QSjmXbGGNz/87a3bwZRf9au3M/lVXXUxdJVR1p+nmkgQIZUNBBjQkyaZbiQ6vzH/azuQ9T9WvGnWiKorGDu4QUQBOkXkV1HWfL1Dc08ndNHvPyc8xIjg9RmYKQl7Ns4M2rC5ToNt/De2WEPAtdm3Ab9+8feC5e6f+i7dqeF9rCtSf21b6PPi3IKTmDAnh77R669cyGoEe0F/mrqn4fu3CY9XsontclQt9uMWYgWwN9C/P4zWfk0AMeRQXFeSFoKbzjcc26YoRcg2LBCho/pCudeGQnT9sp9Enct6cvPo6LKYfUl5CeE+6P2m9kQrtdQizdd9ZgVvWrhBqeE5TRIDFlRXD7xFgOgqgEurh+jHlCTdzSsbQtAMHeaSf3pwZNf7lnSl6QBJa9xHWAx3aMPVZszVayFc1GQU3YneiKloq5Rx7DL3zqI54Pbx6bQ2VV9dQuMYbSE+PYCx8B0H2VWGc0sNUXAqei7fgJeKKouA1YF0eKSGp3+M2YE/344Xe+1lrjIQvnpjNy+D74nbuEnY8Iwv3hrfVhWVczx+bQ6h372JbmD/821KzZsJdJdNx3NfjuFRgTAe1AnRJ98McLaIdqYKyvxWbIwcHBwcHBoW3DkegOLQI2G8f3yeQieroUZ11RLyxaE+Jiw1KnhVepI4Yc/GLeFcMpq1NmkHDFhlZW94F8wuZGkM8mFTSUZ2h3SPkHcROiHC6tYiL+0Xe/CdsIApEW5jRt6rzU5VV1DTTt5H4ccDJtjNGHLs/vwxtaqGL9pFKbfGNln9JIAwUqhJ3BI8pxEuOiWaUrE1Y2D3dxPmKzinR70/0XG2sZ4l7dNTGPzn78QybFAa9NPyx/UJwUbUWQnLLK9tie6cE2iPNDewGBqVrLmMgfXZvwCqpEYnfj0DzguZgyD4C/f7wl+Fy9nldCXHTYOIT+Cr/lC59aFmxTyOqCr/rgbmn8mzV19dym/BT/W11Qyn2nc2oCk33wIbahU/sEY4E80c9AECYnxDI5jawWqEUxZsCqTZD26D9ePucC8DZH4dBxg6s8ixHiexhjQHjagFoVT110LJObI/tksLWTeE7INhH3V+03OkIbzwjk/mXPfBJiQ4fnhBoGd07Ipe4ZsHoKjGlrC0q5BozpOt6T5oHWGEt/yPDKwIHHucn2RQWP75JFiA62bCWvotkoFK5mYclzD4rwyr8lB2Oxhn1tRj7d8vcvQo6hZl7o1gEq2YoMOBt0PuI2yLU7BCmsjl94DrCZEb+tnhOCScUV4ffPyxpvanUdZ+akxNufLfqgbOdjC2LXN67hIB36mA24Ll3w3SvbTpwr5ugFU0fTnEWrwkQUGE9twH1csnIndW6fwOeBQKEj0R1+6NiyZQvt3asfI/1izZo1rXY+Dg4ODm0JjkR3aBGwMYiLjTaqaYTfKTbrglSC//n9S0L9f8UiHGouWbXl4GDDkB7plJrazlPdh+KhM+cvDyt4CTLnxY+3UMf8AMkDO45TcjozGQ8LEGRM7C6rpl37q5ngkFXI5dW15FGLVEt0YlMnyDTZDxhkj+wxLEMUCcVG7/XrTuCieDj+vZMHc1E8bNqS4qPpzVW7mICDL7NfGxBsoOEpDuK3tqGR/U0jISMisYRQi4jht689qS+ngvvxj1Wfs5fSViY25XsNVT+IMjwLvO5FgG4urKCpz38eQpKI+wuC7+QjO/G/1+0sZXUvVO4gNPG8js7uEEasqOSPbqPvFVSJ1K/eIXLIz0Ulj7jo64Rc9k7G+17PC8TUmXlZTPBizkR7/3BjYUi7gCITgaVPNb7qXl7C8OMvq6mn2QsPKKJBTpk8vNGW/7V6F1+X+vu68VSMlygYiiJ7aUkH+qjfop44Tt+OKUzMg/jeuKfc83u4t/Ex0SH9Q+7LAIYsFBS85G+f8JgS4rNe20CPXDAsxMoJMBHa4u/Xpucz8QulOQg/BPsmHd2NNhdV8JiH8TqlKbiQothFqSp2MQ94jaVtPbvElIEjngcKyoOcBlGL/2CDg2wLm8WXqf16ZSt5Zi/U1nMtFLl+R3ryAY9xm4J52sl96c5XV1o9+uXrF89f16+WXJcfzMyQawNgnYFAVTsPQlqFXLtDJoXF+eBYN43J4evesKeMMlMS6I4FuJbQ4N70k/uH3zOPfo51Cc4fhYBtQB+U7Xy8CqVjvs5Ks2dpoKi3LvjulW2HtinGltdXFdC4wVkhwR+0w7fX7Da2Q7yOZ/XW6p0hbXnT/eOs5+vg8H0T6Dk5A6mysqJVfq+2OiAqcnBwcDhc4Eh0hxYDm0yoNFWYiguJ9OoPNhaFbTZl1ZaDgx/4UfdBOYgNE8hQBHzE5ggEOvxR5faGTTRsPmBXALsO0YZlUgsb0XOGdQ8jnP0QndicTT2pL8XFRHEhLNE/RH+BilxH9guyDQqxo7LTQ34TpP+6Xfv5d6Culs9VvSdy/0Idgi1FFZyiLR9T9n33IiNA4H+9az+rsPz22+b4x+qesxdxKd43j0WZAYuWptR3r98RNjHPXzGCrxuk2fDe6WxdECh8qFclEn0bJFZ05I9uo4/22VwCyaF1YCNgRHFYkcWBscCU8YLnyKrodvEcYEGdgHMe/zDsc9xG3t3QLB/8qOioEAKdlIwV05iiFjEEdONpkPDKTudzAQEpyCc//VCQVoG6ASkc6PP6Hoh2kNO1DQ38HHBeorCvzn9dPCv8X/e+CJx5Edp4fVNhwK5GfBfe7aj5Io/VqnpWp0QW8wDGr6KKmkM6u0Q3V9iKTM6dnEdEq0LIR7Vt4rvoM+pcgbakyz4T/cNGguOcUpPi6YZ/fmUMvMsBNDkoA49u1L944M31vjIv5Oev61f/Wb+b7pqUS7tLq7nvq7UBftQ/EKD1C7l2x7eF5dxfBSkMshfX9dBb69m7HEE2XTFzVpWf1C/st736a21dA/cZW/BOzF3rdpX5Juejo6Poy63FRgs73CdkHZr84r2y7cS48Zf/buT29rTSr+H1jraKYIM6jsKObs5rq2hg1zRtQMjB4YcIKNBBoI+4bDalZoVmbEaCghUf0sqFT1Bdnd2ey8HBweFQgyPRHVoMbFa+KC0O8xM0FRcC0YRiZKZCa83xgHQ4fOFX3dctPZnVoGIjBQsXKNB1pBQ2XVBFQ2Wsa8PsdfvqyhAiyS/RCVUVNprY1D0j/bZsG3HtSf14s45NKchUk4pZtlyAFQ02r1Cm+yFq8N2lG/bSwi+3h21235NINS9PURQwO++Jj3z7+jbX0kD3nL2KCQo1o3ksChQlm3ZKX9+FTzF+3XjGAP5317REiouObvJl15OOYpwDkWGzqlE3+iCFzju2B6e8q4rgqSf34/aQlhz2Mw6tDC8CRs6uMGW8gGi5a9FqGtQ1LRjo0qElPvi6Qo3ymHLruEFUVlXLFirqmCIXMVQ9xQGZREyJj6Vh2elUVVvPbRn2HbZ+iKB5304pwX4tMl/E2Gb7nlDKgyS7f8pgmji0K904ZoDVfx3npJJg4n1cmwgU+PFZl787d9EqDl7aCifqlMjo88guQJFKZCEcytklurnCVmQSpCTmjF9V1HCAWwS35baJf786bTQ/O7n/4X3cUz8kuArM66r6WjcH4bdmv7qSfjo8OxgEwByLLBIb5DlY57Ee8tm6Rvp8UzG9+tUObW0AjP+/O3eo74Ki8jOA/ZI8nqikuW28QUFlNTPO73y7rqCUi64is9RklyPb+XiR8ygwfM3/W6O1sMNxUYTY6/7I4zSAcUgOwGAth7UMxkiR4Ye9CP7DdVXW1HP/v1RRqYu2CkGEg0NbAwj0jOzAerY5KC3Y1Krn4+Dg4NBW4Eh0hxYDm+kuaUk0nYsyRgUX3V4pmqpap7kekA6HN7zIEFndp26kbMCmbFh2B23xMQCbw7KqOl+FOUPPty5IEKjp4MJjWBBtsg8rcIJEzG8rqqBb5ocW1YT6a0zuEdbrSoyPYXuCkooaLqZq8jIWpBoU5l6e8pH4+jbX0kD3nM1FH0E096fLn/3Eu+jjhr1067iBNGdCLs1ZtFprYaEWPoVli7B3QZFQqGO9xjn40HrdG91G/8zBAQsQeeMOv2b4sLd1D+W2Ar/jBogXG9GC4ng2tMQH31SoUYwp+f06EjVS2JgiA4QRgocyjFkcTWMcbGSg2p4wJIvuXrQmzBbi7il51DMzJSQDBe0Z9wUFA3GvdLUdbhgzgM5/8qMDxZxfWcE+z5ntEqz+67ePG+TLn9wrOKgSewiMiHP1u7YJXP9gmt1UUBnnbyIhD4XsEh1x7RUYAjmZGBvD46mp/QqbLzEPxMZE0e2v+CPBdXOz17wu2gjIeDy/G/7xZQjx7IVO7RKsHusyUPsAMNUUQrsB2YvsOD+FZ2FrZCpAjnPHnAkynW1XLDZE+PuVqcdz8E98n4v3XhJevFdk5pRW1gTECU1BRlvwMT0lPqhWtwbT+ndkuyZTbQp8F8dFdotf2DLh+khe5gg4BLNR+nY0tmM/Y7eDg4ODg4PDoQNHoju0GNh43/jSV/SPq0fS3Mm5VFJRR7X10JrboVt0YiGtbuIdHGzwIkN06j6QyCYvVBmq3ZAKbA6RRmzbLKqq8ZQmv9BIN13oG3Mm5vLvbi+uoJvnL9emYY/bti8sK0T+jUXLC+jLLcWsxoOHqVff7n9Ee1Z63bYgUATMRjD78fWNJOjh9ZzljfXMsTm0taiSN9Yrtu/j4N4x2elMtHiTk3XUvUNisPApLHOEAk1V7Kr2LkjlNmXVAOLYaGOREt44Fz9kj8MPA2gzfogWE2nUEh98r0KN8AxGdosNXPQ7NjSIbcziaMpWgUq2W4ck7gdDsztwMV9cJ47XIz2JEuJiuPjm/uo6qqtvYCIZwQYRAJu3bHOI5QSCTcjwOPcvH4Yp5S8f3ZstKbz6snw9qs+0sOCyKZXV7BP1+XmNJyAnEQQNKFjr6K01u61Bv0Mlu0RHXPsJDCGYq1qnHJudTmnJceyHj+wtzNnvf1PI9xDzra52iI4EV7N74GMPCzOvcxJAoFyeS3E9qHdhzqDIpIzkeHr7VyeGrANM6xQ/6wBY0NkC1GJtgXmrtr6RszVgF6e2N8z3Jisk1YYI/y8oqQrpm3hO6JtqgfAD15niO/iI9RbU6re+ssLYL0QQorymLiQgqALEvV9EkgknPzMULbbBa+x2cHBwcHBwOHTgSHSHFgMLzfOGZ1NZdT39pinNevF1o6nKw2cYm2UZgpRzJLqDX6zfWUoNcUm0+Lp82rmvijdH2NwB2IyDKAZpAkWR8EyFfz9UjaryERu67CbFZKQEvZdSVVY+QQWGtu616UL/YL9uSXElNoFIfTepLecuXkOLZ+TTrCb1o8lbHarRm8fmWM9BZIUgnXr8kK68mRYFV00Es00ti3NP8iDBTEShifTC8fF8dcXsULQN45AXeZgUH0P//XovHd8nk4+D/+CH74dgA8ECuw4vP+jmqEybG3BwaB4EGaXzWPYD03iBZy/8wP9+5UiuIzLpqK700L/W0eKVu4KfQ+aHKevDqw3Jyk4VeB3vV9XUW+0YUuJjqUNyXEg/s2ZxNKlkQa7de9aQYGCyW2IsF95EIOuXkopXHAfZMnIATJDc8IrHd8pr6lnZKoo4C5UsSFWvwKYIJtgU9LDdQaB/9sRcLhjqJ/sEEGO219iN8VEoWGVPa52aFr7vsK0R2SXPXT6C2jJU4jrRx3ivWqe8/NlWOm3gEfT7N9eGENiC7PUK/pqyzzAP3/CPrzjQ43VOpjEYz94WDLljQi5/B78RKKJaw+OIaf7yQ77iM/heYXlgbSOPUYmx0ZzpIAI14jxuGZtDSXGx3MauP6U/3TFuEKXEx9Ds1wKFRr1siPAbn24pDuk78689PsTGqqXAeuv3PzmKx42y6jq6e1IeBwHQf2RyHuNypLZ5zc2Ek+8xbPL+fuUIDt4U7q+xjq+6oJuDg4ODg4PDoQlHoju0GFjAgnyCTSQW49i8YvG+fGuhNUWzuq4+jCREoUco2xwc/OCsP39I0QnJwY3M81eMpAuf+ojJCqQdP/rO1yFKXrS7aSf1pS+2hG54sDGCIgobOlmRblMryps3G/mmKp/EBhzKOhuh9Z/1e8IKsV2Z35uPA2WaCbh2kAhQixXsq+KNvM5rFkq+O+NiPEk1ANdy4pGdWKl18fG9rJYQJhJcBBKaa2mgqhyFYnFUn0z2qK2srecAhSDcQEhB/Q3Ag9lmSfPmqp1MxPfKTKaPNxWx9YXOCsBGsOmAz4MYNVn7eJG2zcmycGgebCn+fmwUTOMFXsO4dNeiUPKKrT4mD6Zf/PhIKq2s4+K2n2wuoktH9+LAX4g9Uf+OHOSzFVKUlZ1LNQFCvI/2NoNt18LJP7wOAl3tZ15KWYxFuG8gTnOyUoOvY3yDn7OOsFshZcuIMc5PsU6okv+3eQ/dOyXggSzU5YJoR+YJiEJ8Bwpak4IevvWw3cF3uAbFiX0pIS6a2ifE0Webi4LjpKxkBzokx/MYg0wXvzUU1AwBVU2LNZD4WzfPtEXIxLVfAlRYp9w2fzldd9qRQUGGDPH3zWfog7/ieaFNyIFzQcTe/FKgdgUyJvzOQeoYjGd7dHYHrbUI2vzrKwvouJ4ZNPmxD0J+E3OAbk7B/AB4tSdcG0IHqg88+jeCuB98Uxic29ft3M/3YJZSaBge53dMGMRzMIpoygEp2YbINM+pwhc/8Jrj0I/9+JlHapvXnMA03+NG/T3GemLWhFy667VVoUXY+2XS7Il5dO+S1b7PwcHBwcHBwaFtw5HoDi0GFrDxsdFMVAFX/agPK4o+21Ji8CvuSLMnDKKi8mq65G+fBhfyIArgr+rsCRyaA2xsfvvGGlZLgVCFb/Wl+X1oaBNZgnaGjREIKp39Br4PRZTY0GHzB1WSTq0ob968yDdV+STUiFef2Idmj8+luYtDfbjRP6ad0o+VibrjCVLchpSEuOBnTV6zQG1DA00/uZ+VVFMVhjZC2kSCy4EE+IfbUrdt/V+cA54LCIU7X12pTUtHMA4WNFC04rjimCo5qarzBUEjSEGhqCyqqOEMBpP6PistKYwE4XFu4iAmYTprSAI/pK3fII5Dy9DcYrd+yB60aZVAF+PN7QtW0G/PGUp3LTzgJS6IQNlLHwWAd+yrpIfnbwixsVDbi6zsZKuqxFhWoIsxDeeHAsQiq0SQfyDyemUkB69RVhMj2O1HJataC1VU19Hl+X3o6h/1ZVU6lN8IFiBQ8OC/19O8K0bSHOm+eBXrRFYRzgUe0n9b+m2YQhlkdGa7eLr/jbV045gcLhJoUtALf3O5BgXu5awJg6hTaiKTpAi0mqwvrsjvQ0O6pxFy5tQisjL5iN8EcWhSsJpsY9oiPt1URF07B2yrZFI0EgIU1ik5XdPYkseUaYXXa+oawsZbU+aB6CNQN4u+Y1KSBwJbeSHnpI7BB74b3i7w7N9es4vV1DLwXXVOUYukIpsjWqopJP+mIOwx36k2bWhXOJq8psF9hTo9vJD2XrZdGjc4K8y+BcD5zLtiBBcVVd/DvUGB3O86MOm3wLNf2ALTfI8X6u9xVFQU3TlhEAckkXUL6y5YvOzdX037Kqrp9EFduOaFGFMdHA4m1qxZ871+38HBweFwhyPRHVoF2DhFcXGfABn+0Ftf87+xEAepDr/i3aUBxQ02jRMfeZ+O6ZlOi2bk04Y9Zawk7Zae5IqKOjQbaDvnj+hJt72yQpsCLjaFtqK2ojifvPkTpJZQK3ZICqRmB9VtHuSbTvmE8/jDv79mNdjzV4wIKRwJlWPX1ER6bXq+drOITeDba3dbszwEueqlZN61r5rSU+Jo/GA7qaYqDH9jIEUQBNOpZUF6i3ukszQAgYD77Kf/i3NitZiGcEPRM2SzIM1dVpTpvNNVUlzcT0EKwu8ex+tYUROmTgve734d6d11u0K8Y/HbIA4xzuE5dj4g0I2ItG1NBZ4DtXqxWz9kDzzBTYQgyBmQMTJxplMqw77ij29/HfY7OpLfS9kJS5kz87qEkFFQWZr6uk1JLJPAsoUGxs9ZCuEnCEEUE0Wb3lJcEewzfF5pSdZinbPGD+J+9ft/r9cS7aCtbj5jIC1esZPOPaYHRXvYwqkKe1xfcUVtcJxAMO0BgxoaY8zdk3I5YAHit6SyhjMJkMWyasc+fh5Aj/Rk9oFHMAFEp1dNibaMS/72CWeF6azR/BKgmDOg+kefsGFPWXVYQVpTEEb0ERSPBsR8HhsVRTf8eADNHBvNXuIoXPr6yp00d9FqLk6LwKmYv+QxWMxfCOrcOnYgt2NkSKAfvPDxFl6D6J6pOqfIgA8+zgsZFluLKzm7Q52fkO3pp5gt0Dk1wRqEwGeffj+QhSH/Ju4BjvvYfzaEEOijm9TuEBNgbrWNhUJ8gHaPYMKVJ/Th433WlC0SaWAy9D5FTpqrQLsziQCQ1WazriKK4naNa8R9QlvOzkjh3+zXuX1I+3ZwOBio3Id+HUU/+9nPWuX3aqsD+3YHBwcHh8jgSHSHFgMLSig8oZg7JacT1Ut7UyzEQQDc/3r4ZhSLUmy0sRmCPQTIgnsXr2mWSsXBwUvJKG8YTRYFUG6qBKeqVpQ3f37INxuRjd9G0TTVHuWkIzux3YAO2LCtKygNIxGA/CYvVFGgDsoxmwoSqlBhadAzMzlQ/DJJT6rJMJEiUH6rZDPuGdT8IAlMfsbYcP/zswK+rjmT8jz7v+2+43UQW2XBjS+FPMdBWalWdb44R9VXVxc4QCr3pfm9aPq8cHU6xjNhrWM7f7WQXmxMNH29u4yfA8iZ0qoamjs5j9WXUNc2V4F3KKO5XuaiwLAXaRep97xM9nz8bZHv39YVwkQ9gmHZ6UZypzkFZiMho0QgRw36nNDk/wz7Cpy3II6C46dhHBY2KyCpcU34nemn9KfC8kCQ3YTtJZVcwNREDuJ41zep5lEDoV5RA6v3NyU+li2/ZM91WMGIcQKfec90rK/30vaSKurVMYVJUXHdGLfuWLCCA6TB+9S/I1v0DO+dwWRiXGw0iwY+1Kh9MVa2dWCuue2VlfSbc0LXcX7aHOZKWJB5KXkxLs5oIrKRzbW1uIKJY1sfuaXRrFbHXIjMJdEOUOPngKd9IGCpm+8A9FG8huKW9UO70uRH3zfOc7ZxRNyfmJhobdDU655wTYGm9l1RXe/5WZV4RzttlxjLGSRYe2B9IVstirZqG2tE8Az3z2bLZBqz/IzjfovCm4Dfu3NiLp+nen7olzZwwfGKwHnr7oGbkx0ONmor9hNRIx11wc3Uqbe9ppENBSs+pJULn6C6ugOFuB0cHBwc/MOR6A4tgqzY/cvPj6FfnjaAKCp082orTIYNF4obYiONhXpLVCoOhzds7UzdMOo2pKL4XiSqVD+FH6GylpWcJp9dsYEHbEomHBtEMyyTZPUzSFcULLzo6Y+ZKH7g3KGc0g0FmaqCxLXC8uD8JwP+8cu3ltCFw7NZpeoX6kbSpq6Ggk0EMWxEBjbuuC4vtZuf+24qPudFRsQ2KVjVZ6AGDlISYunTzcVaAl1W6OqepTh/cS/mLdtMR/XoQL/71zqtWvWnTyzjwIYLMLaeZcCWwvKgZzcCHja0RFmoemKbfttYCBP2Tk2WSyZACX0wIJNaICxBMm0tqmCSGu0bhCGsT0BGC1LRNn6KcRjXFxsdzff9iNQEznxJiLVnocCrGES6l0IZQLHOz7eUhGTr2MYdQe6lxMcGx2o/XvDqWuUOjd2GsBDDWA1iVpwHPLtVAh1k7aEAZFZs2lvO/45kvEIb2lUax3YiXh7hGA8RbIZ1G+7rYxcOs/42ApC3jxtoDLTPluYo+dnLViwiYCJDnqeQgWUrfOtnHDEFqEXBdBNA5ov2jcK9Nog5UFwn7inuDbL4bj1zYMhaxG8gQMz/8Fv3I2ZQf0cdx0Vh+GHZHfhcQKrHR0dxYdR31u7xLApvA2Z4NXMMbaqi1h58QLAVwRs3Dzt832jXOZsysgc0+/ulBZta9XwcHBwcDjc4Et2h2VBJM5BP8D2FSggbf5GiLitkZIWdUICVV9fTjWfk0HlPfNRsZZ2DgxfpId5H24SaCZCLU2IjVVZdxwSRTTUtb/78FH6ULTlAunoROSAHvLyusYFDyjmskMQmEMpGsflla4LyGnprzW4uOKYWQMOGESp1+J+2lrLZSx0OOxxcs1fGADa3cv/XqdO87jsI7j1NBdtU4NqNVjj9OrL/tJffOOh52EXgc6P7ZtK/1+zW2jSYfkecv7gXpiKIKvHgAoyt42WuFr20tYmWes8jMGfKBsHr7bwKYW7YS9ec1Nd6DFiJCIVka0FLao0bSHnd07jeBNTxlB/wiH703Q1cyNhPgEuMw5uLyuna//ucXpl6PP11aaAPeBGnIvBoAtYeeF5dUhPZsgbjOhPbX+/lGhS7S6t4HIR3sbwGiaZNHAhADQgxVnsF21QveD/BA9XOatpJ/fg8EAA91LJLdEEGL7Bnf2Yy/XXpxmCmFbzp5aAzbP+S4mK4yDY+j2AE4PW8cI+Hdu9At76yUvs+nh1s1XS/5XdNimd431mDqXP7hLB1rmleN6mvdccy2SphHGlsbAyOH7BO9OPDj2ATAln4u6CkitcLOG9dzRivQIBo/7iHfsQM8u+o47gc8JILw4siqh9tLAquz0xF4W2AbQ2EA+p5Qszgdd+c0MfBwcHBwcHBkegOzYa6aVy3q5ROGXAExcZG0dST+1IDBYr4JUsKGR1xmJYUy97MMmkZafq8gwM2yTZgYwySFPYb8B1/4coR1LF9Is1ZGFqcEmnNuqJbAvLmz2/hR7koJ4oJ2ornQV3nZ3MGz1ahbBQkA3uBN23cERDQeSwLnJbT2WgZ0xx4kWfwk8c98ZMxIPq/SWUMosJ230GmmdSMIDRAmMHXOMSeon9HVuOVVNTQucd0D3sGpnOBCu7GMwawzzogUt9BmgiP+E17y9jqBmn2SEFHGxo/uEvwXgh1ru2eAC7AGIpIskZksgokHEhbEHToH6ZCg63hPQ9iB20ERI9MzggFJYgzFPGtb2hkT2WQWrCmKK+CJVMcITFib1k1/f3KEfT+NwcCZQJo42jrOE5rtQsrqSWRkHLwT9xrrwCXICjRR4G4mGi+56KQJxBSoLd/R7r4+F5B4lkO0MvAuUDRLj8v/B/kPjyaoT69XWPhIM6/oaGR+ygsXTAOI5hq8k7WecF7jX8ympv905ZgKjjrhW7pyTRnYh7d+doqtsDh4tuLVmmLhcKyTLQ3r0AYiO0Nu2HyZQYIZFOx1/LqWk+7EbSfJcsLwoqDYr7R1RiJJIvGVB8DbfSeKYOpsvZAMVb85vNXjKS7F63S1iVAe8e//7V6F99X/FsX8I4koCjavx8xg/o76jhuCrSrRVTF2gcBvS1FFSwcwHgJSzQQ5aZ2Z7qXm/aU8b28fUEg8Ka7b4Cbhx0cHBwcHA5vfO8k+qOPPkoPPPAA7dy5k4YOHUoPP/wwDR8+3Pj5kpISuu2222j+/PlUVFREPXv2pIceeojOPPPM7/S8HUI3jVjMju7bie5ZvJouze9D0+d9zotbFNTqkZFMsxau5E0ylB6yGn3XvkrqkpoQlkbpCvM4+MGLV48gikthsimKGtkWSOdji9ez0hLpktEB/2oQnOcM604z54cWIQWweYKqS6fGUjd/6mZMbOpQBAwkwt7yQAq2UJbxZtFS8OvOCblaUsWkxrZZFJx9dDeror61+5gXeYaCrAgkrPdBZODcvOxhBDGpK7i5e3+VkRiF/cQR7ROYXMM9hc8p/MZBRE557AO+XyqRoSMVReBi3a79lJ2RTHnd0tgyAJt3+OOineC31hTsp4ffDS0KCSLw7il5tGVvRfCave6JgAswRmbrYyKr1ILDcrFb2CJlpiS0mjoYVgNQSga9fBNjWaEulJM9M5JpS1E5E193LVplLEAJawP5nOX3EBRrLZhILd0cvnNfJau8xb22BRYFQQniD4V3n710OFU2jU+6gsMYQ7ukJdK5j38YDHYsvi6f7liwMiQggf501+RcytAoeIOFiOd9bs30gHIabeTMwVmsfhVjK+YC+VgqoYasF9h4eCmhMUa8/asTwwprqmN7307hliFtDaaCs37RPSOZ7pqUR1W19Wzvpc6ZshpYtDc/gTBYp3kF4q/I70NfbSvhYJZo4yu2l1BqUry23oeYJw7UAtirL0Q7OS8kW6Q5WTQ4DgLImwsrQoqPzn1tFV194oFsFbSnC5/6iB48dyjfx7KaOg7KwY//va/30Mg+GXRBUwFUXYFbEfD2W8wa14LAJCx10M5VezoZHZLiwn5HHcf9BNq9bOHuW7LGWl9Ftc1hu5iYaA7ewJJGFHsXNnmXPfOJE/o4ODg4ODg4fP8k+osvvki/+tWv6PHHH6cRI0YwGT5mzBhat24dde4cviGsqamh008/nd976aWXqFu3brR582bq0MGe4utwcCCTZtiE/u7NtbzZOX9Ez+Dr2IDCpxQbk8x28fTQW+vDFrzH9MpgtXprpc87HD746V+W0XVjh3BKNwieRy7AJjoqTAk27ZT+7HfbqV08vTY9P+gxalKxgjSZelK/MPWbbhMpNmNQO0Ildeerocp2eaMte2Hr7I0qa8KL/NjU2FBMmmxAZi1cxe/L6dAt7WM2JR6KkpmUm+J4AaWqfdrBJtv0fOT7tmt/lbHgJs7PRMqBdMBzEueNTbMXkaEWAtVt3sVz7tNEguFe/WfdHlq0YofWouP2V1aw6g3wYx0h4AKMFJGdkomsUq1y5IyNN64/Qet/3BKAMDfZDSBwBis02WLGdJ5RFEXPXzGCCxLLBf9as13oSC1BUupIK6iFY2OirCpPQW79fdlmVpZf+NQyvibYIQnosmaeufS4IHmF4CeIcg5IVNTQ/so6Sk6IYfU4F0U2kKTov59pAgDCakNkesiWHvL4ce1J/ViZXlvXEHLPMd7BogtjLH7bSwmt1pBYt7OUrXGioqKC57L6rjOoLUMlZZvTLkW9AjwXU9AZbQse+QlxMTwXIrAqj/fCrgTWPuK+qwEetT4JivgiI2T5thJ66K0DxWHvm5LHgRuVIJfnCS87M6jgn/1gU3AtEEkWjdxmOPCv+Z6wvxFA+6xpaAzLvkCbnTsplzbsKefzltuzGvBWfdnV9os1D7BsYyF1bhrbkA3SLS2RHr1gGE2b93nI7+LYGFfVcVAdx/0Elf3YwnnZrsi2ObgeESSBrY3aplEsVR6b3Dzs4ODg4OBw+OJ7JdEffPBBuvLKK+nSSy/lv0GmL168mJ5++mmaOXNm2OfxOtTnH3zwAcXFBRYwvXoFNjwO3z2wqBakmVCOYFMCVd2CqaPDUnB1foZY8M59bTUrhFsrfd7h8MGDPxlKOdmBIlqskpz3BV31oz50/Wn9ubAk2mP7hFhWPQba1IHiUxubCp+ZAJJFpxzUIah2xCbMoprzUo9DHS/DS419w5gBWpIcwHdgT6IqytBnoeKOtI+ZyHz0V5DSs15dyeQYiuiZlIC4HrXgn5oxAE9cfFZ9Pl7ktVADbt5bTp9vLg4eQ5dNAD9dwA+RIaxzBEybd1GADpY6IAlAJsCWQ3edANqJUL3brAhkVacLMIbCj52SX69qtcDwdw20BVNbkc8TRB7mSxS4Q1vEuAKg36lKV5v1hA0yqYV+B8sVG2k1d9Fq+t1PhmpVnijGh9+IiiIm/gd2TQuSdsdmp7OS2+RDDIU5SE113CovqaR7Fq/xXUy2rLrWaimHgqmfNnlrywSeIPXxH+pHXPTspyHHm3pyP1aoApFYAm0rqqBb5kO1HG4t05bn4vQOaSGkbHPGK9QrQIFL3EN419uwqbCCpj7/edBWq6a+gUorzfO1n/okunUqCGKZQFeD4AWlVVTRZJ9mAj4nrwX8ZtHIsI1lyKSSg9im/or3ERAYOziL7l68JjiGBLNDS6uC904dSzAnYyxJjI3mQqyDu6fR8F4ZtGhFgZJplUmzJ+bSYxcMo6lNRLroB7pAojqO+wkq+1Gr432/tiuRzBNuHj742LJlC+3dq38efrFmzZpWOx8HBwcHB4cfBIkOVflnn31Gt9xyS/C16OhoOu200+jDDz/UfmfhwoU0atQomjZtGr366qvUqVMnuuCCC+jmm2+mmJgDSmaHj9gGOwABAABJREFU7wZYmN45MZfJM1E89M8XDqP91bX06DsbwshE1c9QAJuTW87MYcLyUCuu5XBw8at/fEXRCckh1gxQkMkqsgVTj6femhT5dgn24Q8pvABTOAGRpRV+CFm0b5t6HEXwYDMi+oDtN1HM8iophVsHWCXo0r/nvLbKmuqswkbm/2f9nqAPrFrEFKpyWXmG6wHhpiOb8AznTh7Mnrg6dZqNvAYxgeuESg9K0rmL1xiPgfR2cX+9iIySyhpWqgt1KmDbvOP+wNoBxB9+W1XUqeQLiE+cN1LPhZLQZOXhAozhMKme5XvlFSyTn5HwKfdboM4P/JLZsHnxe55QRdsCShiublKLgo4fxHYwILS8SHVBagmiMSY6yt7uN+ylsqo6OiL1wGsqCbdjXxUVV9SGFCSFDRey00BaNhqKSMZFR9EzlxzHJDfGLaw5dGpcmw0GlLW/fXOdUbU6Z2Iuk302Ak8NqqKQ+tg/vRckWtXMF9hAQB2vrmm2F1fQzfOXG8/ltIGBoHBbw0ufbaOPth2Yd5s7XiHDQKwd/Wbo4NnD2gvPXmQCmfognssD5w6lqpp6bX0S3TpV7numYC6CLH7PFefiJ4tGhW2+Qn96bUY+zVm4ivstaquY+2sh3TpuEL18zSh64F/rwmrCnMh1WczBcxFo6NI+ke57Y40m06qQSfbxQ7py5h8CaJF4lNuCyjg23h+UJQ02Gohn5td2xW9BZDcPfzcEek7OQKqsDNjdtRS11QdEEA4ODg4ODm2aREeEub6+no44InTDgL/Xrl2r/c7GjRvpnXfeoQsvvJCWLFlCGzZsoKlTp1JtbS3Nnj1b+53q6mr+T6C0tLSVr+TwRlRT2mSPjCT2RY2Pjab6hsAi2q/yD6isradBXdO+gzN2aIvw6seq5YHXZhQbQ2w0jYpoKU3fj9KRz8mHsgyEMogsm3p8Z2mVleQNSUFvJC5aJqwAVA9SqDxN6d/VdfZUZxk2Mh82BUKlp7NjAPEkyDUvm5XSyppgtoCqTrORePgMAgU4x/OHZ/s+hheRUV3bwL8Jj1TRVrxSzRGsABkAf3sUkvWjpAdxCzsPfAcEfMCeI5Y9WvdV1gQtiNryxv1gzcWqt62qQvV6xr07ptA/rh4V5lMu0BJFdySFA71sjmRCsX+ndhy8NgWUoDLVFgWNYDybMymXPvqmiL+HOV4Q2yaYyCqbHz0KAL6zdg+rfrF+0BWRhKr14tG9g+MbgkqR2mBAoWxT+UMtLzzmdUUlAZCvssUPLMTU8VYe/xC8VS2BOFOmsMJ6Lm21Hz9wzhCqiU70lbllAu7P9uJAgWbAb4aO7dmb+uBt4wb6XqfKfc8UzIUS3JRRoZ4r7hHGHT9FyWXYxjK0PazH7z9rMP97c5GdgPx2bznNW7Y5THX/nhSMAnTBcxFouO3MgZ7ZMwh8+VlniHEc65+CkiqaOKQrjwXyM8J9gbc8aijV1wcyVEwQz8yv7YrXPNGnYwrbfFXU1PHx5awfh9ZXkINAH3HZbErNan62ecGKD2nlwieors4eoHZwcHBwcGhzhUUjQUNDA/uhP/HEE6w8P+aYY2j79u1cmNREot933300Z86c7/xcDxdAXfJV0+bgzLwudM+SNZ4puDoSCmSVW5Q6mOCnH5usGRLjorWq6s82F7OHOt6VN2og0Kef3I8ubUrT96N0BPwqy0yFPgXgkSt8XNXftFnByAUHxYYTJKwfwsmLKBRkPjb2UGHBpqSsKkD0QoHql1wT16Mj2wEU5DSp0/yQ1/Lm2c8xbHYgaAcgRlSrBj/qSPxeTUMD7S6tYksKBBlsSnqhotSPfwcsiNoyDuZcLKueI7V86ZqWSGlZ8S0mwVVEWjgQBL4fEg7/3ldVZ/WKhq2S3wwO9TzENa8pKKW/XXoce1NDIf7i1SOt16sjq3T3AGMYSHkUIpSLitbWN9IcpagqELjOKD5PWNiIfh4JmV/mYbUB6yXVnsVGasqFFGVvdXls190PjLFe599W+zHPV6ktqyMg7LMETBY5umKYumdv64MXS2S9DmK+QXsFUIcAwZYeGcnaeUWcK/zt1YCReq5oG7hfcpaYaEfrCkpDsqUiGcsQNH9n7W5atHyHVqyizlOm7FDZysxmcVJWXe/LwqZgX1XQCsYrCAm7NwTmvy0sp5vOGEjX19VzXSVktfVIT+bMMHiW22oQiPEyEtsVr7UAfi+SIOThiNZWkCdldKWM7AHN/n5pwaZWOQ8HBwcHB4cfDInesWNHJsJ37doV8jr+7tKli/Y7WVlZ7IUuW7cMHDiQdu7cyfYw8fHhiyXYxaB4qaya6dGjR6tey+EM3ghMQVGnlTQ2r4tRaS5DJaGwQE2Kj2FfSfGbDg7N6ccy0YqNFFRW8A6HT7VqkcI+vRTFqs1LJLUyCBUT0a2q3WTyGfYw2BTDrkT9vryZ8yLbxTniGCjWiTRxsclGod6nLcW0xGZYpBzv3h/oUyaUV9f6Igpxzjj/568YSXcpRBfIBRtkMsmPh7VJZVxdZ9+woxbD69efwAUOJx+VRQu+LPA8hs0OBJ6uEx5eyn/LyvZO7RNYHfueB9lZUV1P/Tq3YxsNkINeSnq/AY22iu9rLvZj+dISEtz0vCItHAgFPDISEFCRiXSZhBP/LtjnjwAEvNqdTHBhDBMBRhCCu0urg+3/7TW7je3eRFap90ANAiKLxs95Igj16x8PYCK/vLremn2jI689sxEyU/h5sk97z3RrO7H5mdu8wDHOQhEP4cGiGfnsPY17rRLHh2o/xvWDhIZnOVT9aG8qAYk+JKvP1YwitE8ERITvOhBSLDY+JkSMYeuDXsBaQLRXec5F4EQHca6vThvNf29pUoKrhTtF28D9ULPEsBbGehqFhpszlqHANghonCsCVX5U/KY1OwISdq33gQCD11of4wu8673IZ9g9IQCgC5gs+7aIHnv3gE2kKcCCoDVqxTz5v28isl2x3VtdcE3UQIEyHgT/oTBHtxRQoDsFuYODg4PD4YDvjUQH4Q0l+dtvv02TJ08OKs3x9/Tp07XfGT16NM2bN48/B/90YP369Uyu6wh0ICEhgf9zOHjonpHMypntJQHCDotz02Zb+BkK4HMgmZBaiuJlULzBy9G0iXA4POG3H8NWCJtcYd0hNq8yYSVU1diYP7V0o3GTqbOGkdVuOvIZm2AQPNhwyZtmeTMnF+TVHRfnDaJF9/sgrG3p0zefkUPH9wkU50Qf8lK9pyXF+yIKcc6PXDAsjEAHPrSksetIa9wL+Khjsy8XMzuZfVjjjSpjkCMmAh737fVVO/l54VzunjyYX5eJdBNparIDKSyvCbl/Qtke3Lx7KA5BFIFk2FtWzYRGSrx9usWxW6J8/qHj+5yLvSxfdPAiwdE+ymvqjc9rf1VNxIrp7MwU+v1PjqLichGYi6OYaGJrBpy/GNOE1YKfQLVXBodMcCFgh2sBMQmiWybXnvjfRm73DT4KZwqodlSqKh5EuF+bpMLyarpcKuxpyr7RkflewbssZCPwOEPWdiL8zLmItUzexsXQzn2VbEnz2abisPuxubCcgyPyfcM4haDkhU99FCTScU2HYj82Xf89UwZTz8yUkGCHSo6KcRf3BgTz7QtW8nP0U2ga/uo28tc0D4t1qi6Lw5aJhHONjopiGx+2UjOQ3YBu3n3PMyvJPpbBYkj0o0hU/Lq+58cGpbExQFrLRVfl44i1vnzPTBkwmN/v0HjUi79/edqRIbVucK/xO1hv7a+q4wCNWPc9/M7XbI0W6T5Cd2/V2gfq89qwu4ye/WDTITFHtxZAoDsFuYODg4PDoYzv1c4FapaLL76Yjj32WBo+fDg99NBDVF5eTpdeeim/f9FFF1G3bt04fRS49tpr6ZFHHqHrr7+eZsyYQV9//TXde++9dN11132fl+HQ5L0MElws3hdMHR2Wmo1F9Y1jcpgg+OfVo1hlCx9g+B+u2L6Pv3d0dgf2isQmxyk7HCIB2tebq3ZZiW9ZlWhTPtoyKqB2EypC3SYYvqSvX3cCb+BVEgYbRZBvd03MpdsVT2N5cztpaFft72OjqIPwSQegWo8qqmC/YR15JD4Lsn13WTUfE57fqqpTVsvyf0lxWvJo+bYSujy/T1gau4lcg7pNFCKVP4tiZs1RiqmkAMh8FIxjJfnQgHVLdkYyk/a2wma693TEG+7Rix9v4WvbtLc8pGCrqkTFb0ZHR7HllZenNMbQSOw/HFrP8qU5NQ7gXW96Xnh99oRB1u+bSCoo0vEfCtSe+uB/tZ/hQLWBAETbQzaNgN/ijICwGhFjo6xmVVXBun6lqvLV4s3qmBuJTRIyQECYrdhewuTd4G6BGir/7/IR9O663VYbDNPYgXsI9b/8HVM7EX7mGANNllp3T8qjS0b1CrPHUQlkMU7B8xnjCIIDICPnTs6jQw2267/tlRX023OGBslHjJnIBNDVs0CbxhwknuOQHh34GejmpP+u30On5nSmGg05LMj355dtZtsjFHdWg0JoE8gaqKoNtwSz+bTLQRwb2Y2+HamvvwxTG0V/k+3MxH2cOTaHthZVhs1TtuxQnGtVXUNIJpyc/YFAw3sbdtNNZwyga6v6hnxm9Y59dMGInsHsGbXOgO4aOWhpEQjMODlcF3/e8Gz6zRtrtc8Cz94rW8jPvdXVPtBZ1rg52sHBwcHB4fDB90qi//SnP6U9e/bQrFmz2JLlqKOOojfeeCNYbBT+akJxDiBl9M0336Rf/vKXNGTIECbYQajffPPN3+NVOAAgBksqa4ILbpDj4wdnhRX1O//Jj+iYnunsn37LKyu1qjKoSO6dHLqxdXCwAQTExaN7hXmkmixFTh/YmTJS4umvFx8b3Hir9gA6dRba6aLlBUxA2zbBdQ2NdFR2esjrssr4l6f3p3Ga/oHzB4lg8jLXEU0mRR42wiBo8B+Oa1Pv6VSdavABqeKm7w7pnka3jxtIsdHRVqVv0CJDUa753YTKxERRk1pXRwqAoIHHMhRiuP7mZLbY0rtB1onf9LIJASGKv0Hs2MgXKN5QFBUBAbUt/k8pOOtw8OFlAQISXddH0ccQlEK/xviC4JL6PP149drU0yCMocoFOWlSuorvRlKcUYwvJjWrUAVjvAVxCdJOtEldFgXsrTAOwR5GWCGpPuIhNkmWDJ1/rd7Fn8c9ha2DrEr1ssEQY4fsQS3GXBQ+nDMpz1NFKvzMTR7z+HvWwlX0iJIlgMCnKXuIieRxg3jdhIAEsvoOBcikJZ617fpxf8S9l8dcVV3+26Z2DR/9X5zWn5LjIdyIosvze9Nfl4bPSSN7Z9Anm4vC2r78/FBQUybrYcsBFbkoLgwCVYVJ4a0LGpvIbj9FyCOFKJYOyzc58CXuC67lfR/ZofguasKg1snMV0LtZsQ6AUFkKL1rGxpZPR5SU6ZfR/r1mAF0xbOfsChG512vu0ZT1oBASmK4dYwfizQ5W0gWEMTHRnMdChOhLtqw3yCkn+CHg4ODg4ODw6GB772wKKxbTPYt//nPf8JeGzVqFH300UffwZk5RAJoRJ56b2PQ0gGL1cBm95sQwgz2LVNP6keXP/uJ1dO5vMZ54Tl448GfDKWsThlc6PK+JWtCiFR5w7Svsoa+2VMW3DDBQggqOJuvLTbUMmTF86CsVOt5iQ2i2IjVNzbS3NdWBY/3l/8GrBFUf3MvL3MdIWYidd6TiGlBPEN1d9dr4ZYsav/TBR9gMfOHt9YbvwsVZu9O9sJykfpE64D3sTFuKGsMsXdQUVZVy88Z5HNFbX3w2YtnUlZdSx2S41mxBp9dnULNywbEr00IshNAks8en8vqU7WQLTxXxz28NNh+dUENFJxFcCU5ITZI8jh4A1kjAXsUPONYSk+O93X/vCxAKjRzlJ8gFYLIfrx6/QRxbG1Pfu/so7sxwetV8FCMLzo1qxzw69w+kX76xIcc8BPWMggSXXJ8Lw4ECZL89/9ax6R5QyNxcNx0T4RN0pLrTqA7Xl1pPE8en97doB3rUAAVtS/kZ4u+XlJRy+sJZITcs2i1Vu1aXecdwAPxiWu3erdrxjB4gNuwv7KWCxijzfgh83/oUIMpL15lL0irkqmmMRVj/vS/fxHSNu6dkkd/W2oOaFw6uhcN6RbIABKfkZ+frvj02786kY5INQfS5D5x+7hBHFyGQt6W6aSORXX1jRH7+tsgF0t/9IJhTILL14xj4HiwmlH7lsgOlW3wPvq2kD79tiisr+D38BvoZ4mx0YHnEVYIeC9PeMg2ffmL7SFzmFiT4RmAgBdrMkCXNSCjXXxs2HjsZQGFAA0Kkb7n0/5H14YRsPFTA6W5wQ8HB4fWA8SX8OZvKYYN09e+cHBwcPjBkOgObR9YwN/56soQT2QsmkFwMVk5fiDtq6hlu4J2CTF0zuMf8mfUFFxsKI5tUu96eTk7OABQE8GT+4WPt/BGCG0JGz3bhglqxNsWrNRuEAFs8pZvLWFF2hvXn8CewclxMUyERzVtIHt4KAZByMobMQSU5OOp5BQ24SD3BAlmav/YDGOTPH5I16CnOBSMwLqd+zm9We1TyBLp06ndgTRyS8o0zsUUfICy2+bHjve9AOJa1+8FkeBnEyoIg1vOHGj9XEp8LJ3+h/+FPHsUAbtr0Wr64JtCbh+/fXNdWBBD3VB72YB4vY/zvUlSwl31oz50/WlHcrYCSJqvthaHeOjbghpoi2jTsBuAf7aDHVsKy5lcVb2Y/dw/ryJ+uj5qUylHUxS9cNVISoqL8Z0Z4RWkUdse2hr6OAhfjCkgxe789/qgEhwkN9AtPYneWLkzLINDqGxhnaFTswJ4HTYveF14w4NY0xUEfOCcofw5BH8uHNGTbZ9Ef1fbOIIL0VHE9xYe2hhrQVDKmSZeBDauHRkCuG8FJZUBL/l3vuZjqWOwAPokrEHkAqs6dSr66ttrd3vaMqljGH5Pd0xBJuI6hzWte2a/upKevPhAsdW2BpDEsLiSM2pSk+2EsI4w1rVrnXUSAiam+QyfvebEvlyQenjvjGAQKMVHbQoBWA7qsiPQFoVKXRTyxlgBT30/Y5F4/qP6ZFJ+345UWVtPnzX1CwSmvLJUbMHpafM+Z29+1EcR59ohOY6yUhM5SwJBZQRkkfmB7A5kh6ok9yk5nekP/z6Q6SEDx4FKvazp36bPYH7DOkr+baxdRFHkPfur2cv842+LeK2hyxoQwDNA5qA6HnupxHFMcY6msVlXKFpWrg/t3oFG9M4IqwWhC0JGGvxwcHBoXQI9J2cgF7dtKZDR4+Dg4GCDI9EdWgydl6FYjIPoKymvZSUo1C1dU5PomUuHs/ITqliQWYJAw6J0wpCsgB+6ZuPp4KACBITAyu37uPjUL04lap8US19sLma/VHXDhHR+0+YPm6RpJ/Wjn0FNGRvNbRSHgNIdxFRFTUNQNXXflDyauzhU/Q5gQ42A0Q3//Cp4HJ1iSianFkw9nkl7PypY9A/VU/yUnE704tWjOJilEl5Tju4WVF+jOJ8N8IE1BR+uP7W/9bs6Za4MnAOIKJAPJkWqn02oIAxurG8wFjTF6yALZOBewv4CNjs5Wam+NtStAVV9j035+l37mQDCs5RtrUy+/ELxhgwIXC+uAwUoD3dFus3rFkGsrcWVYeRtJPfPRmLrCt2aSF4mY7JBmAZ8x+WsmNbyclcVwAhWyRYOan8eOzgrbOwSfv8o+AiCT1WFQ5EJtTT6en6/jlwHBcS3riAgxt7EuGi2XjFl/Ig2jtfgT33GH99jMh1WEUXl1VwrBYXGQTSmJMRwnQfcS1OQEfcW/feBc4dy8WKZ2NeNwZGoU/HcYaMzJjdgN2iCOoZhLSOPUzjmIxcczW0xxH6rX0e6/AR9HY62AAQt7v5XqNIf7eWso7vRqTmd6O21e8K+g/uSmui9DTFlMIGotQVloUSG9zmCPiJrCcEUP88P17N0w172/EbwSbZlUm1KvOYNBBdkAt2UrQK1eK+MZF/9XR77QCbjPojrBgEuk+BYX4gx6+7Fa4KBffn48nn5ybTzopgQAJNJbxD7GA8WrygII6NRBwmZWringPr+nIm52sK/EB7YsoWQfeLX+kXYpcltTRSfx1iGf2N9iQBCRrtABtuesmouuI52sbaglGJjovgeO0sXB4fvHlCgg0AfcdlsLm7bXLjCtg4ODn7gSHSHFkP1d9RtEg7Yu2ygG19eHrJxfGXq8bRzXzUrUR54cx0vmEG+Ozh4Ydrzn9MJuT3o+StG0m/eWBPik2vy+RbF80zARhx0i0gdl9uzvLlD20WbxuZc9jqGkhIbLXnT76WYAgGoEoJQzN+5cBX9e83u4OeQ2YE+pXqKD+qaRrOUQqUA/sZvnDk4i26Zv8KTQOiVmUL3Ll6tJZeh6rPBRoCD4IPdw2JFrSrOUVybHwUeMgJwHTv3VfF3Pt9cHBLMADEza0IuXfBkuO0XiCyxUffyUm2tjbA8PqpEAlLobQAxJCvehHUGrgMp+Iczia7z4Bb9DwTPzS99ZSRvI7l/JhJbp1RvKVHbXOiUul6k0W3jBoYRUMIqpnPTfYFyFbUH9lfXUVVtA7VPjKVPNxXRna+tDvY3+Hnr1MAm6xVVgY6AI0hOMU7jGu5ZsppuO3MQfbapKNT7vF9H7Zguj7O4HjxbrCHkY+vGYGSFPOMzmIb/I4Dw/oa9RnsHKGahXpYBJ+e7Jw/mYsdodzgmLEiWGmwwThrQmdoiZr26ipZtD6iMBXCPZr+6iu6ZkkfVdYHrF8A4PXfyYLb8uWFMjrUf6Pyy0a96Z6bQcx9uMgZl8czVIuHIsrAV5cUcxEVkiypowZfb6f2XQuf8BVNH0+urCsLaoG3eqKiu43NAQK9HejKvVXT9IiYqKjjGRzr2mdY78twsE8SqNZys1DYVVVd/z+szchASdPYdC/VrFADK+fOe+ChURV9dT3Gx0RQjkeHqeGzLFoLC36/1C9T5XVITQ+ZreQzF/5HxiLXmXYtCLfHQlu8Yn0tn//kDDkC01rju4HC4Yc2aNS3+Lgj0jOwBrXhWDg4ODuFwJLpDi4HiYjJ0aZNGL9MNe9leAZtoqOZAFmVnJDklh4NvoE3BZxoK43cktZvJEsOL0AZRJG9QjZ7jTGQ30uIZ+ax4EypVYFtJKJlgK+6HIqewO1D9XrERhO0EbEtKm34fyniQ4Sq8bA6EjYNXkcEEFDQ1pMfDt9eLfLARfDgHnWo86GE7fpBnvwd5IHvLAzgnPIO9ZdWUkhjH1wC/ZmzcdfDaTLe2t6nsq3vygM70mzfWBu+/V1vskZFEx/XKoFU79tGTFx3LVhXCSxfZPIcrTPYOIFKgQA5katjJW3iktxSCJIIVyO6yasrUtF+/NgItASxVUMwUfUwoctOT46yqbRRo9PLzhw81yFE5aKeSdaagpG1Mkok6KMxBPAlFJ9S0CAreuTDccgvn0UiNYWM6cILkT4xnq/ZzdezDvTl1YOcQkl6GjhTF8/7xoCO4T+q826Gmv/2VFUFvc7TTG15ezhYnj144jG6NgakPGY9pypBqC4CtWnRCuJ8JnhnaEYIzeCY8lyXFUV19A13012WcLYL7bOoHuIc6v2y0AZXMBMTfKHQt2gOyAaDGFm38xCM7WQtCb95bHrQBUq9lzqJVQTsjP/MG5iwEuEVbRgDYNA/6CeCaxj7Tekeem2WCWC2QKvdX2zpB/j2bClx8RpDeq3fss9rBiaTC3K5pIXOk+D0TMe03W8hrrgXwG/J8rY4hsMvTtTk8T7yO93EP0baeu3yE5/EcDj+C10GPyn3oU1H0s5/9rMW/VVttL1Ls4ODg0BpwJLpDiwECUF5wq5tnbFaRku21oRbvQ13qUiIdIoGsMJahU1Wt3LGPVd7CU1xOAYcfKdqzX0UnNsawKgKBLyvEBGlt2rAKYIN358Rcmjl/hZYQhO0ENojwNAeED2ukxDDeRz9EyvTMsTm0u7Ram55eXGlefOJzr83IpzkLV9GnTR7Lwh+4e7rZDFao3+CTawNIPRuC5IGmqODtr65kYgPPCSSFiUAH/GymsRG3WYXY3lOhWvPIz99GVoAUpMYoGtk7kxoo3PoKxSIPV9gK1KJfq5kaArjPSMnHffRjI+EH4rlDUTvj1P5hFkNeivDWyHqA8l61SfJSbaON2zzV4UF8+ysg/+xknak/+RmTcK/eXLWLfwfjE4jPF68eSbAjNd0z3NtrT+oXpj6+Y0IuTX70ff4bz1YlNNUxGOePcdAGHSkq7tcd4waxQhrnjfv/7rrdwXstCpXK7XTiI4Fz+8fVo+hwA4hzBP1MhaBt/QCvI4CrjpNeQRrMc7AuAWD7IdulqbYgagAJhWh1YzKeNeYZWPog8KPax6gKbd2c5dUvvAK4trFPXLc4N9jInHxkp+B1yQSxWpclWfKKV/uKXCcF/X1veQ3PefdNGUwzUaDdEIyQgUCKDch0wdq/OQFHMY6JeTlQ2yBwjjgXPAMvAQHeR/F0WMsIsYA6tnm1OdiGifN1OHTgCN6Dj9qK/bySOeqCm6lT70AmSqQoWPEhrVz4BNXVHb4CEwcHh+8OjkR3aDFKKmuYgIPGChtueZMgUtmh1LVBfCdQoLCBZvz9C5cS6RARYAsg+4IKyO0RG+Uxg7qwRQEUlGITDJWU8CPdtT/US9tr04uUY1UhBlWovGGTN6zwXMdxoY7D+dg2xSq5IG+CIyGGcTxhKaHaI4j0dHgh39SURq29zpp6wlHuP2sw/3vOa6tCSbumzbPaZ4X6zTsDIK5VyIPO7RONdgsg7YQ60VbEDJYrusyAoFWIxkbENF7Jth+irXgFV3AOaCdQ1Iu2rHpJz1q4iovcHo6WLqqFWCT9FVZLL18ziothgnj2CoLYIEgbFMy9bdwg+t2ba9maIorWBcnnlpJmfs4BtRDej0C1jX6ANi6DA4AvLQ+ed6AQp3cwwkROyf1dLqQpApddUhOYdEIhRNny5tZXVtKff2a3OUJGzqIZo7mYMXyISyvr+LniGPAtT0+JDzsvdQzGcwfJGOmYZLLSkIO4YtzWtdOUeBi8HF5Iio/hbInm9IPoaKIxuV14rrr1zIFs44X778eeA8/clCVlqzWgI3xtXuZ4HVYf6nF0c5bXPIh71dyxD9haVElTn/+c/41rh+reFNCV67LAlklA7itX5vehrA6JdPei1WHz/fST+9GxvdKDGTAdkuK40LmucDLeswHvQ8Sgy7TzE3AU/VIUUcZYgwLF3Tsk012TcjnghcAz5k1d38X1TjmqG/8+hA3IHlDHEK82hzZiy/5xaJtwBO93h3ads5ttxeK8zB0cHL5LOBLdocVolxBH5z+5jF64aiTdFjuQGqR1Jhaz85Ztpl+efqT1N+SNRXFF7UEp8OdwaAOFrECKqepL0bawuXnusuE0V/H8Fpuop/73Dafhoz3LAOFjQ2pSbNiGWUeO4nyWby2h847twQU8ObAURbTPov5WyQVTwVFs9kxFNrHZxfceemu9MT19/JCudNekHnyPbCnayQmx9M7a3SEF+4K/Zeizgvj3myLeUvJA1F9AfrhKdN89OY/to6Dq1pLX8OmdlMc+vnarkPD3cO34bhEKqCrEbND2QyHtVDUgSDvYv6Lw6GXPfhKyGVcVwDg/qIZh8XK4BRtNwSQvkgptA/cKbd6vXYAJKpmK34aSMjk+mmZNGMTPBc8Pr0dK1IIYL6moZUUsCD0QTFDY6+ZCeDybLJhMqu1LRvfmWgkIwggFp0yg+yGMMH6hD6Hd494hKCH3GRDUID4/axqTVfIR791wxgB67IJhlJYcRw/+a13wmXRqZ6+JgnsaHxND970e7k0MCywUhR6W3YH6dEyhaSf3C8ni+GpLCb+3r7iWVu0otQbT5DFJPBN4m3tZBYlxW9dOE+JCM/dk4PW2ipF9Mujj7VX6jBo/gd74mGAGIv6PQDeypW5fsDLsGf/zmlFUrgQkVSCjzKSK9oKO8DXZMrEVCRG3Oz9zlj37qCN9vqWEvblN52wb+8R9loNWawpKeW0kxg+Th3jPzGQtwc4FipceKFAsgL6OYJZctFU8H9zzbkp2Go5vsoPD63gfCvLmBFqEgAEEuinQgTXelc99Rr8+fQDdduZALgqKIBxEFJiDUdBYFAZFS8V83CUtkSYf1Y0FAzplugqM+bqgpcOhAUfwOjg4ODgIOBLdocXARhMKkn3ltdQjM4k+/OZA6q2we1ixbZ9nKqVAXX3jQSnw53DoQrQhlczAprBfp3bsh4qUbhAgJg9VbAa3FFVwcU15s9fY2GgkqPG6IMHkDbNKjoKQ6pWZzOrz2QtX0VtSsVBZAeZFspk2wWt27OPCVqpfp/Dp/dNbX9MFI3rSRxuLwlRSXHx0Qm5QPWYr1AW1p1qwT4auzwri32Zp44fo8EMeALg+bOpBaMJnHQSCnK4PG4Zv9pZTfGwUzZmYx5kvsBtA8bKlG/ayf/Fbaw88H79WIbj2DXvKgoSCSsyK61OJBEFWgEA5plc6De6WxmpcHVR7ImRTHI7BRlMwSZDKpvdgF6LztI00aKvzJcZzhIoSx5Z/R/bl9RM8Kiip5KKGqiezKdPDq1CyKMSLMQh9BOOkCDKKvhog4iNTzAIgq+ADjCwWEPIYH0B0QU27fNs+ujS/F43d18VYU6LxjUa2wsI6QSam42PtRHN6UjzN1hQpxBh924KVwULK8r1bOD2fSitr+DlMnxco0msak3AMqFfFM9xeXEGbCyu4aKgpYKH2TTHmqM9+W1ElK3h1x5x+cn9qq7hwZE+K+2pv2DXNnpjLhZRBWNqe6aLlBZxFgHEbzxDq5qc17QbP+I4FKzlryhY4xrzf3HFRR/jarDxwDhv2lHORWnnM181ZtjZ3+/iBNOWxD2h4rwzf9mAy8Bsrtu/zLGRssrLRzf2wcPFT20C+F9xXEmJDrgH/xvhl86JPTaxpVraaEDCA8DcFOgCMVbe8soLv07jBWVxAWdjZYZ009o/v0ei+eA6Dgm1PBCSuPbEvZbSLNwYC8JuoC4B2gmtycHBwcHBwOHThSHSHFkMsvlHYD5ubz7aU8CIe9i7YuGNRCXsW08ZBpFKKv6EMORgF/hwOTahtSGzssJH57dlDmNCpa2jkwn+X5vehodnpYZYv4jtQvqHg2dST+rLKCq/HREWxcrNR03bxelVtvXbDLKdKA//+5Y+03ufwezWRATqSTbcJhjXDfUvW8DVMPakfq0RVwqyyrt6okgLRbPt9scmG0t9LoYq0abmmgbw5lwMLQPf0JKvqLhLyQATixKYXRAgIRng7y6rwDk0FF1WSUrQj3CcTxLXr7CkwbqGd2YhZE5GAjfmlo3sxuQcy0ktJ/dI1o1hJ1zMjmW4YM4DJ+w7w/W3yzj/UYVNUwgMYFgY6y43B3c0BikiCtjqbBrlNrN9dFtLubIEp1ZMc2Q5ypodNVQqgmKkgyVWPZqC2LmCPJn5DFPFcvq2E7V6QzYA+KwrWiu/68RDGe7BGuXB4NtsKHZF64DNojyUVNZSVlmS856KWhTqmoFCrsEfR9dHq+nojmS0XUpZfm7NwJR3TKyNoZ4XzPya7Q1iwE+MmVPSfbiqmjOR42l9VRzfPX87n8diFdpsZcR1i3NY9+xte+opevHoUjR+cFXLM3aVV1L1D27Vmuumlr+jKU/NCrgn3GAHKldv20fvG7J+OPIZd/uwnQZIT7990xgBjsJaDJdFRdPfkwWEFXkW/0lmK+IVunPaa97AOUMf8jgrpKvoysjYwT98+bhBV19VTSXktfbqlmApKqrjv2da9pvHkhKa6ADuKK+nJpRs9A4W6cU4393tlyunuC+ZdMZbK9UMgInhACrapXvS2Od6WrSYEDH6LGePfN5+RQ5U1dbTkuny2GkIgEeMiRBN3vXYg0CrWcfjv1JxOLDiYpQTw5DUo7h/ajoODg4ODg8OhC0eiO7QKsPjGQlZsbLFY/+fVo3gBClWdrMyFDyo2E0h9hHJDkHwqGerHJ9nh8MYjFxxN64sDbUsmxbFZw2YGVgiqt7XsLa16p3dJjaXy2oCSWRArCXExNPXZT8KIFkFQCyW51wZQLViqKtNA4NsKdIUVs2wXWiztnimDmXw644/v+VaNmfqZaZONQAHS7G0Aga/WNLAR835hIg9OyelEvzjtSP5teCn3SE9mgnCG9HxVVfij72wwqtXg9eyVKm9KGZ84pGuIJ6qOmNXdC6iFURQR3zMpgMVx7128OoRAFOPmz//6Ma2+6ww6XODVpu6elMfBBbm/wifZBr9BW9WmwdQm/Kg/ZeB9OdPD9rvCnx+KbLU9iPHtmOx0LqRsslMZ2TuDLnv2U63vvhiX0Bp17U3M0yDucZ6iICnGXox1IEMxnvkhntU2jwLI6L9X/agP90cEp3CMKIqid9btojSPdYGO2MM13DQ2h57430a+Xlwf6kHA2kdn/YDrgyJYzl7yUufjfXXc1j77lHg6ZeARVFyO8byOC6HmdUtr0/UNKmsatAQmfKZhk4ZxG/8hWAMSFUSr6Jd/fHt90BJI/EZZld2uBfftkXc3cI0OFKVs7rxigvrcvGzdRNuQx3z8x8U35y9nmxZTP0TGBuqy+F33inPbWVoVHNNwHzGHPHnRsRFlislQ1xhQk9fJ/oyW61ZfK6+u1dYPEGOivHYRQL+cenI/ng/VLJzZCBDsq+R2A7sdnWWcn2LGAttLKikuJpr+pNgF4XlcPLoXfajJ2nt77R666YwGzlrUrQXxeZMnvIODg4ODg8OhA0eiO7QasDES+PkoWEcUUv8j2nPFe1nl9kjNhhB13TOXDudNirwQ9euT7HB4A8rd6IRQ700A1i2AuoEz+dcCIH/gVV5UWhOiIofKU1WVyxAbXi/F6W6lYKmACDC9Om00kwg6MsC2GZXtQrw8RXWbzEj6GT738aYii6drIJ3cpMK2kRthQQJNsUeZ2IB6LCUhhm0CfvPG2jBl2LwrR1JJeQ1V1NYzAfLf9XvozLwuARWxpWDizDNimJgf1DUtTGmOAALsBkwp43MXrQprVzpiVr0XICDFuGdSANs8ecX7hxtsbQoZB89+sCmkL7JXvgV+g7Zq1onp2cj9QIBzFWCirAHavtxHbb97wJ9f3x5gXZPbNY3W7Sw12qk0KIVH1bER4xKyHi7ZVxXsB1BqIjsHGRP4Oz05jn79z6+CFlXsobylOCLiWW3z+Bse2yCW/6DUckDWDgpNev2m9v5W1tHVJ/ahP/z7a+5v3xaWWwkxeNLj/or1SifYfBiKFoPo65ae1OSLH+PZTtMQgIiNpriYwJgXV11HiVIGz6EAWZEPBTIyHrYXV3LAeHVBaVhGGPyqRVYF+q+uULhAckIMLV6xkzMF0L9EkW7MgalJNc0uFmx6bpifbFYemPdwvpgzuIjqnjI+h+4ZyTxPQ5GPbDFdP8SocOMZOXTeEx9FNB/fvXhN2PlwrRUL5PlILoyclhTPmaTy3Ii+hkLJmA/fWbvH04oR7R7jDgfS4mLo5pe+CusrJussnMtNUmFQIbZBRmBlTT1thRintp7bBWfW1dRTl6a1jxAw+BlrBFB3QR1bTOOiDKzRUNtG9x7OAUFQBwcHBwcHh0MbrUKiY1OFRbHD4QssgGskq4OxuVmB4m1SGjc2nyAKsYlqaEp/xWeR9v74fzeELNKbWxDK4fCGKO6HjRcsFaAoHNqjg9G+JdTbPJaKymoiKwSmbHhtilMdESCA97A506mzdP7Lps2ol284NrcyIu1n+NxJR3bign2wa5I33LhHU0/uH+zXkdhj+AkSyOfAv7m7jEmuB94MJdAPFHtby37LYrOL8xvVJ5MJAwGdLQu80m85cyAXXpQ3ymgjPzmmO1XVBbyvdQBhAIufSIlZtJHTB3amAVmpdGx2Ok0YkkV3L1oTcn9HRehNe7hDF9SyFeCNNJgkZ53YbATwGShGVcJL177VTA/b79r8+dEeoOCGRcbfLj2O7nxtdZDgU21f1HYjtyV4Bdc3EHs9C5s2mZDn8XbcQLr+tP509jHdKSE2hu8NflfAjy2M6hONv1GoXA2OAXh2X2wp8WXtpAPWJn/5b0CN3j4h1loEEJlMcjYAiwAuCJynTA5ibQM7prMe+4B/10+hWtOY99zl9hoZP1Qc3zeTPtpWqZ1bdNcqZz3gHl936pF0/+sY80IDJrqsMbyeFBcbJNn99C8/QVobZFW5PH7gOi7P781ZEk8t3ajNRMHaGFliRgsi2BqV1XBtIb/zsc5SCvAiksV8JD8TNfAlgOtspLVsfYJxQ1WHw5IGYwwgCno/9u4Gtm/Cv03Xq1sbyNcjCppCnY9aLmoQEM//1jMHslWfWA/gPiNQzv1/S0nYvL5zXyVn5QD4DOoumBT7tvkUtVP82nM5ODg4ODg4HJpoFRI9ISGBvvrqKxo4cGBr/JxDGwQWwPB2xuIUyi4oMsMVHoV012uraezgLiEeqfjOjWNy6MYxA6i6tqFVU3IdDm2M6ptJy5o27tjEIePh0Xe+DiE5bfYtsifrn/+zgfp2bh98TRBUpkJg2MhhUx2mMDSoY5vr92naLOs2oyh8Zy+CGsseoNjUN7efIVUZatpf/3gATTu5H6vB8fe763bzhhrEm1Bx+bHHsAUJ8Prdk/PC0rcBnHtVcb3VN1f4KgP4HPxz75mcxxv8LmkJlBAby17JIen1/TvStJP68kZc/b3bF6zkomM2yEpiv8QsFzwdP4gtMHAugty/aewA2lpUycQI7K/8HtdBH9QCeXbesT3o1ldWhHnS3zUpz/pbKgl375TBtK24gooqaiklwb6UguWCnyCYyPQQ44/tmXo9b/RxkDoV1fVG+yG8Lvv4C8DGAX0EpFNReTVbLHy7tzyMQBe/e4sSLJfHW9v4iYCT+JywewMxB6IKandT3567aDUtue4EmvXqyrDniDHpsmcCxJ6u8N9XW0uCWT8YL21jMsYdORtAWMqMHZzF547MJSha8Toy8R69YBh9tqWYXvh4CxN6IEXLquvCSFse815aHhYE0Z1HW8ED5wyhmujEsOCxPL7jNbTJzqkJbNeSmhRL/7h6JKdm3Pd6uEpbzGOyKhjtZtaEXDrviQ9pQJf23LbgJa72r083F/MzwHwEtTpqncCXXQTU/QQ6VIB4nTspj7+P5yqKUUOF/vG3RcZMFMwZXv0Vlj6RFEJVLaX8BK3EfKTOuV5e4hj35IwNBNGz0hK5PsNTFx3LFiuob/LbN9YGn5nX9aprA3E9Yu4bk3sEnT7wCPqdJkiOY9y3ZC2vDWTbJGSaoRBqQWkV1zxR53UEO6CqBzGPoEZzsvaQWYtjttSezsHBwcHBweEwIdF/9atfaV+vr6+n+++/nzIzM/nvBx98sHXOzqHNAAtgbE7+fOEwTgs1LcixabxkdGjRr8ACeS3dO3kwDcxK+Y7O2OFQwOBuaXT9GUN4c5sSH0P3LFkTRiCb7Fuw6QNRJDxZsbESPr+LZuQzQYPfEgQP0pRnjs1hQgyevD0zk6lberiVjAmRFBiUoSvsJSuo5dTxiuo6axFUKO17ZCSzVUkkCE/7XqH1Saam4yIV268K2xYkwOsbdpexLYdKeOB+rdu1P6KNMFLF4bf69PvfMimgU9/hmMhk0KVz47l5kdlCCWgqHKlTQ+L12yRvVmEfhOc79fnPfVmReCkQD1foglo6P+Ez//Qek546Yk2npBUk8A3//CrEriUSqEEwkekBL/P731hjtQbw87xR22Hh9NH0J6WILiD+hspUHVfQNjGu5PfrxHYwD/57PT3+s2NCgt8mqxmMC+h1ov/IBDlIOKjtEXhLjo+luxatCgY2uZjplmI6qkcHHiMfOd/spY7PllbWBImsksoaDsAjAAGSC/dPzZIRPuf4Lvo3rOYA25iM+wFSTowDuAaojQWhDgJXtYQASff8FSP52uRgLkg8BF1h74G2Z8oiaKtA201NbWcc30Eyivsi36/7puRRz8wUexHRcYMov19Hbje7S6vpgic/4t/dq2nDYQEeQ0DdZCtiGqdhxzKzqeipOgYgIAOLIB1wnIaGRs/+Cgu6SEhYU9ZZsJaBpcYK7MPk9/wUTZXnwgVTjw+Oqwgg4l6hQKq89vKriBf3GsG8Zy8dTmnJcZxdhut48eqRFvX+Xs5EkyHuH4LdunkduGx0L5o2L1AA1AYE0GSo87lq9XPASijyLAcHBwcHBweHQ5hEf+ihh2jo0KHUoUOHMDuXNWvWUEpKirN1OUwhFvQdUuJp7/5q62d1C3YseJ2S0iFSDOmeFig0lRxHCY3RWgW2Lj0XSk8Ur0ObA1EJyAVuX19ZwKTLzWNzqLyqnjqkxLF/LTbSR3Zu32zVUaQFNkHeoWiaDFOxQVF8KyEmmq8VRDY2v7LPr/COjQTbiirolvlQTRYa077VQAXOEfYkfo5lUtQJ4BmZCA8v+xp1I4/zm9W0wcY98rJH0dm9YL4zecTiGaCw2Nu/OjHsudosa/CcYDt0yfG9Quw2oAQWqkKrrVCThcWpA4+w3g8Hu5+wrp2ZMiUCVgeBNuVl+WSzF1EVmcj0qNyzn+0KGhuJXpsxmsqr67kI3ntf7wkWxty9v9ro0QxyD5lhQpFusy2QbdhMinW0UQ7WSfBSr8rjrQgKob2Le7txTxkH81AUGMEMMU7h/p83PJtV4jakJBzITrnztVXB+4Al6I1nDKBL9vfS+pwDOF6H5Hgu5Ikxmf26RZHPpFgmNPEenj3uu+6aTUEEXJNKFAM4P1iB3H/WEC5qeKhCJaARtETbAgGpuy+dUxN5DrcBKn/4hXu14UjqR+A56mxFdON0wLpEn52EzITrTu1vPX/RX70U4jK87GdMmW041osfb+GaBbhvunWGOudG4iWOZ4n+IQoJiyLnmwrLI1bEq/daXl/g3wiY2KCzyMN9NgWocJzrT+0fCNh52ExFRxMtnpHP9m0dkuJD7p94NhU1uP54uh1FlKXfacu2TA4ODg4ODg6tTKLfe++99MQTT9Dvf/97OuWUU4Kvx8XF0TPPPEODBtnT3B0OXWDDC2/U372xNswT2HfRLx/WDw4OMuQCZV7KIhGkYVVifi/aVVpNzy/bHKbYlhWLgEz8tAa8CmwKCPIO5Kq82TMqQL/eS7MXrgwqrC9tUsnKG02o74Xy2Y8/7PbiCrp5/vLgsYZJHuM24gxq7Tsn5vq6Tr9EuI7wSE+JD7He8fJGlkkwTzuM+gZ9sKJfx6Cli0yk43hI9e/VMSUiy5rZr66kmWMH8jNTyUuknw/p1oFVhSZbDHzujgm5NPnR9+mGHw+wXpND5BZJts+KNj/j719on82PmmxioHLXAYQUAoBrC0pDCNz4mBjaWlxBj7y7IdSHuF9H9uSe99Fm6pKayD7cCOrIwUMQfhcf3yuYVbOnzE5Eife9iEdV7Rtp0FtVckIxjgJ9craFTOQDfkhH9fnA7/yUnM6swrcBpDmIch1pigAg7JWQHYLAlu6aTUEEW3ABz2lLUYXnmNdWYSKg8Uxxr3XPUgQ6bEARURvUNh5JgEcttKkbp23ZSZh7bh030LMWyclHdqLjemXQnQsDGW4Cp+Z0ojsn5LIFybpdZZSWFEsp8bEcGBLFek2FxE1ZFBhzcL+PSNWfj9r+YEdjmkfxOt6XLfOg9JY/K46J98V6wzRfiXEAUO+1/NyEuMHrvqrwCsiITDJxfpB9qR73WDtd9synrIT/41tfh6z/RBtHVhvqNsAaTGfj4+Dg4ODg4HDoIiISfebMmXTqqafSz372M5owYQLdd999TKA7OMAbcWiPdPZGPaZXRkTElgAW4A4OkWDa85/TCbk9ApshjywY2K8I+5abXlpOPx/VM0gMYeOHDdmKbaGKxe+zWJQgh7BZkzejfggCWS0p/o1rAfHmt4gnCIXNhRUhG0So920AISK8h3EsP7B5xavjharaBVFw1+TcsPRt2W/ZBC/iBl7HqlUDgHENikrc5wtH9AxRu8JigiicRLcRsSgmCmLFRF6CeJk7KZd2lFTR/uo6brNQXoI4io+JZuUdHstr0/Ot1+PgP2ArtzOvzyLYgn4WGxXFQYzbx8VQZdN4Iohe2MSo7VsQUncwIRVapBKFbZ98L2AbIoPn1CiiWRMG0aRH3ufXhI94XGw01zxAq57cVOASQBuxoXdmCtszJMTFWMcVtDmZ1PbqPwjYISPDlHGjFgPksUsi8qH6tZFwJlUtrvvtNbs91yA4JxNpij6J+gQ4rhzElK/ZFETwCi4I/2hTgKCtAvfyVk12B/5GoAeFQ3UQY6ctk6NdvH2rAnu1SJ6B/L5sOeYnYKYDZkVTVogc8ME8hWLXIGlxDslxMZy9iba2VDN/ffBNwE7OlCUTaWabac7F0mnqyX2pgRrDArSoh/DxpsBrCCw9+s4GrZc/7O+4rkeTfY5a5wAZCbV1DTxfme61/FzwbwgkbO1CZ3cFWz8bMEaKcSkhLppuOiOHZkZFsW8+xEC7S6t4TGDf+6r6kKCqPF5AKY/vHCp9eMuWLbR3b8vIf2SkOzg4ODg4HA6IuLDocccdR5999hlNmzaNjj32WHr++eedhYsD7ausDS6AxYKcqFEhB5qKfj37iXZBnBTnSHSHyBFUaI/ubVUupsTF8GYdaur8vh15w/iv1buChcbQPn89ZgC9MvV4JsG+72JRghxSPYXhJWyD6Ifypt+m/jJt0ANew6EEVXqKPWgK4lAo+U/L6ezrOk2KOjkrQEDnsZ6RHE/jh3QNFj2DFQqe20NvrQ9R4eMedEs/ECSw26N0ZJLTZoPBljmK2nXKUd20n7cRsV5BkWkn9Quok2NjjN7NsABx8A8vJbDczrw+C0L0/z7aHPIMRVBK9CVd+w4QUl+Hef7y30vW0tDsDlrLIPRdjE+ibeO4+A8BwnMf/5DmXTEipN172SqgQCDOE4URbUDQBv0RpCcsS9DXcUys/2A9JMZR8bsIonmNnaIY4Kg+mVz0V+4L6riHvt0zI5k6tk/g4Jnt+cDyZsHU0TRHsQ+Rx5Txg7OMpKl8HrKiVr6XpiCCH2sMFDWUa0jI59dWAbsfEwEd8DXXz1u4p6t37NPeD1G8u71HAVi0I1uAR7XlguUWSNB1BaUhNip+rMV0QJAA2R9Qq5sCPrA/eWvtbv5PwGSPJltFyeOKLhvLb2abbc7N65rGc5nc10RwA8XCX7pmFI0f3JWvT/aYl4HfuW3cwJDnJNc5UMUJvzgt3AJHfm74ty37CllfuutOiY+12rTg/Z5N2WLf7imjuxeHBrCFfRXOt11iTEhQVR4v0Jaw7zlUkJMzkCorK1rlt2qrw+v4ODg4ODg4HNYkOtCuXTt69tln6YUXXqDTTjuNC4s6HN7ARlYU+REL8qt+1IduGptDe/ZXU6f2CbRmRylV1tbT0dkdQlPUkQo6MZc+3VxMGa4gj0MzgPZ0ZX4f3ohjGxYSvOnfkX579hCqaWjUWmaIQmNQV4FYR2o11GJ+4NcWpTmQySHhKeynwCTUWfgMNsIgyP57w0lsGaErKCZD3aDjmlQyoq6+0Uo8w9tbbJb9FBUVEIo6qNRgdwCoPsY631gA53vikZ1CSEqQJiApodoWAZHEuGj2IgYxA5LCtkGH3U+R4gHtRaiYzs+LiPVSTUItFyBKqFmqQ4fIsh/U52j7LFTjK7bt06bzy0EpnWK0tqHBSEjpCnB7eQGLdgQvdNHG/dgqiPaT6uFBDkU7AnBPXXwc/f7NtcZxFKr7SLJ3BAn4yPlH0/rdZWHXKR/nsQuHcZBMtqnQPR987/VVBUyUgxRE0UKMhSKD46mLj+Xxes/+Ks8+KZP5x2an04QhWeynbwpO4HX5/utU8ChWesVz4aSlUOm2RahZQiqQLaO7L2ifT198HBdshRWZuB8o7CgX77ZZlxSXV9PMMwZycUs8X6w30TexDjB5/eNc7p0yuEU1NsTv7NhXFRbwwfn37dwuGPDREfSR2M74vc9+IY9JCICofU0G+g0CZ1g/2YC5VvxmcUUNk8zqPA7gGaLmgwq5T+Hf2Cuo91X0k/Rk/bPCWmfGKf218zpex/ti7Tbr1XCPfvE37CmFJ7tYy8jP0I8NUVsCCPQRl82m1CzzvOOFghUf0sqFT1BdXWjBVwcHBwcHh0MNzSLRBc477zzKz89nZXrPnj1b76wc2hywka0uCRRlxOISC+aH3vqaFWFYVP/29bXBDY260YCSr7GhkX7zxlpWCTtSyKE5qKitZw/wF68aRdfX1bP3JdJzkTINSuQ2jXelWmgMfwvPTC/4tUVpLkzknY2kAZG9ftd+uvWVlWHnBBI2EhsLKE1BJD9/xQjeDIO8iouJYp9u3Qb14tG92Bsafd9GKHuRae0SYuk/6/cwwYDiaDjurtIq9pRVC3vJwQsbwYzPT//7F7SmoJTmXTmSPttUxAXtQK6BfMEzr2toYGsOpNBPnxcowmqDvIH2sv2xEbEYA21AUTP1Hjm0DEKJCT96WHcIhSqIGahUVaUnyDZYLsh9PV/yovcTlFKfnZfy2xZcUW2V0L76H9GOi5BWVNfTWUd3o9kLA8U2BQmMoNKs8YOMWTaoL2AeVzKpb6cU+vuVI+kuFPHUjKPw7UchvtqGRg6Wo8/p2qrcd9HXQc6XVNZQu8Q4z76AAGF5da2vTJaV2/Zx7QKc7/kjevL6QudXL/s4C6jkmEww4vNLrstn24ezj+7GqnJk7IhiwBt376e7Jw+m2xeEWnQIFTyKPp5/XA8ONqjZCyJbqC3ClEko1nyYVVFEdurJgTFWZC4My+7A7SWvWxoN7pbG30FbUzMZ1EBUUjzudwnXGxDP74Cf9SfcJtCDQMzrvP7xbGCvImdfWQNm/TvyMw95rV9HthPbUljB16mS0LANEQEfHUEfie2MQCTBaS8ExyQleKUiJSGWA/BepLF8blhG2bKUY6Kjwu617FN+IPgXGvzwmmvxOjJWRHYa5nRYs+H5VNfW096m4Pi+iloOVJ4/IjvYd0WbRFu5Y9wg+tlfl4WsZeRn6GVD1BYBAj0ju/l1VUoLNrXq+Tg4ODg4OBySJDrQvXt3/s/h8AYWrvBFn35yP148C4jNjdh069QuSLuurK1jj+rWUtk4HH7ApuaYnumc+v3bBWtCiB4QwX69TnUqz0gKRaq2KH6hI4axWcRx5I0mUtBB6oEAkF8/ocm/FOnX6jnhN+6enMfWJ9gQnjc8O0gcyhtIeRMMcgvkQ0jRwn6ZnIIOn+7L8/vwxhQENDzQhdqsuT7yuH4o4jB8LFm+I+T54TehNvcKXkD5p4NIw8b54vtLVhSEWU1d+aM+9MXWYlaJnjKgMxc+tKmV+3Vqx17SfhThtiJwUFv6VUU7tB5Ays2ekEu3zF+utWIRgTC0FxT5Q4HJa07sGwwowcKhpEnBaYI6nyEYhIKWKCKKcSrSonmCzFsqeRKjfaDAHUhzQeZwJsa4gXT7uIG+ramgmMW4cqvGn/meKYMpOzMlkMliIIzQvzbuLQ9aHOE8YcXRPSOgJDb13VNyOjG5ivoLGMP/fuUIel8iWQVAViFAeHzfjmHHtnlDz508mG5+6StttoDq4+wnUIk5BpZaR6QlcWA2dHzsSHMm5dJj//ma7+XW4kpuL4JwA4EO4h72S4daVskbq3aFEYomFTjaxsLp+bR3fxUt/aaQps37PMx6SxfEFKSvCIqq8684NuY3DhyNG8hZZSaFtS7QZRqn8TzrGxrojetP4IwmAM903J+WciDg+StG0oVPfcS/p+v/OoLej/VPJPNBczPjIDaADZQcDAra3PXvSLX1DbSpsIJ6pCcHFf4qcG7I9lKfi5ylIj9jkOjqvcb76CNYP1TVNnDA7N7Jg5kIx/7Cbz/JarKJQlZCFEVxzRE1O3HaSX2DQX/deeJ6B2WlhqxlcGzhfe9lQ+Tg4ODg4OBw6KLFJLqDg0DX9GRe7O4srQ4p6uWltikorWRPWVgvpHj4PTs46IANEFJvbxmbw0Uf1U2el3el3EaxEfxmT5l1A2orQKbzLfWCjRg2kS3idag4q2sbeCN83hMfaUk9/O6G3WX0wsdb6IWrRtHshSvD7BhQ5FBs0LEZV4ud8e/g76goOhM2Cc98ElQZgng+eUAnVk03hwzaVlTBZObQ7HStR6wITjxw7tBmBS+EAh/nairYCCsfqNd6d0wJeoybCBXhQ95TU0TUBEH0lVTUsvVVeU09K2+hxrUdpy0Taz9kiDaujhVyWwJEe4N6FiTL88s2B9uPl7WSHJTaUlgeLFYJIBhlVH7378jWZiopidevO6U/Xfy3j4OvPXLB0UygoxAnfjMkOLa5mE4deARnXfgBiPLf/+SoINEPixco1G2WFKZxFPds5vzl3IZhyaELPGL8uECjEs9XCC3ZyxwKbl0/N2VpYNw0Ef86H2dboJIzbo7vxcVQF365XTM+7g14u2en8/37ZFNRUF0NG5gr83sbMxPaOv7fR5vo0UvywzK8dCpwtIE5C1ex77+O4PaaQ70KgGItiX4A24+Karu1hBro0gVksCZAH8vJSjV6mM9dtIrbulwnQ+7/OoLeFqzJV4pqe80Hzc2M031PEMpYL8wcm0OLVxTQX/67URrzokKKi4ogg8h+sWX7ic8jSC2vY1o7mIT59ZNNxbRo+Q5t+4O/u3xO6nn2ykzWjjOo64TvCqX8vGWbtTZEDg4ODg4ODocuHGPp0KqIpijaWljOaiyovLA58FLbQPGKBSwyP53q0iFSiJTqT78tYiJdV4zPr+ILm8clK3fyJsq2AY3EFqU1VO06hbVMwuA34CdsU8VigwfrChDo7xvsGOBL7EVS4HXYQiBVvTU2vtuLK+jm+cv5HC4ZHVpITb0fIPeaE7wQadheHrTww5eLdNoUrs3d2N/+6sowogPkyKGmTP0hA/0FNhxebQkQn9EVuuzTMcVXFgEU6DKBrnqVq2rmOyfmUnx0FN0zOY+Pi/+gTIedCfDa9HwODKIGAdoKCHSd4hfj2cg+kakiQZjLhTtlROoZjeuCwhyBIgSPoOY/f/gB+wTY0pisNqAgRQYRLKVkX+VIgpR4ztuKA6phPz7Oat9D0A7q+xJJTY7zwOdNxLzIbIJydsLQrmxNIQjDQxk/H9mLYqOi6IYfD6CZY6PZExs2Gqbx1sv33zaHes2/UDH3ykzhgIusDNdBZ4+izq1CXY22a7oetNmbx+ZYVePqfAK1+LnHdA/LaBB+7bAbQ4Fur/mguZlxpu/xeoCi+PlMfOR99iYXQS0ECZDhcn1TYVAUvca5IYvsrTUHiqaqv6cWOT+YwSRxXRhvvIqD616TCy7LwHODeEDMAXg+yKIRtRYwH+i+5+Dg4ODg4HBowZHoDq0KqDkz2iXw5h5ptFCPQVEnK9Nl4HWhtsHGxy0+HSLB/KmjqEtmBm0rrqAbX17Bhed0sHlXimJvstrRawPqRSZF4lvaGqp2vA+rFhtAAtlI5PekY3mRFCCI/BZf9drsgmQTz8UrawXqThtMxItIpff6/eKK2rAshEg2+bZ0ehCpsJWQa0MI1fCmwnLq06md0Y7GofUglJcgxFTIzwWkULuEGFZ3C2sD1Y5s4bTjfWURIPijjj0yKX/buEHcp0DGoDDohIeXBq2R8PuDuiaFtDEgEHROYDslFPHWkdH4e9bCVRwcU9twc6wfbJ7RYhxVAQJ6Z2kV3b1odQjxjM9D5YraKTaSVVb2Rhqk9CJQxVit9nHcG5DnRRU1VFXXQKsLSkPsZfx4WaclRbHaujnWXm0Ry7eV0FPLdoY8XxCMNtjuo5hDde0UQRkbUNtAjKV4fja1NzK4/M7PXs+9rKreUzWum09s2R8Hcw1hDZY39T/hES6rtFFzBYp0BIfEfYaVkw14ngi8tzQ47GfcEtelG+NlmJ6n6dnhmDpLSjFvwIsd9yE1qYb6dnJzuYODg4ODw6EKR6I7tBqgKN1RUsULU2wG5EJcULGAYFeLEUKxPv7hpfy3V1ExBwcVR7RPZIWn2CyZFOdC9Ql1lRzMQRBn9sRcthMBVN9O0wbURiZF6mPdWqp2PwQXPD79HKs1gwQ2BOxoan1nDIBgaM55iVT6TR4bfVz/T/7yYbMKxJrS6bEhR/o3lLgocHhZfh/KbBdPD721Pswn+DetVJTWQQ9ZeQmVogyTf7PJ0xdISYjzla1gCv4IQmb84Cz649tfeypJdW0M7eamMwaYyWjNGNZc6weTZ7QagJSBPg01uCDQ5UBFeRPpGCnJ5Xf8wdiKcQ++64O6poXVgVhbUBo2VtvsLUQb8BqnsJaBb31zrL3aKj7aWETRCQdsLLDWm3ZSQ7N8/8Ucamrvd03M5WeqyzrDs0J2owCCU8hwQq0Ndf2JdlhdU88BE5mUBQRRi2ctAmmezz25eUSxLfujNdYQsHxrzvfk/qcqt/Ge3A+91gwy4d5c+B23xHVF6jkPoLC0nI0mQ3eNpnlj0/3jfF6Vg4ODg4ODQ1uDI9EdWgUgIYUlg+wVKzbMapovVLMrtpXQlsKKYPEikaru4OAXUIvKhJiNMHn5s62srMJ/KOpXWx8oiAnl8dX/77OISGxbAbJIfaxbi7D2Q3DpirXpjtWaQQIbBEnhJ2MAx4VCr7nnJTbZojCYTUkbaYFYU1r8p5uLaXNRBT36ztchKlwoIEHsgHgKFl9uQVFaB3+QlZdqWzP5N+s8fdX25pWt4BX8AcHnx1pG18Z0AQHbGNbSoshq0CAlIZbbuS7IIPrUsdnpTEQOy06n5LgYDqjDYx6vR0pyRTL+YGyFrzOKPqJWhvz80Afvnjw4TIFusreQ24BtnMLvYn554n8BD+nDpVg6vPljE1NCClMiq8I03uL1bh2Swt4Xc6itvcMq8MYzcnh+V4lxzHX7mDQO1KuA7ZFqw4R2tWL7PrYMum3BivCikyf3Y9sOtejkyh37rM8dWZctIcObC681BGqmoG1HmlGn9j+ZVEegSO6HB3vNEMm4Ja7LTwaiep62fYjuGk3zhoODg4ODg8OhC0eiO7R4YQuF5e0LQv1eBZmJomGqQgObjVvPHMherUtWFtCpOZ3ojvG5jjhyiBiCoBCbJRthgjZ24VMfMfnz4lUj6cKnlkVcHFBGa/llN2fzaUppFueEgmpbmtT1sp+wrZCZSgr6DRI0xxZCAJvdt9fuDm50ZZ9oeTwRxwVB4ee8YJ0STI9PimXf1oYGZMLspakn9WVluI58kZW0kahITWnx2GA//M7XWs/nRg0xi2PuKq1u9v10sENWXqptzcsvX1ZhRhosQ/DHZilRUePPpshEtHtBjGHoF/AYn3pSPy6+yBZDLy8PkvS2No9+jnEFmSMp8TFMnqMILz6bFBdDw7I7hFyf6FOvfL6NTht4BBdkVBX+eN2kKAaZiePJwH2/a1Ie2x+1K6/x7BsYz3794wE8H+j6IIqA3j0pj21b0NcwRtgKVoo2IAo037kwUPcleM79OnJ23cVPfxwkYFsra+eHjunzvggq0QXpjHH6xatHsa2NPF7nNxVoPefxD+i84dl07Yl9KSEuOqQwNdThZquRQrq0rCakoKMgxlft2EfdB3Xh9oZnKmzO1L6NoM5TSzdGVHTyuF4Z3Kbl12QP89Yi0COdU3HPbMFhBDNwbpFk1OlIZkGq43qh2JZ/rzWFBS21rBH3w7SekAMlAqcP7My1KPA7AUuWwH2HHZC8lrj3rMF0/5I1tGhFwLrINm84ODg4ODg4HJpwJLpDi1MroYJTi2xh8frCVSPpN2+s1W5e71uyho7plUGfbS6mORNziRpBKTk4RAZBUIjN0u7SKiNhgtexYceGB0pBv+pnm4KqNfyyI918eqU0i98EyaX+5rqCUt7s375gpeex/AQJmmsLIYDfwznJxIRQDU4/uR8r+zA0gGSsqK3neyjOC1kIdfWNVN/YSGXVdXxfY0qjuB6DWsTxhH6ZNO3k/lzoDh7LQpWYHB/Lvy0HGmT4VZGa0uIjIWYFthZXhPhAN8daxkEPWXmpFgpFW/Cynlgw9fhmBctAYKHf3WooIIisGBtwTJv1AtqviUQTY9iWwnJtv/jn1aNoz/5qSk6IZVK9sib8ONzPX1oeYoWFMXPGKf3ZB7h7RjKPH6hvIBfhfPHjLXTH+EFhxwUCf69lMl9VFOO+3DdlMI/Tw3tlcD9MiofCuYTO/NN7wX7q1TfwjEDu3zJ/hfZ93K8Ne8qC/c0roIox9c8/G8YEYm19Pd04JoduHhvF2XUYi6DAvnvxapp0dLdgcerDsVh6oDAl0dOXHEclFTU0d3Ie+/3vr6rj8RmkrhhvcZ/EvZLVxF5WI42NjSFjq2yr8Yd/H7A2wu/iPGRluZ+xeebYgfxv4YUvxusZTWPGtJP6UXxsNHuqI0jbWgR6c+ZU3DMQwFDom4LDKFDaEnsmUb8I/79nSh73eRWtXYi7ubZ3ON7cSXmcZSCP8UDn1AT63/o91DU1kQs0iwKvsACaOX9F8L6jPaHdqFlkuP67p+TRjT8eQMWVtVTb4PYuDg4ODg4Ohxscie7QLIDMwoJ9aI8OlKIhH7DpwELalOKIRelNY3PoyCPa88Ydm1IHh0gBn02hpMJm6bnLhnPRKx3QFkHYjO6bSe0TYnmThHbqpX5ujQ0g7I5umQ8SqlC7Mfa7+Ywkpdn2m343urYgQUttIQRuGDOAtpdU0q9OH0A3nxFFBfuqKC0xln1JQfabyASk6UNJKj+z+6bk0ZIVBeHqwg2FhER0WErJhcFAmukKFwp4qUhFYKSuoZE33MLGIJIChF6I9H46mKEqL+W2MO+KEdbvgihriadvdmaKsYAg2lFLrBDQ5pZcdwLPybrgGNSUOiIb/eL2V1eyohf3QVichPVzhUAHxG+NH9KVju+byfYOuV1Tg+PKlKO6Ucf83qwmN60D8PpeSVGMQAbIcvT/wvJqqq5v4GvHf9P//kWzxho1MNacPij7a1/7f5+HEY1HZ3fgf4u+f+GInq06f7RFoG1dsr+ax1fMtQim4D7t2l/Ftj6Uf4Cg1qmJvaxGQIb6sWPC74Lm5GCOIZiiw9aiClazy174CKRhnLDNz8jMLK+po/Kaeu4TsAeJJNDe3Dk1CoEBRZkvB4e9MurQTxHA7dQ+gVZs2xcSVMa4cNfkXA6EXDA8m6pr64NKf1UlH4mwIBJEanuH4rIYm8T9AHA/0OaO7ZlOPxvRM3ieuO/q+GLKIsM4eNsrKzjIh+LqyJhwcHBwcHBwOLzgSHSHZgEqUKh6sWmBokcHKI5s2FpUSVOfD2xIXVE9h+ZAVVKp6f8qUOAObU5Vp2HDePWJfZhkj4pC223gDTA2/61RcFeuF2DaGIcWIqwN7IqbrrE5Kc3iu5GS414QxDEsEEAcIZAmkyGmc1FhKhoHBRmItBv++ZWWTMB37j8roOpV72nn1MSwrJhQdWHTTW2FLITWKECovq9LoQcOpwKFBxO2rI+emckHvQ6AqYCg32wU0/mBFAJpZAqOoYCmjcgWKk22OFmwgn73k6OC5D6CWiqBrn53w+4yevaDTXwNaqDhaw+SCesEEch44xcn0D2L1oQcT1i4IGtNBcbnIT068DnKFgxyP/Ei3+DhDWsPrGOQ+QKlqe561b6p88oX/wbZ6oJegQCFrBCXSWxdwV5ZTexlNfL2mt0hpDEyIkzKcvZRHz+Ii36KvgHLFq+xWX3GtkBaQUkl179QiVfT2laXmSZqvOjgNQdAULB8a4n2HvjNqEOmxexXV9KArFRuv7ivWAdhbOyWnsxrGRTnRrYJ+g2s2JBJNmdS3kFfu0dqe4frOfHITr4y/HTrKlumAsbJrcWVFB8XYz0vBwcHBwcHh0MTjkR3aBagvBSqH2xkdESUF4EEhQ6UoKL443/X76Ez87oc9htPh8ggK66r6+yBG9EmhTrt5WuPp5//dRlv4nO7poXZD7XUSgMbZVgcmAgseWPsJ407kpTmgwE/xLGfczEp7kTROKgGjX64X+9ltZ/OX9pLVVpcURscq0DuxMVE0ezxuTR30aqwLAGbitRvAUIEdUw2G/kKKQdrjYuVFHoAm3ScS019A338bVHQ4/37KGB3KMCWoRGJrZLsu5+WHEvtE+Kosqa+2V72frJRbhs3kC4urqSoqKhg1gMIdPn8dMfEOdoQFxsdMhdXVNfRzpJKuvHl5XT+8Gzrd/EdBB51aln0E6hX/YzJuM9fbCkJI7Dxu8g4UesHyOSsWvBVHjO9yFi8L/zaxW82UqPW313tm3IAQv43+qdbxwSebSQFe2U1sak/6gp/4vlef2p/zywCKIcFbNkfcsBEPFcbEY3f+s/6PbRo+Q6tx7roFwD6N+x/ausb6P1vAnVAcB34/dkTc4MZcjrY5tTW8CRHn/nduUO1YxCy6VQxgOgXIN7xPXF9B6OeR3OuD9fzwLlDQzzNkYW4v7qWtn5bGZxLdesqr7UEAgn43ZysVO15OTg4ODg4OBy6+EGQ6I8++ig98MADtHPnTho6dCg9/PDDNHz4cM/vvfDCC3T++efTpEmTaMGCBd/JuToEECjSF1hMm+wwdpeGE0jYIGDTdHyfzKbNdxStLijl30Cq76g+mW7z6RAxhJIKm9n7zhrMARpBCAmyCe1LJi3RLlFk76Vrjqf6hga6c2G4l3pLrTSwocRmywZsVv2mcUea0qyiJUVA/RLHfs7FS1Hvdc9MpKBX4A6+xdj043Oi6PFf/ruRz/2SJgKse3oSddEUYfM6fzG2QcGG5zR+SBYXtdOp4TAu3j05jzbtraDHLhzG7bRHRhJtL6pkMkK021e/2E5PXXxcmM+/8NKGRYhD5DBlYvi1VdpaWM5kLwIZCCh3SI6jm1/6ymjX1NLzMmVtwMIFCnSvPgzrGB1Em81MjmcVrWh3L3+6lQtyoq8kx8VorYoE0JegvNapZfFv+F+bsj0EWSnU5vA71wHXjdorMmz2HWqGj8n3+aYxOfTQW+uDvyH75KP4KoILuL5/rd6lrZmgkm34dyRZCy0Zj3/oEM/Wb10Icd/ke4J2BRK0rKoupD8Cws9avCaK45qA+6veb6wVMO//e81uz4CJjYjGb2LNYQqWf7q5mAO4CAaZAtBomzgXdR6NZH6X64XUNzTyf3I9ET9tSzcG4buwozMFQob3ztBeX2vX84jUc103bmLuxFwv+vOpOZ3opjNywr7rJ4tMrEN05+Xg4ODg4OBw6OJ7J9FffPFF+tWvfkWPP/44jRgxgh566CEaM2YMrVu3jjp3Di+EI7Bp0ya64YYb6IQTTvhOz9chACzMTQXasJEEEfXuut105Ql9+DNYxJqUY/JGAovwR1watEMzAR/SJcsLwgrgQWUJi5Zp8wL2QQLw1f7zfzbQrPG5RhuQllhpYLPutRnDhsuvTUukKc0yWloE1HaO2Exfmd8naIsAIF3etHH3UtSneNjotEvUv2+zZ4FNA9TDcxet5g3vMxIBpypZhWrQBPX8bapYkC+shquoof2VdZScEMPXlxQXQ//30SZWI+K7cxauClO/Pn3pcdrgDj4HOxt4bDtFeutCJpHQXmAVsm5XWVC1CEOgbSWVtLjJex9t/rkPN7V6AM5v1oZXWwXgvQ7ySG5ftvkY4+HdS1bTO2v3WDNO8BruEXyUdWpZ9BNTkB39Ecrb6CiiK/N706bCck//chk2clYds1WSC7YVTGyW14Rco+yTj/OeP/V4VgwPykqlRy4Ypg0kyOM7rC/8qn5N4/Fzl9u9+dsCZCJaKJRNEIGH3549hOdv0xyl2qjo7rFpbjx9YGcuHKn6Xotg5i9PP5I2FVaE+YgLoGYPanSYgHZuUy5jbQybJHWNIQqwvnDVSLaaQxCrS2pCsI3JgVmvOVW+L7b72BxCm+d+ix0UbPB013cw6nn4taIzjZsYA5GFiPuK+3z+iJ5sFaWuG2xrCREgGj84K+LzcnBwcHBwcGj7+N5J9AcffJCuvPJKuvTSS/lvkOmLFy+mp59+mmbOnKn9Tn19PV144YU0Z84ceu+996ikJNxD1uHgIi0pdLEoF2gDQFpC4Tn/2uNpbF4X3lBlpSXSvYtXe6b1Ou9fh+YguGnSFMDDRvWYXhlaFSU2VSDTD4ZNChTJ8A01ErtNxDf8fP0cv7kp261RBNRGfGOzn9Uhkb5YGrBF8Nq4eynqU+Jjran2nOXSLzNs045NMcYePG/5PRCI90zJY2Xj8F4ZbPtjC5qYPJaFklENjNhUsTe9vJxuPXMg3a2MfXj290zOo2XfFhntDmpqG4zqRrRbkICORD842FJYHlaME+0Inv2PvLsh+HokZG5z4BVgKyit4n/bjoE2gswFBF4EkW6z2YC9EawvZIJZnafRD6ef3J89zdFfBGQVprCmUIPsgqwEgd6nU4AcbeehJEZgXh4TvOwW1DFbJbnaJcTSnrLqEBsbQZIDIP7vWbQ6ZJxQAwkIBIjsJvRnEL1++qNtPG6reOSCoyk2MYUV2V/v2u+7LkSfTils37VjXyU/B9TYAKkpFxxV7VB0yn3b3HjnxFyaOX+FNhCFIpGzJ+TSS59tDQuoiOeKa7IB8xmy2kywjRFoXzdJGZnH9EznzI/p8z7n6/GyKzpYBb8jCXqL69Dh+6rn4RX0x1gkxkDYSKmBPjyLp3ktERUmysB+5oVlW+jnI3t+R1fj4ODg4ODg8EPC90qi19TU0GeffUa33HJL8LXo6Gg67bTT6MMPPzR+76677mKV+uWXX84kug3V1dX8n0BpaWkrnf3hDZsi9rSczqzcAYEOcrJLWhJvTuHdalOziLTeg+3r7ND24Kcf2zZNaHfCrkPnewp1sA3NTc9FP0HhLWy6AJWQu2/K4Cablhrfx480pRnwq3S32QvYiG9sRu9eFB4gM23cvRT1sMcAUaDzX8e9xOvzrhhJcxSbE1j2IOMAAZNbxw2i/fBBTYxlJa4gt3Ae8EC24dvCcrr2/z4PCVBAvSbOB+pjOTAiSBJZOSgTcyUVNVqv3NsWrGQiffbCVWHnYPPG9et1/UNCW5qLoa5WCXQABHRZTV3I65GSuZHCi8DauKec7l28JoxY0/VlZC4If+D2ibHWwnlizNKpTmHH1ik1gZasKOBguSA45WwYHP/zLQfUnOqx8Fko0P2OCbBYksc99C1TfwMBJuw7UJcA9lDI/oACHWpxjAHozw+8sVZLkq/asc/Tx/vLLcV0w5gBdP6THwXHCL8BLdt43Fb7MdZ8FJfIgcou/TvRUxel8H3vkBxP907Jo7sXrwkbz0BQf7G5hPuaLeMBbWJnaRX/hk1dbZobbfcbbR1t5BenHcltSPX8RtDMiwDGMT7eVGQMlntha1EFz0niuh97dwO9cu3x2uLZXmR4S+Z68X11/vcKeqMWhA3fx5rea9zEs5aDG3KgD+NESkIM/W/9HrZ6uQaWe5WBrEKsGect28yBHxfAdnBwcHBwODzxvZLoe/fuZVX5EUccEfI6/l67dq32O0uXLqW//vWv9OWXX/o6xn333ceKdYfWBRbW8DC9bUHoIh/+gjePzaHfvL6GcrqmBTe3o/tmUky0XZEkyAjnJ+jQnH7sZ9Nk8j2F729zbVK8+smcSXlceAsFeLFBg4dyj/QkiomOYiVkdX0DtUuM5ZRz2ZvVdvxIU4e97k15da2n3YuN5AKpFoka14+iPi2Z2Argm91lTMaIDSy+c97wbKqsrWff4lvGDuTChkSNVFPXSKWVdawcXLl9H43u11Gr2PMiBaB6FSQ2zg9F42SbINWiAm3LZo8xYUiWlhTHvUYav64wKzb0sJJojtf1DxFtaS4G0Wwiw8qrwrNZbGjpfObVVnF8lViz9WUUwgM+31xk/V1TcADtderzn7OC+w///jrE11zOhkGfh3WSzsoF38H6AcdYW1AaLM4Kaw0EltTz1hVOBQkIxe7D73wd1t+eu+w4tu9YtaOUxw5RuHz1jn101Y/6UnZ6Et0MZbKBJL9lbA7V1jcGlfMyOY/P3Dp2IP3kmO5UVlXD3txeQczmKHvbWj9GRkFqaqrRvx/PSi4GikwijN+XP/uJrxobBSVVrFKHN778TERRS7l9qM/CK9MLBCmTqk1ztMiWALmOmgNewPFOOrIT9e4YqFGhZhxhPrEBx1KvG5Ysn20pCVqkqe3QpO72U3zc9Ix0BVsxZqhzvyh23Tk1gcdDBE5wnrqaCd/Xmt7PuCmPcXI2La6la1oiffBNIT367jchgTr8v1uHJK534uDg4ODg4HB4ou3swLH427+ffv7zn9OTTz5JHTt29PUdqNzhuS6rZnr06HEQz/Lwwb7KGt50/Or0I6mkopYX1Hv3VzOBfl5T0T55E/T8FSM8F7XC3sLBIdJ+7LVp6pmRzEUcVd9TKMKhPGqOTYofgMTFJh+bXpDVqUnxdAeIog2hxwGBBMhEemsc38+9gT2TnxRw0z3yIhJ1SjQ/inoovVAcTRzTRFSrxcJgs3Bpfq8wgkXAFhAACbdi274QEgekvPy8VIuKLmmJVnuMuxetMRaMA8n392VbeHxEcbZgIdweHaxFGXGNUNi3FbSludim8I+N4YgNA+0RwLMDESeTXGgjLQnA+W2rIptGBKsAP31ZtWRTYerT4nUQSpiv50zM5b+hKpf7Gcg8m5VLUXk13bbgQFFPEYS/a2IuFznFd6Ea75lp9qN+9J0DtjoCsGZIjo+lm5VCiCJw+sT/vqEbfjzAqNYV34cy2FS7Bef3wsdbmu317DUet9V+bPPvB166ZlTQexw++uc98ZGWdJUzE0U/w3zxxdKNYc8EzxSFNG3PwQ+h2tjYqK1n4ff5oo3iPO+dPJjKUcyzJkAuCysYP31Yvu6y6jprDSGsJZpzrVjrmJ4RPNfleUoeM8TcD9uZ568YqS12rQsGt8YYeLDGTeE1r2a0oF5Jx3YJ1K9zO/rj26FBuhOa/Pud5aSDg4ODg8Phi++VRAcRHhMTQ7t27Qp5HX936dIl7PPffPMNFxSdMGFC8LWGhoCSIDY2louR9u3bN+Q7CQkJ/J9D66NdQlzAwzE7nReh8CnGpgEKdB2Z9OHGwrDiZgKiQBm8K93i1EGFqR9/tbWYunaO5rRjr01TfWMjPb9ss1LcLpPumpxHBfsqmcRFAciyqjrfNil+IdRxIBm4uJni245zvn3BSj7+zLGtf3wvq4Sa+gZfKeC2dHkbTEo0P4p6+ZjY5N/1mr7QpigWhg0v7m8DNXKQT6fYM2XSyBkKcsFGnSpXVq796xc/sqrxcT6XjO5lJHDE+5c/+2mQJMEzMRVlxGfunJTLRS6FkheFL3O6BFTGP0S0pbnYpvBfumEvEynwbcazeVqZ68Tze/HjLdzGWtp/TcErNZtGDla1tEhxvkTsySTTqD6ZHNSCqrh3ZrK1CLgg89R6KQL4LbUfv712D1XXreTrgtpdLvSrHidQ7DD83HGe9y1ZY7RiwZiAbCAT8H0E32xWLkL97+X1bLLHst37HzpM/Xh3aRXVxpjbHl6/5Piq4HNFQNtmVyWPubDOUElbQPx9x7hB9M2eshD7MRm43+iz71kI1UlDu9LbvzqxRXOvbT7zmm/U685Miac/vLXeeM0g65sz1yNDw8srXIZo5/D7Rz8sraylmQarK0Am4VtLBNCa46YccMe5InCH4qK6wPy9Zw2h+yYPZgsvOSji9igODg4ODg6HN75XEj0+Pp6OOeYYevvtt2ny5MlBUhx/T58+PezzOTk5tGLFAe9E4Pbbb2eF+h//+McfrKrtUAUW69jcPLV0I6u3nrtsOG9OTUWUBCEUpRTqAZF5x4Rcen1lAe3dX8UqEFPRJAcHGRc+9TFFJyQHN2s2sglpyrABEZtEpFh/vrmExv1paVj6MjaMBwNefqUg8A/Gsb3sU+A361dJbiIKTBt3kBdQ74JQau7mUxwT1i62ugozxw7kfwvbBTxrkx+ryKQRFjsofFxT18AWO49cMIzT+IUFi5fSvriimuI9PqMj4mUVonhfkBM3jskxKnlXbN9HEET/8h9fhpAZm+4fZz0HB3+Awt8U8F2xrYTumTKY3t+w15h5EB0VxRkQreWZKwJJO/ZV0bd7y8OyaQRA/vmxc7CNCSc0ZcWgxgFgyv7AvI37YOrTNjIPx0BQXQfcc1jCyerQ9bvLKAOBUokkNV2nrYijGBNs5K3X92FBIs7d5vVcUFLJNlAg3dBvkWXy8bdFbPsB1bJpPG6rgH/3JScN8j0Geo2p4n30QzyTW+aHrv3lZ4KQyCtfbOf6I7BPU9ePaDOoPzJz/vKQPi3WBgh4dVYyKQBbjZBIIeYb2I8VVdTw/FJXH7AfQzsX2Su4brQD2AmZLKW46LTB6strrt+9vyrieaqksib42ygibCt2fdu4QVwXqTVFAM2FLuifFB/D/372suFUX9/AwZM7DYH5219Zwd/PbrLpcXBwcHBwcHD4Qdi5IC304osvpmOPPZaGDx9ODz30EJWXl9Oll17K71900UXUrVs39mFMTEykvLyA5YFAhw6BdDz1dYeDDyyOh2Uf2Nxgwzg2twsVletVqYIQQsFRbHqgaIHvI9LfJz/6Pivah3RLsxZNcnCQcdWP+tConO688dtUWE69MlNo7uQ8Kq8OKIfgNf7F5uIg2QRyhBVGUwbTXYtW01uKB7lX0a6Wwi/BdTBgs09B6rhXCnhz1bIXH9+Lxv7xPS4srBY/bO37pxZoQ7vAuYN8V4kQZNKIYqD4/G/eWKtkKXQM/g68cW1ZDknxsZ73ENYU6vdkFaJMKuE87pkcGzymSurdd9ZgtgRqThE7B/IkykB+Y4wAMSiTbhg7Zk/I5SKKVSDEDMQeAmWY31q78NyXW0to0fId2ufu1zYB/V5cc1l1LY+XCB5hzJTHBAQBEFxDH0IBzrDCuPAGf2UFFyvVXaeNzJs1IZcmPrLUeI4V1fVa4l6u0WCyrfAq9Ir305KiuH/rlOxeQC0LEJ5yho3ahtonxNKWooqwZ4U+D99sYU+iG4/bKj7aWERXn+aPGAcQBDJaVfXvSD3Sk2neFSPY0gqBTRsQWMK4f3l+bw5uHdWjA4/H8njfPSOZSeTNhRUhNTZMGSNeNUKam7l52sAj6C///UabvYKClZhr/AS20V+bM9d7FavWBTeqaxuCQXCvYtYo5j28dwYdDDQnqKEP+gee35bCctpeUmmcR/1kmzg4ODg4ODgcfvjeSfSf/vSntGfPHpo1axbt3LmTjjrqKHrjjTeCxUa3bNlC0R4FKR2+P8gLcmwQzjq6G6c86nwGhV9sZW0dK4iPzu7AyhxskrGJmHpyP2qfGOMWrg6+sXxbCT21bGfwbxAjF4/uFSTNxw/uQjPPHEjzs9MDlheJsawyxQZUJdAFDmb78/IrPdgFuEwqcqR4mwgNvI73vSA27iABQCABslq2NQIUfrxtxTVcfWIf6pWZzIE6ECIYf95eu5vViiBNEGABSQMVOpTyGIuQUSPGNGEJg2ybk4/sRCce2SmMVMG9uWlMDj301noa1DXNeA9BvqCYLI4nEzji3siKdAHUmTCRkBg7TQSug3/YiLLszBQmiFFkVB47BGG8zyOgA4/01oSfQp2iX9kU4HUNDexr/P43hSHe7So5KMaKtTtLjdkfCDDg/uhIdBBeIPCuPrEv3XQGCnWCiKulgtIqPgcbmZfZLp7+9M7XYX1JHkNMSncvhTPWJxv3lNGvxwzg/q36Omel2QnSuJioEL97XRtCkGvJ8h08nqiFIXHsrqmJwft7qKxzENDGvUXB2aioqJDaAADuF+YGAZNVlfCcRuHoC55axq8Nu+Q4X+N+NEXR2MFd6PQ//C/4nty2u6UnU7uE2CC5POWobtTRoED3U1egOZmbD7wZHpDC37DmQuAO99AP2e21VjC1LT/WNuprn2wu4mKauG84T9g5qc/3YBe7bu2gBoAx3itAczCFDQ4ODg4ODg5tE987iQ7AukVn3wL85z//sX73mWeeOUhn5RApqYXFNDbHWamJVp9BEO0g2LFxQGorNphYuF/+7Cf0wlUj+XNu4ergV/0GOxcBQXwKX85FK3YyAYZNb07WgQ0lVGs2HKz25+VX+l0pEVVFV0NDI12R34ff03m2IhWdKMWXMgxWFvD2PhgBCr9FFkFe3Tkhl/3TZQJQWEdBpai+JxcOFMQA7gV+p0vTJh0kCNTusv0LyJ6fjexFK7aXsBJSvYcgLKAsZPVpI9Gf//tNGBGv+uICOAcQFjpF4bpd+5t1/xwiI8pADpvU5ClNRUVNEEVHWwtehTpLm/qozQsYWSFTHvsgGLgR7d1GDsJuwuu8MJ7KylAmvF5aHqL0Fu0cgQCQcCa7HLyOPuWlDkU/QODgjldXhjxDELUmkhC/nZEcz/12xrzPuQbLzLE5VFZVz/YauIaa2nprQDEuJmC3gT4NoA3BH1+Q5RgboKIWAQ9dYUj4wR+aAe0Pg3/L7euYnulMEEPFL56NaMu3jxvIz2BbcSWvJ6HUh92NPEeDsLU9EzHu62pPoL3A4/7uKYPZLk3MVTiOaR7ysl0Tc1gkymg1c1MF+gLaPYjdg7lWwHmg3c9SfP/xXGBVhHW4fG+xLmikRrp9wQrP+RL962AUuz4YQY0firDBwcHBwcHBoe3hB0GiO7RdyAt9kAZx0dH0uzfXsjex6jOI94/KTmdPxT//7Bgm22Kjo2iGtAgX/3cLVwc/ePTCYbSuqC5EEaUWx9IRty3dODXXKxWfgd+wziYCr3v9htdx/ZyXTtGFDfSlo3vR8X0z6ZenHclEEPor6he8s24X9RnS1bcy7LpT+x+0AIXfIosgGVWSHMDfc19bRWMHZ4W9JxcOlEkvOW0+JiowXunsX3AOQ7p1oON6ZYQQnLD+AFBQFmQbfh/nCssH+NrCX1n1tsZvwcbg8f9+wwSB6pPvxseW902/RJkJKfGxVmIP77cmvAp1QlWrs3OAIr6qtp7bkxogktu76ZplZakuuwxe5RMfeT+ozoYKe+Z8EG6h91Y+3vR5n9NL1xzPxJw6DsLqZeOecuu9gEcz1heiP11yfIA47ZKaSP9Zv5vHMhQhVknCORNz6Y1VBfT00k08jqhFYXH+sOuxBRTr6huCRYexlrlgRDbdfEYOW+PU1jZS9/QEJoRxXibP/FkLV1mLsh4KAe2AMpzopWtG8Xxy/+tr2C/73sl5HNgWdiUgwO9evIbt/C7N78VtVZ2jbQWWTYU55TZ7wYie9M6aXdQ5NZHfR5bPnv3VlJESR+XV9axOR7YV2lU72B01eYDb5rDmKKO91OVoN2jDQkVu8zZvSdvBc8EcJQJI7RNjuRbRm6sLuG3LwbmvtpXQJ5uKrIV2ZZu81rawao2x2jRPoA3iu/OuHEEfSJk534ewwcHBwcHBwaHtwJHoDi2CWOhjMzG0RwdWt3y2pYQuP6FvGIGuLU7WvyM9csHRNH1eYHMPUt0tXB38Ytrzn9MJuT3CFFHqRlolblui8mpJWjE2bvBiRzDpsvw+bCMiCowV7KukhLgY4ybU67h+zsuk6OK/GxvZduF+hRzG5vjso7v7VoZdc2JfI+mWEh/LpBssIqBwTU2KpfTkAxYZfshQQRCCwNpoKLJoKw4I8vwSKcgiQw3AqIS1SMk3kWN87Oz0ECX+f284iW6S7pXwYZ92cl86Iy+Lvtp6wEJGJYbwuo4gSIyLNip5D2dE0jdbWp+gQ3IczTglEDAK9dLPpNkTc7nYbN2exhYVI2zJmCUX4z3rzx/4au+6axZFVj/fUmIoMHqgdgDODZ7TJsJLHA/fL6uqCbPLQT+vhho3wz6OwqNZ7k9y30H/w3pCqPX5XiTFceHf8Q8HikhDNQ7/aVFYWLabu+/1NXThiOywYJgYYxZOH81FQu9QlLm4D3dMGEQrt5VQ/y7t6ceDjjCPQYeJZR2PtfuqOFiBe42+OfXkvlRV08DzQGxMNPtnD8tOp537KrlgMjIF1PYuZ2CA+N1aVGksrqva+cDWC+PlohUFYTUv8Lz+9/Ue+st/N7JFFsbd859cRk9ddKz1ulBnwzT/6VTvYgzwCt4DcruQg2Eg+JPjYzk7qbS6lqJLo5pNWCObQg0gYS0+7aS+dNmzn4bcT9jzPPTW19rfwfdvPXMgjR+cFWJ19UOvJaPLlMEYJ68jWyNY4eDg4ODg4HBowpHoDi0GFvpQF5XV1AcVQ0hLFQBhhI3AMxriSZB32Bx9taWEC0S5hauDXyAAE5uYEmxjIqtB3Uiryl20r3vPGswevSBwoMTaVVpFr3y+jdVypvbX0rRibIbhxQ7V01Hnd+DNu876A31KJpGhlPt0czErL3XH5UDWS1+FqavV87IpuvDda6vqtNkj8Djfvb+KfwOEQGG5+XegeMV14Fxl0k0E0m55ZUUYSQ8Fm0hj311axepvBOTk61HJUFgD4DnDfzdS2IoPyu+p5KRXSr5KSuL7UJvL90oOKD767jchStrOqQn09prdIcSQliBohLVMLs1dtMoR6c3smyBWVb9q2efXj+dwz4xkGj+kKz9zPOfu6Um0Ytu+oDK7NXx75eM1R5nqRUDJ7V13zaLIKgo26oJHqoUWPP/9HC8pPs5ol4NnafN1Rz0D9EuMZ7r+J9T6Iog3JvcIKi6vpacvOZaVxzhmft+OfN6yAlUEsNAW8rqlhWTJiWPjmA9r/NpxH+a+tprOHNyFJjz8Pj124TDrfThcLOvwvOXgCTzyL3km1DIE9xxqdPRR0QbV9i6eKby5l6woMHp6C+JX9OluHRI5cK17XnNeW0XjBmcFyVOib5l0x/r1+StGcBaHOi6gXUK1rjs+2ttPh2fTDf/4MmzuArEeExUg72XyVrRRWPzUNzRSTV19sIgn/o+5Fnjo3+tDflOdN/0Cv6nOwQfW4sT2Ore+stL379XWNVBudjodTCD4YKqxhOcSSWZWcJ5QMmUwjyLzDs+9qLyG+jTZCjk4ODg4ODg4qHAkukOrAAraHfuqginMUAvJhFFSfIyxOBleR1HRc4Z1Z1WuI9Ad/AKKQ5FCLhSRUBjKxbF0Ks0theVaMveeKYOtG6eWphULQsuU6v9ek5INlgI4P9U7+8Bmn0I2lNjsm/qXfF5ehJpMgJmyR9jyYGIuv69LT8em9rUZ+fTxt0Uh12i6ZmxeYW8DVSpUqEs37KXFimpQXIefe3Nsz3QmM22wFR8U74Ewg+dypCn5giQU5KawLRBQ74NOSSsfQ0cQQMV52ysrmHy6uSklv11i63pwtzVE2jdBhMF3Wb3/aEcvfrzFVzYUxooz87rwb8M+RGch1Bq+vQKyMlX2yLf9rp9ivF4ZOCDqqmob6BYDuSYHj7wKe+J907FE4BDWKOh7CKSptk3wdf/jW+vp+StG0oVPfRRGpIv+p45f8t+qJYgYO8TrN/x4AD367oYQayecM9Yp6Jsmv3bZk9vrPhwulkziPojnohbclecHQG4XpvaOIs9qMAnjNeaGe5espnfW7gm+/tqM0cbnJdotVNk4Puau2eNzac6iUCtCeVxAu0RAWQfTHIfzvHX+cjq2VwYXPhcFbW1z7JxJubR5bwVltkug37yxJixYKs+bkSjA7YH0vXT9af05CAEIK7Lvux3jmaOOAoJX6niN1yPJXPW6fvRfZJLhHmCedfsRBwcHBwcHBxWORHdoFUC5AxIBKcwg9mKjopnUHJrdgTcIV//ogMWDjMbGRmqoLKU9Bduof1p3Sk3yXrQ7OJg2QCiABYIX6d5QAiIog42gvBGC4lynxIJdwQcb9rJVQHlNndZPuaVpxYLQstmNDMhKpVvmQymltwu56kd9WCUpb7z9qh79EmpehMCdC1eFeYerBTFBZsuKbds1gxAoabK6AalhIj3EvYFllKoixnN947oTKC05cI1GJWu/TP6sDiBiOrVP4A00AjFn/uk9vg5ZSex1D3tlJtPbvzoxSG6qpLvtPshkZFJcNP3ihCzasnkTbd6RSNldj6BO7RKCNh23jhsURiRtun8cHa7w6psovLl3714qKyujhuh4mvWvLVpLHrTdSLKhZNsU0Wd1qkn4MLcGISOO59cH3qsY7+bCMnrn1yfyea7duZ8V+sjM6ZYeOhdjTLRBkKToN6bCnuh7XdMS2Tfdq1YD7iEIMthDIbin2nfgeHhOahFjMYap45fNo1y8j36Jv2eOjeIxCQGqQVmp1CEpjnqkJ9GYP75Hvzt3qO/7YPLMP1ws6+Sin+K56IILYtxD8FNtF7r2npYcXnAZ2Qm3zV8RQqAD5VX2oCcySMTx0QaQ3aNrI6jhg2cPwtoUSPWa4zjo+fJybtf7q+q4jT/4r3XaOfb2BSs5oIrfNGUb4XXYIUVConuNkyjMO/X5z/nfYh7zayPV3FoxfvBoU9/UPRfUF/CLSDJzROAV+5TCwkKeO9q1a0eZmZlhGXDbiys4q7G0spbH0JysVN/n5ODg4ODg4NC24Eh0h1ZBVV09JcXH0gNvrGWCCymx8A7eW1bNmwqhTBdoqCqjspVvU+WXr1FV4U6a9HDg9T59e9OVV0+ja668nDp06PD9XIxDmwU2lXtKq+kyKV1ctVPAplPdjMmKMFltqX63pQVJxYbUZifiRbKi8Ocf3lofcg1+VY84vpng6hii4Lf6in+9l649sa/2fVxfZko8+5XLsF0zAI90XNOFI3oaP4NzEpZRqnoPhM3IPhnBNHgoBu+AJYxagDS/N6dtg9AL9TTOpKkn9aPznvgohCRRlcS2e4hrh92ATByoJITXfSgsKqaqL14j+vpNuubuTcHXEzO7UN7p59Nz999IA3tmaVWahzNMfVPMNeecOoM2fvNtyP1MOmoCtcs7laIT24WMIVBdRwK0t6KKGs/6H8Kq6bv0gUdbxHH/s34PdW6fEBJ0Gt07gxqjoujWBfqsnJ6SVYR8f3VBArRzvL6uoJTumzKYVbJhKvLRvensxz8MC0zprHjQB2HrpJLkAoLkNpG26vjlN3gFwPMcQDBWEIpLrsvXWoWpEO+bimEeql7Lo/pk0LLtVdraDvg3gpOLZ+RTWXUdLZqRz+0Pz1zOJEBRTb9QyXUEsd5auzvsc6g7YgOIe7RbtGOvOQ8+50ekmgNTXmM73j9veHawKDWCtaYMMtEmPefNKntwS0UkgXTMKyhq7cdGqiW1YmSgXQTrJDTVTMF9V+1XBHA8UR/FD3Hv5/rFOBJfV0mL/v5X+vNjD9O69d8EPzPgyL507dQZdPHFF/M+ZXNhOY93cj8/nAPaDg4ODg4Ohzocie7QYmADDPXuA2+upS+k4mPwe378Z8fwZ1A4UaiyKjd+RkUL76PG2mo6azjRuReieBnITaJ/fryJbr/lRrp37mz65z9fpjFjxnzfl+fQxqB68qokqG7TaVNdqwRqcwuSyj6vmxSCWYbXprmhkZhovjy/T9AT1K/qEcefOymPblNIM3z3hjED6I9vr/d9HglxAVsG08Y6NTHUZsGLfEpOiPH8HM7Jpii9Z9EaLhYHFR882WW/cZAly7ftYwsg4IWrRtIl+6uDhQM7t0+knz7xoVZliGssaFKv76+spakn9eXMG52fvU5JKZMQtuvD2Hj5GT+lqsoKOus4ogcmyGPjLpr/j4fo6Fcfp3l//wedNWm8VqV5uELXN4NzTV01/fg4IvAaIffz3ado/9L/RxkTb6GkPoG5KlK/akEeiXZms2pqLVuXSH3ga+sbaMnyHWFBo/y+mdqsHBDUsAtCe0bxR5Ba+6vr6O9XjqCPNxXR4G5p9NelaoHRgLVCjw5JrO69ffwg7iPbiyv5fVlF7rdWg9cYBBujA8cP2K1c/uwn2u/6ITgFsF4B5L4qxgVW2iu+1joSXy6GCTIUBB+KZnrZ77RVQDV9+1l9aHdpdcjzPiY7ne6anMcKb1kljkCNbMmjU6FHApPCGPZgpqAnnhdqGOAZec1P8rhgqk+AjAUbcAyZqPfTJr3OC0SzDiZVuK0otdx+ARGY9bKRammtGC+bvV+cdqT1eyDQRbDLi7g3reEQSIEffGZKAs04uT/97923aNzZl1NlZQWdfRzR3OsOzB0vf7yRbvj1L2nWHbfRY08/T0tKjjBmzzk4ODg4ODgcenAkukOLgYU1MhuxiITFgkwgYPMOoIAjVEk7Vn5E/315Dp0xpJGevrKRuihi83NHNNLOEqLLnqyg8ePH0aJFix2R7hARdJtO2RM5NTF82LMp0OTv+i3uZ0trxuYORTFNG3uvjTg2sWLDKLxaRXFRQCV2YW8jipPhHGBxI4ohik06Ns4gnx65YBgTSF5kb+A8460ba3WzaiP6sVFOjovx/Bzuje1Z5XRNpdvhl67xG8e5PHDuUHptej6fb1piHP3uzXXB83vusuFWv/ONe8rpnsVrmEBHwUEoCuV7iIKoeK46yCQEiEXdswfhu3f+HBo7hOipK2xjYxX99JzJbmxUoPZN3M89vuaaanrj5TnU6ezZQSLdr6pfJo+G9ugQ8LT3OZZ8Vz7wVXUN+kKCGwo5oGgif0CygTifqxRlvG9KHv1tqa7AaCFhITBxaFe68aXl/BqUtiYluZ9aDV5jEKybYGWFz63Yvo9W7CimRdPzqbq+gftZJL8l3sczRHBSJRRR3BnXExsdTROHdKW7lKK+nMlycv8giS+r9cXYdagS6MBj//mGnvtsd/CaYYODMa93x5QQAl2+L9uKK+iZS4fzs4tEhR6JwviJ/22kBdNGcxFRNXAslPJPXnQsq4kHd0+zHiMxPiZY9FNHLMNSxmadBDV+TFQUt1lkb+jWIjLE3GyaD/F6oqZdm1ThsFGavXAVXTK6N2qIhpHVN47JofOf/MhYVNvUdltaK8Zms4c+du1JHgF96R7oiHt5PQarlXuVTBm2jrr4WK6DgKKqfueOK56qpEvOP5sypswKCcI6ODg4ODg4HNpwJLpDi4EiYJU1gUWuSiCIDcCnW4rpiw3baNmTt9LYoUSv/rKRYg118LBgXfirRpr0h0b6ybln0+Yt25y1i4MvsLJs+74wv2yQIuXVAaImPSU+TInlpQiTlaleqiw/ac3wMP2NgYyHp7ZNOScTO2LDCUJXqB5vGTuQU+brGxrpw42FNOHhpUwOy+egK8zGx85I5muDfzPqHIA0gvenULwLkllssG0ba5XUFPYGoJnle49ngU0tnhP+bbJBwD2BL/H63WXG5+RFYCItHOnpYlN93an96dqT+tL73xRyETEbemQk0fnDs/nfUNzCMkg91hvZ6dTZQAbJ90p99rAc2bfofibQF/yywY2NzYTomxu376YfDfup77lm4oNE/154H2Vd8wydNLiXb79qmTyS260NNpW7l6ew+n59Y6OxwC9QUllDdQ0Bz+fmWEFARa5+F+3bWCT8671045gB3D8wZkCRbkNheTXV7myglHj9UtQr8JYYEyDPMEbFxUTRKQO60B0LVwYD+vJ3vchI8T6IVRSnFgSrONaiFQXB/n5KTifO6EF2CsZKQeLDOeSYnumcBWMqGBmpvUVbAtqhfL1sCzR5cAiBbrI6wpwEr/PmwqQwxjntKK5kpbwaOBaZEfg7v29HDr7Y5t5Fywto+daSEKskdf7TBdlxH+ZOHhymxr93Sp5nVoNxPuyXSXdMyKU6pKZJwBjx3/V7uP1eeUIfntcgZoFdGoq6fvBNIf8nMiTk+4GME7FWiMRyyE+tGK+xTbXZk4Mt+LffNZFK3OvWY6cP7MwBBdh2YYxMiouhe5cEirdiLkb2Egh0zA22uQNz9aQ/RNO/muYO2RbMwcHBwcHB4dCFI9EdWoy0pHgqq67UkpFiA4BNadq2D6mmuor+eoV5YSqA95+6vIGyr6+g5557jq677rqDeQkOhwCwGb00vxf7XT+1dGOYX/Y5w7oHCWyhRBJkrk2liA0cfDnhuSpvAEHGqogkrTklPobrBsB+pl18DKUkxFJcTDRV19bTNI1diKycM/n5omgfyKRH3/k6jOiSz8EWCMCm83aNlzj6MY4NP2O/G2z1OLh3vz1nKN9HbOqhxENQQxRGgw8zbCRwHBRQRS0F2AOAJMP53fv6GrZsMMFPMES3qcYGHe3DRti9uWpXsE2hrclWBGLDD1Lziy3FrFqNj4nmDXq7xHDCQL0vLz/3JN1fU8UKdL9jY4/rK+jhv/yV7rj51/YvHGbAff7fkpfZEsfvXIPP9biumo7YtYx+c+fEZpFHwr4DGQ02mFTuXsE3U7sV/VJHpMNmzRYbQgHRSOHVx3AeINBX79hHY3KPsH4WgbMdJVWUHB+tJcmwfnj64uMIo7M8nqE/3jkxj37yxIdBT22QYnOaCHTxXZl8NAXx0JeRrVNdV0/jB2dxgeNBXdOC9xTHukQZd0GE1tat4u/hHlZU19OpAztT+/hYLj6JMRzjmJc92KHsiS589QvLDrx2MK2ObN7/WR0S6ZFn9MFVAPN7dseA/78uuC3PvWgTtnPVza3xMVE0+7VQAh24e/EaDlQTNYa0bxzvivw+9NW2Ev4tBKNuGpND7SfF0pbCisA8s7WEJj/6Pgdt5FoL8PNftHyHdu2AIqZivNAFm/9x9aiQoth+4eUznhQfQ9P//kXY2IZ1GK4NfQ41lV6ZejyvC77YWkxDu3cIruNE8AUFPpf6WBPJxL1uPfbvNbu5feDeYh23dmdp8HdRPwNWk1Cg+56Lr6umspXvUOqxE/3eMgcHBwcHB4c2DEeiO7QIWKTesWAlDc0OpLKrZKQgFi4d3YsemfNXOue4gILDD7LSiX2BH3v0TzRjxgwm0hwcZDxywdEUm5gSbHeFZTW04MvtWr/sWa+uDG58szNTuPgdlGcgmipq69nvF4pkWXHNab6XHMce27JaDBtAFK7cp5CkftOaTYQYrEJwPlPnfc6EA0hkFLeDX+y/Vu8ykmUgbV+6ZhTdt2QNE9ImpahqTaNulE2bTty/6Kgoev26E6hDclxEG2zdcbpSuBIT9+S3b6zlTfHNYxMoNiqa7l2ymq8FqlKQ0ziPAV1Sw4qCBo/lYYWDQMXNLy0PU/7heu9evJrT2YkCRd8EdCQavg9VIcgLWLuYCp3iWs5/cllIIUVVkYfMg3/+vyfYdzWSsXHKsUR/eOgPNGP6dOqQkuDvi4cBQLSgEFyk9/Ps4URffPoqdUn7fbPJI/RNkHh+6hNEEnyDDZHuffyN68VYoZJiOIcPNhbSuMFZ2nPH2MYKXIM/slpo2K8tCoqBoq+i7a/ZUWrsqzg/jGk4byi7Z08YRHNeWx1yjUdnI5uonq/vprE57IHeLjGGUhPi6OzHPwgpSgniVD6OzpO8vr6Bz+uy/D5UVVvPFisYW1EAPTk+llW7WWmJ1Kl9Ip2W05lJWCjQdeMuxgCo/H/7+tqQ444f3IWmn9rf1xh8KOHCkT3p9q4d+RkhOIr/GhqQKXGgj7SW1ZFJ1QxN9pLlBWFztfjPTy0TQYKLYpWqat3PuYo5T5znztJq+tnIXhyckdcX+D/sjlCf45qqOoqPjWbPcvSbRmqkTzYV0UNvfa2di8RvyAEI4A6l3gkg/oYaH/OUbrwAMg3iAC/YasWg/3++uUQ/ts1fTkdlpwfPRcyZK7eV0IjeGVxjSe3LKP6Nfonxy9Q3BXEPGzs/67H9TRk5GEsrv3yNzh4ebuHitU957cuF1P6YCW6f4uDg4ODgcBjAkegOLQKThhv20mdbAunLUI2qBAIWuH9a/Dlt27SJfhehUOPs4xrpHw9/Q0VFRZSZmdn6F+DQpoEikdEJycEUXRTHFH68KtSNb2NUFPuDqoSprOyEUvzRdzaEka74LRTnPLppAyjSn6EQg7JMtpGRN802dRT+hvr8hh8PCKbFw1cW/uf4TRP5AMCL+54la/hazh/Rs9l2ErYgAF5H6vjBIH/ke7J4xU5+DdcsiCiZfIHHLZ4R9LDqs8tOT7KSJbHRUdrUeeCtNbvpivzedHzfTJo7MY/tbMpr6llpunNfZZhtBojHm8fmWAudAoKwmP3qSpo9IZd9X+V7PLxLLK1b/w0XLosE5w5vpJeWbacNW3fSsTn2Z344obCwsFn3MzDXbIxortGRRzrFM9oOxpJh2R2YmEtNqgnJTvAKvsHqwPR+wDO4nzaAg3Hs5CM7aYlytMv7X1/D/0f2jtwv8P3ZEwfRxEfeDzueH1sU8d5xvTLojvG5NGeR2Y8aEArdeybn0bbiSoqOjgraUV37/Och/S6/6bsygW5SyMv2Iv+8ehRnvcTF1lF6UjzVNDRQRXUd1TY0Ut9O7ULGNfFvBAPUcVe2mUCtl5vHDqRLSqt4/MI5TRnWPVhM1YRICte2FYA8RLaOmO/Ec0LgUrQ/rywGrt2xpywsc8dPxgZUzXe+tko7V9+5cFWYD7b4nqkYtFys0usZ6kh9zB3qecoZXTKRjv/Q1sfmHUHnPv4RPX3Jsbzu0PmDI1CgkuBibYOgjil4IzLW8D0UJVct76DYt9lY2exY8H/cX5DiqlIcljNQzOuAz6KNyOcI8Lrq3Q0h1yn6Mv4TanlY6+gI9EBdgxJW6fvJTKttapcNlaVUVbiTzrmQIsI5wxvpn8t2UkPVfopJSo3syw4ODg4ODg5tDo5Ed2gRZNIQBZNQmGl473TetMiL+WFdk2gb+1FH9vvi8/v373ckuoMRQhm+s/RA6rht44sNoS7dHps6EEpIK0YBOZDat8xfof0t2Ubl083FtLmoIsxGBZu5Ry8YxmnZg7ulMWEDH10UIYRvrroBxG/OHBsVpvr0Iq6gYBPveSlFZTsJdWOMTbjNY/lgkT86ElEmXOR/qwpTvNczM5lVpd3Sk42FX7HJ32DxUwcS4qJpTG5W0FdZACSQbN8iANWlTV0pt5EBWal0y3yo4EOf4QfrtvP/mzs27twLtZ4j0QXKygLP+LuYa3SFhtE+X/x4C5Nz8NxFLYbUpHjO2JLHEtmqxctT2Mu7XJ6HVeVsckJsmH0VMKpPJrfbIT060NjBXeiS0b1Cvr94RQGT/ir5/sLHW+j/XTacbSNgRSWChbBvuWBEzyAxLtr+t4XlrIb/5WlHEmp94lpVZa8g0n/94zrq1TGF7l28mmaceiR9uSV0jAx4S+fRuY9/GHYPvMY9+EJPeewDJjEf/Pf6kP5t8ipXMw1kT2+QxXLh0P+7fAS9vXYXdUlLoJ37qq3n4rdwbVvCtOc/pxNyewRJYhFkvPRvn9ALV42iOxeu9HxGmF9+8pcPjc/DlrGB4CTmVQRDVcC+45YzB1prmagQz14OmsjBccyXJlIf1kKqIl4XWJWzN/D36L4duc8h8OBFhquA33lxRWhgSYWYR2ElpwaIbL70fuq8wJYFqnKQ4vI48u3e8rD1RKjfeWywhgL6lEz2664TwPODYh5rPogZTAG6+dce752Z9vLyYFHo/362q0Vzx/0T+lH6Ed0927mDg4ODg4ND24Yj0R2aDSys57LyR/UXHUQTh3bltFOxmN6wZQct5OJBkR1DfL59+/atfPYOhwLmXTGcsjplBjfDJvJXJS+siusNe1kFCb/L/ZW1vjal2BA+/M7XYSQ30pGRnv2pkpatU6QJgJwShLkgz23FxS4e3ZtTz4PHtBDucuq61lKmn91jOTE+homM1laj60hEeSOqs4mSCQAo00CgA9jUw/4C6l2Qj6lJsex5C9UpyEYb8LnbFoQS6AAIIWHfgvT74OdT4ig9Oc6afSDaiIlsj4oL+ME3d2zMzEiL7IuHONq1C9gRfFdzjVehYfQX9gPWKGSFDYOXpzCsMWxAAPsiqV0KYBxASA72Vb//yVHcJ1B0GLYNIhiU1zUtpE2rhLGsUsdrj5w/jIvwqfP+r8cMoCue/SRk3EDbh8USMmUuevpjeubS4dpjCcBbPLdrEntpF5XX0N2TkRHSEKynUFOHoEQ9v981LYmtXvaUVVNCbAxbMcAWRvWdFuQ7rG1MWSMmr3I100B8H+O6qUAmgnArtu82jsH4DH7Xq9BiW4RKEiPIiGs874kP6ZVrj+dMJlOBSMxlndon0GMXDuNxFMUxz8zrEnJP1HlbJbizMwJzgDz+CpRW1lIfJePABjwjZLf9dHh22HNGezrv2B5GUj9gLbTXFwkuF8aEVRqIaGRjeJG/4j6J+Qb3orjCfk1iHsX6xq8vvd86LyDxdfPbM5ccF6J6T4mPpbTkOHrgzbVh2TNi7SHmTFPmgljHwU7PVjBWFEk1ZaahbgmuSxQCrtpfQvNbMHfMfG0DxSQFgjib7h8X2Y84ODg4ODg4tBk4Et2hWQgurNWF+Ia9bJFx58RcLoAkUBmTTEd0z6aXPt5K546wE1kyXv4kigYc2YcyMjJa9fwdDg0M6ZFOjbEBQgjp1/C09eN96qX83FRYwanc864YYf0cNsvYvJoIUiYT3g1PyzYp0oC6+sZgivMB8vzbEPU1Hzs1gd5es5tfF36ood8JJdzl1HWjpcyGvezFavJYXrS8gFOodSpBACnhgrxOS46l9glxVFlT70kU6UhEORjgFRholxjLhV/Lqmu50DFUv6ovLooArtyxz0puVdU1aN8DhLISwDOfM2EQb9pn8bFClXByIEIQFyZCIDoplRIzu9DLH++KaGz858dR1KFLV+rsMnRCABX5gCP70ssfb/zO5hqd77+AnzoJNk9hvA4bEqPncP+ObDmktmuhyBQWvaiVgP84ePbSclae29qlyPh4/ooRQZU6/PtRd0E37zdQI503PDtk3EB2CGyRRF9IircrNBHwkoN0uDc1dfXUqV0C21jcs2g1fdZEYN//xpqw650zMZeLkL4lEekg+C8e3Ss4TurGafRnKPKFD7Y8VsmZBmKcByloKpA557VVdGyvgCIXUM/xrkm5fC9u8lD2tlXIJDHIUtxbPEdYtYAg1hXuxDNCwejznvgoSH7jXo3snUGbCsuDdUcwvuuyAlQyFrVSVmzfxwEiEdwEQb1xTxmTvbq5SBfUwDoWz0kXVEVmx9xJedq+7WVbg2AC2hCyQRAAQx+5b0oepcQFKlkiKGQDlOvCaoaD7JccR3GxUb6sljBeIKCkg87r3W+dF90cjmfUISU+RPUu1zcxrYnEnKlTdMvruHYJcVabOwTwTJlpaIe791eF1W76tFcveunjzRHNHS99HEWJmUdQdKIT+zg4ODg4OBwOcCS6Q7NgW1hjMQyv0Gfe/5Y322Kz0230WfTyP/9IO0v8FXwrKCaa/wnR7x+8zhXrcdCioKSS7v73mmBbFIVAsf15z+J96qX8FJs3bDZNhfewKV2/az+3baQy6+DX6kP+TaEsE4Q5Ntmzxg+ihkaizYUVTJ7L3rOAvHlW7U4AKPRA+PvxYPbyWMbvy4XMBPGAew9FF6wSfj6qJ43NzaKbX/oqhHAzEUVe3tK2wADsHW6bv5yJM9MGXfjiwiPVRG7BsxrqVxugrMR1Qnm+aW85F5y1kQE4l6DKUCp6KisoQai8k3w9PTj31ojGxlc+Jbr6pmtp3yHor9wSYK64duoMuuHXv/xBzDVeATthTWAje0B+m96/e8pgun/Jaq0i8+/LNtO9Zw0Jfp6DZ02FdU3FwGWgr6NPQD0OohOWGH5tJjBuZnVIpIVf7Qi+9r/1e8xK5P4d6a01u2jZxiJWoN+1aDV98E0h9/tVO0rZXgbHMBHY+HvOwtV0aX4vrgsh7gMCqxc+tYyvRTdOm8hYeawSmQYoQOo1rrOi94wcemvtLvaEl5/J7tIqVtPPWqD37sbzfe5ye+D2h4qrftSHRuV052vtkpZIL1w1giqqa4IBWaEelu8niPXoKOJ59HIli0EUAx8q1R2BfYewG7PVooimKLYoElkPXJNg3EDK657Glm/I9vr42yI66chOlNUhKSwrS9QwOKpHB2NQFc+rvKYuzFsc8zf+bwJ+u3/ndvR/H24Ky2JANhVskX486AhPMly93nun5NGrX2znYLF4Xf4O5j3YTCEwMOHhpcbzUy3b/IxfpjkczwiKc/lcvNZEKBwKf3jcj937Q22R1HWcV/BRZASZMoXk9oZ/P/ruN7S/7+n08rtPRTwXH3Xu+bTH7VMcHBwcHBwOCzgS3aFZ8FpYQ1kza0IuF3rC5h6bnT1dRlJU3ON02ZPVtPBXAbsME+rqia78azQlJyfRRRdd1PoX4HBIYNbCVbRs24HUZ95cP/MJb4BBPEOxpfM+tW2+5E1qkMiNigorECZI5aOzO7Dfrw5eijT5fWwasYEUZAJ7pDYdB16+2Ahe83+fBYlieQOoFjMU3weRdf9ZQ6h7U5q73/4L25PXZoymrUWVYSnSwgMeRMQdr64MuS+wU4B3+Gebi8KKCdpsE2TFJ35bEMzYk84an8vnsL+qhu6dPJiJMDzXJE5fr2Xlp7Bw8CK3rj2xL13x3Kchfur4bSjoX19ZQKfkdLbeF6gZF8/Ip1mvrmJ1rnx9qrVA78xkOmdYNyqrrqf8vlATx7FX7u//tY6vVfgq47ltTD+GKDbB99h4xV+jKT4hgd6qG0C/OAT9lVuKiy++mGbdcRtd8VQlLfhlw/c613gF7GDNILIoEBAKWJaEj1smmyIQ7DPHDmRlrGo5AS90vC8A6xOQ52i76Edn5Hbh45psUECcg4RG0AhjAArs+hnP8D0UeYZ3+YAu7YOZGSCpYEOBKKdMIuPzl+f3ZnUtxhhcC1TLOVmp3E/QV4NFB219fMNevjbZMgbnLsYtKNpV2CxeQKw+Io1VgoT3GtdRH+OTb4vY0m5G07iJ53HnxDyqra8zWn3o5qO2guXbSuipZYGi0ACuF2vAET0zaLmkHg7J3NhdxkrzW19Zqf1NBGxwD8W9AamOuR21Bfy0AzVIcot0HMytvTumsNWQSqCLz0PJbAOeq+otjt+1keAg81FkOiybA8dvJDqmVzo99NZ6unEMsp7WWgvyyte7pbiSxwesf9CmUTw0NiaK7cbgYobr+t25Q3kMsNneYTwSwLyIgIBqHSN/XwRHdPUhdM/Iq+/geawrKKXfnj2Ez3l4rwyjh704pq6AKzIbcJ7weJczhUTGATJO2iXE8pw8d9Hq4DW1yzuV9i/9fxHvU176/Uyqi00OnquDg4ODg4PDoQtHojscFGIgOiqKlbPDe2cwMYWFdHRiO8qYeAu98fIcmvgg0V+vaKSsdL2yAwvTN1dE0eLF86lDBx9yEIfDEh9+U0jRCaEEMTZD2GTDJxtEjA62zZe8SRWqbhQahU+pzncTm9zbzozRKiy9CkyhIObi6/IpNjqK9u6vpm1F5Uwwq8eBglqoslTCXJwnVKc3nZFDl5XVUFVtPSuf8fvCKzyS/ltb18AEukgZV4FN+h0LVoQRAYO6ptFdi1aFkF5+UsZlhSKT8wtCCUFVwS58pi85vlcI+ee1QUfh0GN7BpSN6jO/e/EaTv83ZR7gdRCKZVUBEuz8EdlGNav8d6iHfUd67rLh9Lt/rQtR1X6yo8b32Hj5U1H0xnKiTufcQsMH9OAMA4dQYM74xz9fpvHjx9HkP0TTk5c3fG9zjS1ghzEDQSNTwVG/xf1kz3Mm2BNj2QJGJtAB+JuHFRSExcjkPIqm1SE2KGjvsEERKm5BSNvQIyMpSLif/2TAmmOvYl313Ieb6MYzBtBNUTm0tagiOM4JAh1A/xMZI/jOhSN6NiswCeC3RZ9GAWaV3PQKvGHcLa+pDylA6DWu430uUh0VRS9fczzVNTbQ7tJq9gaHkvZQxEcbi6hd+/YhgcTCsmrK7phM90zOM/YNkOh+nyf60G3jBnK799sObIp14G7FkkX+vKmwpQACXrrfBQl+25kD6f7X14ZljgzrmR5C5svAvHL9af25fspFI3sFs0sAqPtfX7nTWK8ENjUICqjzm1BvQ3EPlEg1V7RFymMCbXtLYTkXa33fYlUmW6vo6kOgkLoKr76DQDXIfrE+8PKwR5HUMwdn8VpAXjchmIB7IQfstXVg+nfk7EV8HteEfcqJ195P/37k1zT5D42+546eXe0BeAcHBwcHB4dDB45Ed2gWvJS8SMf8amsJ3Tp2IHulgiwC+Ud9jqFOZ8+mfy+8j3pcV01TjiM6d3gjV7dHcR740iKtHsoOLEx//OMffy/X59A28I+rR1J5YzxvjEShPFNasgps+O6amMuKJKivoP5UFdcA/o1CXLaCeNhMI00aSjl50wklF4hTnfIQ/QSbYqEYh2oPirEtxRVMfmFDOCw7nbqNT6KTj+zEymuhyoJnK0gzELpC+QRfcFxDQ0MjtU9MDlNt+e2/OBfcBxAhJpiIJ/G6THrpYHs2rG63KNhBaIEwOH94NhPIYmyR/cdNSIoLpOnDIufrPWUcvJCfOdoRlPQoIioT6bKqd0dJMb8mH0slakzEDbeD19cyGQfyX76PSR5jI3xXMTZGxSVQp3NupTE//nFIartDKMaMGUOLFi2mn5x7NmVfX0FnHUd09nGRzTWyx7+s/I4EOoUmgP4HtSTIG69sDT/F/YTnuQm4ljsXhtsPoa/Blghk3a/H5FB1bT2rThetKAgbC22eyyCjYDOlGxfw+ZvPyOH2jt+A9zWIMlOQDpBJUluRYR2RD1JMqGZhjwEFODJWQIjjPPZX1fEYguuEUldYhOhQUlnL1jKiACH8tgv31xjHdbwOP26+t1/vpR3HV1rnjkMF8LvXFlvt15GmndyPymrquD5GFyU41C3d7gGvPm/8Btq7XEzb9j0v+5CK2tDnLn/eq71/sbVYa+eCdgcVODz6RYFLjB9dUhNp/e4y63nD3gvAfH5aTuegAhvrG5v/dyBbq85a5BgoqazRWpohmHbHhFxWqsNiRyXQ5c9jfkNtFN38I6u+v91TxkE1WNDBCg21GxoaG631TbJSEyOa03CtchDSFLA31oH5ei8LEl6/7gQqrqhpumen00dn5LRo7nBwcHBwcHA4dOFIdIdmwY+SFxsHsYGUFSwg0rOueYbKVr5Di75cSC9JKcAo7AZfWqTjp6WlfU9X59BW8JO/fEQ/yu3BxOeFT30UQqT7SandUxbw+zV5aYuNXUq8fajEsbARU32J1+0qZVsDQCZcVMU7CNvfvL6Gbh47kP7yv29CSGRsbo/vm0ldkpPCNpdHpFKzYCP2QBbDtgCBA5N/sRfx5UV0qc9GpFhX19UbjwfFblFFTZgPuTy2eBVWW9IUtMB1XXx8r6DVggDOAe3olWuPZ7Jep+oVKn75WCpR46VuhWpOvl8CSZaxsX+/3nTrXdfQ6ZN+Ql07Z1qDJA4HiPTNW7bRc889R489+if6x8Pf+J5rdEpMEUyB8jsSqApNtH8EcMb+6T0teatma/gt7mcqkIj3EAyw+ZlPO6kfJcfF0MCs1DC1uoDIgkHvVscoBCQXLt9hJKS3l1TStf93gDT3o+aOtMgwzkMQ+fj3gqmj6fVVBawAv2P8QOrbMYVuVwKdGAtkda0KXI+493gfBPmoPhk07eS+LBBQxyIERj7eVGhVxuPcdM8C429bxc9H9jIGDnGfxg/O4swwBIPRHoUqGFlWpvuh+n8D6DuirfuxZPNSrFdUhz5z+fOmWhz4/Rkn9+OimQjOqJlN+E5BSRVd/LdPQsaOe6YMZuW0DWhvAAJ2qJUgwzQfi+sdm9uF5y31ezJQjPP8J5cFLc0w13dPT6IV2/bR5Eff5zYOKzdTJhlev33cILoyv7fn/BMdHUVPK23i1JxOXPMAxb/lQLXqd+4XJms63Ef49NfWN9Anm4rYugXBawTC1H6ONoTghZy52JK5w8HBwcHBweHQhiPRHZoNEANIWcXmWGdzIW9IZAWLsHZJPXYinfnTS+mXP8qiuupK6tetE2VkZLgiog4RARsxKIexAROKPzXN2AQQpLbNMjat+F1syOCdCeWzqjhDyrA4FtRZYkMtLD3++Pb6oA8xvgufVSiyRPqwwMCuaTT3NRScC1eK3vbKCvrtOUPDLB4igY5c81Kt/cZAtGPTbSO+bESX+mzkFGv2SzYAY8csj0KeNtJDDlrgWI2NjcHxSMagrFS+Pz0MRKlQ8cvHUokav1YDOiJRjI3tj5lAL186mDomNlL79u3d2NhMwKLluuuuoxkzZlBRURHt37/f835Cta1TYmKsgV83skCao0iX+5Za18CWreG3uJ/N8gUBIRviYqPZSsFm9yTsrV68ahTdFNXIFiV8LVtLaNzDS7k+hImQzkoLHTNMY4QoAolxEr8x78oR9OXWYpo9IZe9i219HEpaEIFi3ERdBgQ2Mcb17tguLFPIayzAbyYppsiwfNpfVc8BOLW2Aq4JNS1E0WVdH8f5L5w2mtXtuiKybRVDuqfRU8vWad8T1igoUotADSDaKUhNPE+MiF7+3/Lc4TfDwxasQVvD7827YgRnHGBeF2sCQC3SjeeMTAcEalB0HOSsaT5CxoM6dmAenzspzxroVa9TANcLEv7W+ctDyGdxn2DnhuDtb95YG1ZzRAZ+V7Z8gYDg/z7aHHI+UI3bAMV7WpZ9fYUxFGOlep1vs2XUaibSN+6tYOu5XrCd6xAuEvAD3ViF54qMkb8t/ZatcUx2NKHXFD7GRsUn07jzLqP8ST+jhqr9FN9QTd06Z7q52MHBwcHB4TCHI9EdWgxbqrK8gVE9JqE+mn5Kf0pOiqX7luykh/v1cQtTh2YBm8qbx+ZErGgCWSr8ctXNMkgcbO7gJQpyasnygjA1OWwDemUkB48lb+plSw+1aB++e97wbN/qZZwf7AeaS6LbyDVVtSaT7bgHKFYm28aIzb1OBSj8h72CEiabCowXaoFOEBsoWnfawM782vkjeoYVORNjiyA9QMLBSgqp+qWVtVqbHtxTFHLV+cfa2g7egxoZJKtoMz2Uwq2evq9NBetswYYTj+xE/bOznNq8lYC5JTMzk//zAlTbJiUm2g3ej5REj7QuARS7fj+Lfull+XLruIH230iIDbY1WEnIxKLc10CU795fFaYw1QXLBdDG0xJjQ8YM/B7GT9RPkYs6wv7hsXc30HuSb/R9U/Lot6+voRvHDGACr6y6jklK2GjBfgI+zqI4sNzH5TVHbEy0UYmPZ3qtMhaw2viU/pwxoAuAieLNOojP6JTUw7I78HV6BTDbGvAsbMA9wX+wz4HqV1b3y3MvlNHw9v5iS+iYrRubdRkeuI/4DohitDV1jBXzC6zSoArfWVrFhLho3/dOyQux6pGfM34HQRn8jXYqE7QycCzd/RDkN9qV+JwAfnv6yf1p3c79xjkoOyOZ7psymIuIYj0gAjcg0JHFdsGTgWw8Xc0RATX4oFt3tEu0q+XlQENzxlAQ6b84PVAEnv/+1YnNbvs6azoRUF/qc3zSZcepayYO7o0fRAnpcbRla0lIlo+Dg4ODg4PD4QVHoju0CLA5MBXiM6XiQm2KxT82vdigpCXH0ZAeHaiw3Lzwd3DwQlVNA71x/QlUUVPH5ClIJa/2BP/fO8bnBj2wxcZKeJRjIxwkpxT/W2zI4K0tqw7lTT2sSWxerGrRMi/1spfHuwl+/JRthbdMZLtOBbi2oJTunjyYfc1lYgSAeh2esPIzUW0qVu7Yx+TEI+9uCPPVHdk7I8R+RVWVwdde+K++vWY3nfuXD/nabEE+EITYwEdCZOEe3fnaKk4NF8XMUuJiQsZBGzmOz3VqnxAIwhiCDTJhZLLncDh42F9tV217qbpbo67I51tKgv3F9lmhWvWyfLkrNtpaNBdzuWkMEH3thY+30BUn9KGqpsCVn7FNKGXRx3SEJ4gpFBhFP8IY8ds31oadY+fURC56+uW2fWzd9ef/bNCqcVEcWIUYV/dX2sdPUOUYP4SqHOsT8OeJ8aFFozFmQLluA76PMQuKaCjTBfA7IEG7NhV7PpT6sVegRwQWMVarc50akFg47Xg6M69LsAaIOjaHjYntQq1P0pIp2NbKq2vpnGHdeU4SqnfVt12eS9CGnr74OE8LNq/5GsEdHQrLq6lnRjKNH9I1JIsBfv1d0xJpUFZ7a7tAhlRdYyN7rEMxPib3CCbCBYHutx6MuD9Yd6tAhomfsaIlYyQC87asQb/zni4jwcsHX117qeegrpnkQuF+ikA7ODg4ODg4HNpwJLpDiwA1HlSZSNtc6pGKK4pPycXE8LlbzxzIqe1Tju72nZ67w6EFeF+e8cf3ItrgQGl55XOfMmEJJTs2pVBhYROJTelTFx1LqPPl149Ytm1Am7ZB3YQLdbIJOo93PxtNv37K+K3/rt/DxDCKdsoKVJVst6kA8RkUDQwWZFQ8xeXzVjfw4KagQjX56soKMlVVBtX80g17g4pCP8B3bP6xKuTN9Vtrdgdff+aS4+iS0b2psem8BDkOYm6ppngbFHiTju7Gm3moMoWqFqRdRko8VdU10NbiSn6un28uobmLV4coMt3G/eABJHKtB0HmR4npBfSTuybl0W0LQi0P5LkTJKIYT0zWFSLYggLJNuwtq6a5k/PYEinMz3xyHu3cV8nWCre/slIbMIymKLrpjAFcMBHqcRtgV/XK1OP5s8XltVxfIS0pcB268UkEukBi64g7MVaKmgXyeI0g/BJNEVSVvMX4aENGu3jaXlwZ/HvHviomVN+47gSadlJfLoiI+wACfXdplcWXvSMHyY7plc7e6Bgjcf59OqZQVlpkRRPbEjBv2jy7EZTAPZ00tKtn+0lJCPie6+6VLdArj4nq9x85/2gqqail25X+pptLLnv2E3rhqpH0i/r+1NAQsFNSs5m8so0QEIJgRM3kaJcYR5W19ewFjzYFT3bMQ1DO+20bOKcJDwdsi3TwUw8meH80hU79FNj2gtcYifZiyvzy+4xNa5HapuKsftZeunNQ10ymQuE6IYKDg4ODg4PDoQ9Hoju0GCiyBo9Y+F2WV9fxAvXDjYVhm1oswIWHqgAWpVjv4v93LlzFGx23GHWIFGhbSMmOdIMD9ZxM4ug2o379iHW/bYO8Ccf590hPsqq/sNFuzkYT56+zSBEbe3H+xRW1tGj5Dm3RzjkLV7EtSsG+qgAxnhTLhc+wmdbdW7xu2mjL5w3STMbgbmnWFHlVQSZew/1BEEVVn3ERPwOx49c3309AApkPN/zzqxA7oNioKCZDL8vvQ0lxKLZYx2rDgpJKDh6o54pn9Nr0fLpN8X0XBRK/LSynuJhofm6zX13JgQo3VrYuRJAEWQa2TAI/Skxfx6usCStGLJN18thiC1r5GW/2VdbRRU9/wlZHt40fRPsr66h9Uix9sbmExv1pKR8P/VEl0AXw+syoHFq8YicdKxXgU4F23CEpnv3I1ewKdWzC/QaRiOPCbgdWH7rCpPJYqY7X8HT+akuJlkAX2XA4drv40GwRGXg9MTZaOw+U1dTRZc9+GuzbUAuDBJ5+cj9+P7SvdqRZEwbRpKYCjfK1H+pE26XPfEJ/vjSfEElUFdwzTu7PxPE7a3dzQUrAK7NCB7QX+NrLWUBiLvMaE/E6j98+Mijw7LYVV3K7QyHZzzYVhX1PWJeZ2pMocBuSybFsC/c3WIGp/SKStuEnM6UlvyWCVY9cMIyLiJqC4c3NUsXrHRIPWMVBcCBEAIDfzDkZctDkG01gQAbs1166ZhSvYXTZZ+qaz6Zs1wkpHBwcHBwcHA5tOBLdoVWAhXVFdR0lxsZRVFQ0fakUTRP2GFD3qiiuCKhRsWh2i1GHSAHi4uLRvcKyHnRKa6HabpcQyz66+6tq6O9XjqD3vzngiRrpZtSkEIeXronAxes9M1PoucuHU1x0FHXvkMRp2igchuJjqvoLr6vkk2mjiddRtAvKdt5YJsVZU9ixecXv3WFR6D132XCaqRQJE6o0BNH8Qj1v1fbEb0FOFXdPGUxbCyvClH/4b8l1JzDxYlLwRgJTQAVki80jGSShIOhwvTpPVrx250JN4UOpQCK+I5TKzv6q9SGCJML2QUeS3jMlr8V+6ALtEuKMbUY3tgiiSIxlUJ+nJtUw+eRlD4O+hjZ6yysr+TrumpxLH20sCsly8Op/m4sqmPA6beARdEpOp2CtBzlIh/63t7ya2yt8rcVvqyTY9uIK2lxYEeK7vnZHqbbwn80eafWOffTrMQM4U0WtvzBnYi7/G8StKMxoGl9nzAtkyKkBR9ljGef0wpUjadq8z+nqE/sEi0fidYz3yISBml2dR5oz1rQ1DO3egabP+4Ku+lEfuv60/pxhg3uJ+wLxxLxlm7moplw/BMT3gKzU4L1GEAW+36Z7hTEPtUR0c5ltTJQzn2wBZbn9Y0zH30/8b2Og4LXk3S/a3Z0T8zjALAcN0J6QlSSvR9Auob2/7cxBdPbjH7RYzewnM8UvTL81MCuV7aTwTP4/e98BZmV1db2nV6bQiwxILwMoKiAlimKhCvk0Ufwi2BKjaIyxSxFsURNjIqRpjOb/LEmMIgJqRKNRsTd6F1DpwxSY3v5nnZlzOffcc8773jt3YGbY63mImdveduraa6/dz6OIaDhZqnLdgBoFCDzrIgBk52D8jYSwls+5uqYmyNdeBY4PsU//jnbbHD0g6cdqT88K7NnOf4Ybg8FgMBiM5gUm0RlRQ2xsDN350ppAYSSkW5eWV1N6SoJQX6qejSpqlNTLSH2fGccnXvzp6ZSRkUFTf7/SauGBNrX9QLEgid+12Cag2JtK3uib0XBUX2jrb2/aT50ykmn2xP5079L1Icq8GSO705SF74mUbhA4sjAliPWHLhwiioZJtSlIcD2F2WXRgte37DtMT6/cLjbH8Ao3pSLLjT2ySLwUekjD17+PjTE2yPi+X1JRP2/dE9wrRd70PtLm73llrShWpgcI/v7xTkECeBXxgzoe9xxqe9xvbIJNaeM2ta+L5FNrQ4DAAbkIH9sBnTKCCJyRPdr48nGVx7h7ch1ByIgeZJBEL3YoVeJds1PDCho1hqLUloGC8cpEhpms1TAebdtfLDJP1HHPq/+hvYIYB4F487n96NLh3Sg+NlZYqjz8+garz7RKpIPIRHHQ215cZbSxQZFEELEgYSXRiUyOiYM60a9f30grNuwL+s704d3oqqc/oV+c21f0CRBktvoGGF9xj3B8eKS3SkkQ1jPPfLCDVn1XFOR9bLuWrNQEcT2/eWOz+Kfj9RvHhF1noSXgJ9/rSU9+skdkEslsIhCZcyYPoBNap4SoxDG+wtrqrhdXhRR3ttl2oE2Y5jK0yYmDykQwWlU143jw28c/BGu6tUl1Pl9kD6ljNtqfaLu1RONzOwbU7zJj5OI/f0C/OKePKNoLqxi0jWUWayHMl7vr6wBFQ83slZkSDuRvocgqFPjinn5TQBN+966wmbE9Dy87OZmlqlu7Ietj1nNfGEUA8K43BZm99gjquCj7cS3VhthMIsDROq1OYOB3XPYaF1EEWr+e7b+c6PwOg8FgMBiM5gsm0RlRAfwuQajJzY1UXULB898tB8TGxkSgY5MFv9RwvBwZDIk+HTNof1mdCtiGxPjYEN9hkw8q7ARevm6USNVXN6PhqL6wqYRaU9qiSNUbCB4UFANUuwZsuma/tDpIhYbNqpfftZfFDDb6OFco/W45r5+1CCA2mEin9vo9EMy272OD7JdE14+jk5W4bpevrl6oGM8ABRhVAl0NEDz0P4PF366N/o684qCxS1WngnRTgXbxwPcHUftWSUEqRhRcROo7Cs3aCEwXQffkzNMoDoboDqhqOJyrOm4yogM1SGLKLAA5Gk2Eqyj1ykDBOHKkYGC5IIt1L2e1PeljoGdB3PQkWjj9ZPrLe1+LgLm0U8H87jW+SsB2CeOS7fMIMp3TvwPd/+r64OLC9cryX5zbRxBycfXKb1wbgpGn92gj7HFaOYoQuvr6N/kl1L1dujXgKK8FlkouP3RRczSG6MS2accFeS4BOzJTscyMpHjqaJjPkIlwhxZI8VJmQ3Chf14dV2WblH0INQDmv7I2kDGBjCBXQBljtTpm43nj7zatEmnmU0cKxKpAZscr14+iSx7/kJ67eoQzswQ1B2xQyWETOW2bx6LZxlADwDS2oL8i20uuFRBoRiYfbGm87ORM1m6wW3GJABCsCDfzTx0X1XXFT8/sRdW1taLOhRwLn71qeFjjsmtcHFO/BrFdD4PBYDAYjJYHJtEZUQGINNPmBirR1IQ4mjy4k1GRC5XSrnrlSyQexQyGS80JggQbKhuJrCp8sQnCZgsEqb4x9av6ghrtsbc2B44niTgo2my+65Go0Pz4raP//XBYjiCHXMD1hOPfrgOEll+YjqOSlf/++Ri6Vinip25UrxvbSxTk1FO/oZazEfyHyqF4tW/0oV7TSTX5Xdg+ICtAJQSKK6pp+ardIeMYCPQTW6cG2ggsqhB4WLOrkNZ8VyheB/mGQou6zQWODfIdasZwnoHf4qkMOiZew42hKMVnYHUA4tpkR4H3USgX363cXUM/+FOofZrentQxEL/x7NUjKIY2GBWc63cX0pKvgusmuPyCTXUMKqprPH2poYgNsTWqV6lKWyMQ1rMn9aeTTsii9hlJYhxwFd/16usIWiDo4HUtKNAKklW+ps41sBX7/h/qsqKOtwLAqAvRt0M6pSbFi/EMQQ5bsUwRbM4rsc7LtjkRdSV0uIo+4rmelJMdINERKHcFlOH/jUCADDoJS7CZp1FxmXusRYFbP8U0XfOoJIf1TBPM4ziHRW9tCZp3ot2+bNltch1x8z++DPRbW+DMFQBRAwO4D/iNcIqAu8Zg07nLdQX+qXZqfsU6clxGFt7OgyU0ZXBnUWhVz2ZccMFAUVOCwWAwGAzG8QMm0RlRgU6kSXXQQ6/Vbcax8MUm9fbx/ehweZWwmDhcXkkr1u+h7m3S6xejR/wyGYyGqjlBvMI2Zf/h4GK2LoUvLA7uX7beuDn1o/qCOhhEC2wObF6rJoRrY+TH/1iSCzqJpUOSdrbfw33UFeAqvIgDv+eN1z/bUUD3LF0XYqOBosU92qaJwpsq0bg9r9i5CUdquqtAGYhuF6mC99EOQAAgQDJbswRSSXBJHEjPavi9gnzAM1CLpdpsLhbEx1oLsZlU+HqhWUb4MCk+o+U1HA78KkoxZ7rsKIrLK30V9tPbkxyf0B4LiisE8Xi5odgp2rj+e66xDeuA1mmJgsTC52B3EUsxxuKh6u/ZyMagoOeWA7Rg6TpBqsMaSf09E5nn1dexhnEphWWfw9oFRTTlGJUQHyv6v15MPRKv6+aMKQvfp9ikVF/FMtHnYK8S7pyYmRL6e64gDp6rDHgAXs8X70/I7UjDurcOmmdQUNsFtGtkqcDWA4WgTUEivA5lvoscNmWaoJ2pgXnV03397iJhX2QK/Jvgsl+xZaOZghThFto0WVCZ5kEJiG/0dYJrDPaTmWe6164MNQB/l1XV0H3L1gm1Oe7FTDXToqiMCkoqOKDNYDAYDMZxhiZBoi9atIgefvhh2rNnDw0ZMoQee+wxGjZsmPGzjz/+OP3tb3+jNWvq0jZPOeUUuv/++62fZxwd6ESauvDGoh8bqie1hTiUZJeP7k4dMpLERrioFHYv0fObZRw/SEuME0XLiiuqxIYGZAey6qcuel+QGC6ohA3+f6TkBzaK85asCVEqqV6rNoRrY2QLHKip6Dh/oYLPybamImNDmZ4cL3yK500ZSHejSJq2cUUa9/wlR9LkVYCkA1nX0PNWVeW2Ap0gKaCyVZFebxFlKxYHcsu10YcHugsgUiQBgBRzm4JWJw7w37mTBoQUY3XZXEC9birEZvK0RmCDs3YaBpe3uEsZ7od8aSxkpSTSQ69vtLap+6cO8izsZ2pP6hiIbBwbQWYizG2EtwykP/LvjUH9BvO+jTyru8YEWrnN3M/0czAp3W190k9fb5OW5PxMdmqiGC9RQ0PeIwQILnv6U+sY5CoAfCzbUmPCaw6VamRv//1gf3Pce93uK5xi1F7HFDVIDAEtEKm2gBReR6AI/Q31UK4b25twRH2tO3fyAEG4ushhk82JSljbLMH8qNJt4538ni0bzUSYhyMKgNXjbS98ZQw+m+ZBnBMKmobj9+43k07ea4w7tzruhQp1HFXPUxZIraxmWzUGg8FgMI43HHMS/e9//zvddNNN9Mc//pGGDx9Ojz76KJ133nm0ceNGat++fcjn3377bbrkkkto5MiRlJycTA8++CCde+65tHbtWurSpcsxuQZGqOpNXXjb0m2hJEPhH2zo8dlpJ/HzY4QP2+bwron9xWbJb9FHbHTl/w/XYiWgIDNsFKG8vOX8vnRWv3aBtPJo2ETIdGOo25BuDKj+x3KjqxfvlAAZce/UXJHyvmL9vgAJ9NMzelJSQqwg7OTGdd7kgVReFUzGyU2kXz90lTCaM2mA8FSFh3Fakj9VuUmZiO+d0799QPGtb3LH9e9gVb0KGxsPNTc277JtXTIsx/lZ3dP224JSXzZCEqUVNZTZNiFQiA1WNLDC+urbYE9rtFlY2zAihx9vcT1g44eIamzACsXVpvC+ikBhv5IK+k4pGKi2J5x/r3bptPjakaK9w0pJQieGc1qnhtgw2MZXr3nfVDwQfRYqVPy+DSYi1JYpo/ZJP33dj50PxkM1OIH74qp3MO1k87rG1pb+dqXbr7m5wDWHpifF05sb9jm95Zeu3h24lyKYOzWXHnxtg8guU+2+wilG7VoLuOZhW0BKnQMxpoCYhd2SnkkFxfK/1+2hRf/ZSq/eMEYUSDWRwyZFtUpYu6xrXEEL13gnv2dr+7bAmS1ohL6rWtOgqLuXfZNNbe53/eWVSYdxC0F4+XxtRU1t99BWIFU+d1OdFAaDwWAwGC0Xx5xEf+SRR+jqq6+myy+/XPwNMn3ZsmX05JNP0u233x7y+WeeeSbo7yeeeIL+9a9/0ZtvvkmXXXbZUTtvRjCwmLx36iCaU293oC68vdJtrxjdg/3QGREBG5g7LcWwxu8sEO3KRiKrikz8f/jrTvv9yogsVmx+opI0uqasJ905YQDFxaynN9bvi5pNhFTNwWJAV3dD0Wkq3ik39j3bpQk7BBDouocozkvdTLo2kX5gIoywuX1g2iA6oXVqkKo8HLU+zu/uKQMFeWHyOq6lDUayTv4e0u9dCkNkOMhz9iJr8Awk6nzR/aeYo/1BfYv7CfIW/4UqcfLC9+rS+S85OchaA97wsLZpCarVYwFXf7WRf36IqMZ+HrBCcwHWDjpkYT+oNU2WV8gAgR1Ft7ZpgetE//90R76RGEa/UJXkcnxFzofaj1Do0zXvo+CfXjgU40FZdTWdnJPlGfSUgB+6jXRXxwxkJ7n6Ot73W+hVHQ+h3LeRm/gb2T0LtbbhakstCbY5FAHUdbsKrd7yN5/XVxTqVO8LCGzYDOlzWafMZGsx6tFae7G1VT/zsNccqI4ppnaPjAX0FwS0cB1+FdXqvBOujUo44x3mHVPbl+sIFRv2FNGTM06jx/6z2VgkO2BN88IqumS4O/iMficDeC61ufM3PPptJyXAueNAscgqQ1BcJf7xbFz30FQg1VUnhcFgMBgMRsvFMSXRKyoq6LPPPqM77rgj8FpsbCyNGzeOPvjgA1+/UVJSQpWVldS6detGPFOGHxSUlIvNzV0TBwiljd/Uz9raWvZDZ0QEpMrbNofw1l5+wxia+/KaoI03HD46ZqQI//JdhaWC/MJGe3dBWZBiORyLFS9PTvjx/vGdrfV1AaqdKcqRpPibihMi9V2qs3SLFLwO+xtJoOswbSb1TSTOE0Sv13naCCP8ffuLq8Q96ZKdGnFRx7JKtzrXZPegqkrvmzZIqPF1hSFeh1JewiujAaQjiHQ8C3hXQ5nmgiRH1GDOWX2PZF/hvtqsbSLx0Wf476+mexsJ8d4QmMYBL9sCdcwyfR9jBIp2olaAbNOwUEIBSKmml0rrdzfvNxLDsp/I4BTa6PMf7RTZKnkIhMUQJcTFkCaKDwGIzDd+/j1B/Ktj4df7D9Mt5/WjWIINjNmqSlUsr99VZMw00ccMXJurr8tMAr+FXuV4iPs80hEweNfQNlxtqSXBNodW1NTQ7ef3p4deWy/sxiQhDsIW8xaChPozlf7m+pgIRbSc53Vrs3umDqJ7l64NvCbbKoI1FdVmNbgL6jPHM0RwGIEt9C2/vtyudYVpDlTnnUhrq/gd77zWERKoQbDoP0d82vXMu1/9YIiwrkH/nTmqu6dFEgh8eU+3HSiOyNrIT7/F89LrmiBD8PkfjxDfgyd+RVW1OBe/HvN1GYjBfdm2HmEwGAwGg9EycExJ9AMHDlB1dTV16NAh6HX8vWHDBl+/cdttt1Hnzp0F8W5CeXm5+CdRVFTUwLNm2JAYH0eXP/WB2NRAJSnVQV4KTihR2A+d4YKtH7uIRGyY0a7kxgpENjZJUPw++V6wH6+uHAo3M8KPJyf6Anx5+3XKsH4uErsInSw7sW1aYAPoUmftO1RXLM2Wlq0WKWzIeboIIxAjO/JKRHq/XxVouASBDv33urVJo4cuHCLah9x8Y0zCdWzdVxuiYsRopvveS3Lv1W7ZdYrklERaufWA064APrrPXDWcWimkEdon7q3LozZSH/1jjaY0F0dybyMh3iOFrX/BNsBPoMn2fZDjD7++MSR4pqvpYQvTu0Mrev+lNdZ+e8f4/oJMk9kRD7y6nqYP7yZIyrP6t/fMUmmTniiOoSMhLpZ+9+YmGpKTJQg4Sa5mpybQj578OMjWCDVVYigmpJ+NsYwZrr7uNZbagPcTPdY4utVTeVU1/f7SoSFK2JbUj21zKNrmgiVr6bP6Qo2Yd4CuresC2xf/+UNn0VkVcu4qrayi2ZMGCJuXkvJqSkvCfS2gy/7ykchUuvGcPlRcXlcrRX3efqC3ieT4WJq3ZG1QH5L2cS6gn3itK0xzINoG1N2xMTG+PN0bOt6ZPOH1c2rbKslq0QJCGWr97wpKfVvoRMsmy1Wg2WS5h/aDMQs2Qer5+T328RIMYzAYDAaD0cTsXBqCX/7yl/T8888Ln3T4o5vwwAMP0Pz584/6uR2PaJUUH0iX3pVfSneM70dUu8G5iB7Tqw29vWk/XTCk8zE5Z0bzgK0fexGJ8NtWN1bYrEERrm7S0WZnKgrHSCxWXCpq1YIAaeA2RGIX4dp8woqktKKabhzXm+6c2F8U2YyLjaE29Qov3AOXl++FQ0+Iynl6kY8FpZUBpaZfFWg4BAF+8x8/GSF+CwRIDdWK69Y/Y9owq89V2uJAtTbzUHmQvYq0tsDnCkoqac7iNfTZzjo7DJON0IxR3enSJz4S38HfFw/LEUX0EOBB+3R51ALN0f6qKc3FkdzboxXUcPUvWINIb2ZboMn1/TteWk1DumYZM1BUNT1IZtRacGHHwRK69pnPg15Dn4CyGAS6F3mG4oGma8c54tz1+hFYK/zzJ6eLc0PGBzI/bn1hFf3viG7083F96PqxtYI8xRjXNj2J2mu/j98+WFynlJdAVhI+DzSEyIOaVsIUlJTvm44hi0/bCq02x35sm0N1IlOfc/AcXfdAJZH1uUved2QFILsR2RX/d+VwkU2UmhBPOdmpYc3p8DFHlgQU7irxKtcLK7fmBc5V2sfZbGVwbehPrnWFV80QWAJhbrEdwzUnNHQu0edlrCtcUOd8V00W3A/gaNhkmQjvSD3mIw3gMxgMBoPBaBk4piR627ZtKS4ujvbu3Rv0Ov7u2LGj87u/+tWvBIm+YsUKGjy4biFmAqxiULhUVc107do1CmfP0FFWVSM2F1BWdmmdQvcvWyd8pmGTMXlwJ7p36fqQ9Oy7L8ilB5avp4sshB2D4erHIITD2Rza0pWxWX5WqIIj8+WUCjITQaJaEGSkxFvtWrzsImDD4NdXF69PGNSJ7nhxddD9wDnK38B1YrNu8/IFeWDaRIZra+FHpa8qNV1qMj8EgUpiAZLcxmZ+aE4WzZk0UFg63DlxgCc5pisD8VuwwtDJQxXFFVWBcU7aCN0+vh99c7A0hHSX9/raM3vRSV2zAq+7PGob6qN/rNCU5uJIsh6OVlDD1b9QT+GOCf2dgSZnfYbNB4QfsA2yH6LPCsLZAZMqVtongTy2kWeue+yuLZEnbOKknzSyV6AUf+ytzfTois1Gck4C5PV9y9bRDWf3oQVL14Z4cMPe487FazyJPNvYLduGzUdeZgFArY8gBp6BmvXz7Ec7rLUbmks/Xn7DaIpNShUe0cgcwDgs75cgspPiKTE2VhTeNAHP5K4Jcb79zVUC1BYMjrTo7868YnpvywFatnq3pdbGETsj1T5u8bWjaL7WvsbUW6chk8I2ZvsN4OD7D0YwJ0Sa5aX/hvzcht3uLCKMSTiODKLpPvZoH2rtj6Nhk2UivCP1mPe7tmEwGAwGg9EycUxJ9MTERDrllFNEUdCpU6eK12pqasTfs2bNsn7voYceovvuu49ef/11OvXUU53HSEpKEv8YjQ+k0sIL9crRPWhvURn165xJldU19Ph72+iL+tRdmZ6NDTg+Aw3YXRP613sPs50LI7x+HMnmMFyS1i+w2cUxvz5QLNSSOmEKEiA9MZ5mPfeFcbMMH20XQN5CvRkpWSYJIWzoD5ZUCBJoxImtxeY/nE1kuLYWIJhcCj3co2kndaFIobYBG4mlqj3vWbpWBDb8qtz0wAuILxdAIklI/17YXriIdxQnVIl13aMWCkSQ8ypB1dzQ1ObicLMeokFE+YHsXzabpcNlldSjXXrE9kYuX2Wppsd9+Hj7QXsGWe86OyLYTOh2JAnxsSLrxVTQuHubVOpS77seybnvPFgSqDuA+7PorS0h5/eugfgGQYnxUCfQJSm6M7/Uk8hD33MRnfjvO5vMPvIyC+CW8/oK6wh9bMJ4FB8TI36vufbje5atp4++rbPwwLNB28DzUYUTYzxU9xVVNVaS+N6puUFzlUqANlRRrCvQQaAPOiGT7rTYGZlqbeB6vs4rDni8A23Sk6hdeqKo+WFDuJldkWRr4RiurLRwgYKqriK96Xj+WhBNPiu09/umDgrYPR0tmywT4R2px7y8p9jzoGBsTExMs7NlYjAYDAaD0YztXKBomTFjhiDDhw0bRo8++igVFxfT5ZdfLt6/7LLLqEuXLiKFFHjwwQdp7ty59Oyzz1L37t1pz5494vX09HTxj3FsgM3tvUvXhXgFTx7cma4a3YOeeG+bceO4M69EFOBLZ0UHI0JEsqlsSBFPr3Opqq6hP7y9JaR4HZSIsGOwbZZBbgM4dxAJ7TOS6HBZtcjsQMAJKj6V1I6ELMOxtuw/TFc+/WmADFNJDZ24MxXZCtfWAt+F0hNFRNV7IseAv3+8k9qODi3+GQ5UshmFw0zKelLUg7eN7xeWyk0NvOB+2BTJkwZ1pA6tkuiV60cFPbv4OMVDwoCq6tqgzTeIQgmQd7NhKdBAv1gGNTig1pCxxi/QvyKxWVK/7wKCMCaoanpcz5l92gmlN6Art2eMPGJHBGJ04fSTadazdWMICLqOWcnit3CfQCzJMQVt+UBxhchaQ/YPgo3quOtH2SmJRRFE1Ar6SazbXSTqT+wuLBPj5G3n96OUhDgRzDcB5+EC3r/7FfvYjfNB24CFiJr9owLfveaMntaxae6kAeJ3mis+2JonlOgAnjcyBEICHOLvGFEzZ3tesSCP8Rwl0J9cfexXFw0JvF6pFK8PR1HsNeejXUKBnuXRp03za3xsTNB5gGB95N8bnSR+JAWLwxm3XCp3P9YypnsEAlzaSpnWOfgO+oIeRIOwALY2UOVLePX51MR4oXyHFR4y+WCNpNdb8LOOM2USReox72XLdHJOXRYcg8FgMBiMloljTqL/8Ic/pP379wtiHIT4SSedRK+99lqg2OjOnTspNvbIQucPf/gDVVRU0IUXXhj0O/PmzaO77777qJ8/o24Be9eLwQV7AGygQKyf0j07oM7RfYSxucBmKCPOvZhlMEzYtKeIOtfUbbzVdPttB4opI6XCSYpHq5iVjpw2afTrH5wkimuJjV9yvFBuIdtixYZQL2IAGzsU85s4qKPVcmD+BblUqqjV/dikeG3+ce1QU2GjK5VjXinxkdhanNA6VQQGUEQUHuhyDACBvuCC3KiQkAFLHEvBM1U9CILbVPAP3y+AD21i3dQYEwvSMXjTblMkg0C/5fx+QnGqP7v7pg1yKvfg4atuxuGHK8/paPjFMvyjsTJZJPzYLKHAKMYWEMUolAjiyG//7NYmNeR9k5q+U73a+76puYL8hpIVSmH49qtKYkmM/vh7PeiT7Qfpg2159CVUmTNPEwVz0Vf0MUWtQ4HfkWOMn9oSkli0BRHxG89cNYJu1/ohivnaVNBeZBrug4voBDGIc8ov8SbjTcB5YghoKX3ZRWoj8AECHW0Cz+nSJz4U9w4BXQQbZdDWK4sMNiDhKoq95nwce++hMmG/Faua5xugtxm19ol6Xl7B2sZUYke7zoocYxAYLquqFoF/BMRwjliPYJ0j50o5R+prCX2ccfV5tIlPdxwMygiQRD3WWX7P1zZv43nZ5mXbWsZ2T9GH0SJQM+Xf64ItShkMBoPBYLQsHHMSHYB1i82+BUVDVWzfvv0onRXDL7CBtBFX2DD9dGxPUYRJAqmPwIgeresXsW2FooUJIUa4+P4fPqDvDewqSMqkuFi6xScp7tpcwssfftkgqFzqJxfwWfXz2HTmF7s3w1DA3X5+vxDyB8Ambx7Is2mDwi5m6rX5l+Sy35T4SG0tkNIOH2OpJISFCxTo0ezzftX56clxQUozm7IMSvmHPtpA8yYPDGzaARRtBdGJgABS16GWg43FLS98ZXx297yyjm4+rx/V0oaQIqMgE6HeVY8p7a0iUSkymhbq+n6F77EEzxPe/TZFM5779rwSoQTXAzXd2qR59k+Q4+jLecUVVF1TK/6VVFRRSWVo1olKWm7ac4jOffS/1nn+F+f2pdwumQGS+qdlVeJ4TxrGFN1XWh1j8B0UG0eGmrSx2VNYSp0yU+i6Z+sskSRpZwK+b7JtwTmiqLDJexxjpatgY2x98VFXJh6ye6A8dsFF1rckGwgvUhvvi3Fx6dpAG0F2w/jfvisUzH4C2er850dR7IdQRhDksXqLoFln9bLaGen+7HrtEwl5Xi4ivDELFoc7f/i5RwgEmQLFILbVcc1v1o5tvEJ/vO7MXnTF058EfR7tBvsFCBVQKLwhVjgIPl58ateQQs3n9G8v5vzdRWW0ce/hoHHbq24Dio5jfLn53L7GzzAYDAaDwWj+aBIkOqN5A0SSCwlxsfTFzvwQJRoUqD/40wc0Prej8DJmQogRCbCpQqHIWWf19r2Zsm2EsMm7/uw+IWSorn4KB4KgfeErQZa6gE0mFJ+mTbu8TtVv20WWXTu2l1CBhkOuh5MSH6mthR8Vb0Msdvyo8/Es9xWVB5RmLmUZgCwauWnHJtqmfIPXrO3ZIQPhf0d0s2bk/GXGaYKAk3/D7uBo+sUyGgcoUGgjnFxjiRehqiua5Rj40IVDRN/06p/4r8njG8TV3VMGCg2u7pfsZXlSUV3ngS7PHZ+HHYytT+i+0hhjQOyDNF++aldQYB6WMZcrlk8YF2B5hGLQWH9Iv3hk08AGy+8xJdbvKhRBiNkamSYDD6WV/ghu9F+Xj7xt7AWQUdBS4EVqy/cFITpxgBgXZdvxm2Wjzn+u+y7HeS9CGe31LsUKzFYYFxkN907LpZqaWjqrb3sqq6wOyc7Q51oXEd6YBYu95o/8koqgwJmf4uYLlq4zBsXUOTLcrB3TeIW41cTH3jOOhTgeApPYW0TDCkcn1uEXr9vPyXHbq3YN+vHia0d6XjODwWAwGIzmCybRGQ0GVJkuIAXcqKxdspYWTh9KqQl1PsxMCDEiBdoTfK79bqZsm0ubitG2SfRCgKDdkkdDcrKdBAs2y1A9uQA1qwobWYaNJxR96sbcppYDclqnegbD9P6pb0ZxrUixb4i/fEMtdrzU+SgaN3fyQPrdik0B1TzO2bYRl6QbggsFJXXevdsPFNMlw3LEvZTEHY43I7+uqJ4NUPraghRQAkufepU4aUyVIqPxFeg6ge53LInEqgm/CyJQ9hMXgWULHOFv2MWA1Fz1TUFQv0tNcs/zILJVwgvneEgbr7wUy1DF47w+21kglMBqUVWo0X9yRg9a822hsDu6+Z9fGT2Ji8vDU3SDHBOZJq1TjWOpXMN4FUd2Ea/o0yDg5r+y1ngODSVLmxpcpLYeyC0sqQwZF/1m2cj5D8GXaSd3Cak5omZHweLNBT2ALQvjwqbo5+P6CLsd9AH89+OvD9K5AzrQie3SxZz1x3e2BtUUOb1HG5FdhOALrJdcz7YxCxZ7jSMYL65/7otAP/ci3QtLq5xBfhDb4ayPXHVHIKxxBROxFkrwqDXid0+hHhvj9k3/+NI6bqPArQtQrPdsz/W5GAwGg8FoyWASndFgpCXGO8lBeKSagM3OT8/oSagPdWpONhNCjAZB+lz72UzZNpcuFWMkm0RV2WUjWNB34C1aV1jPPSSjUCWyOlSS2kSWZaYGq6ug2sSm1OQHjM06rBO84OqfNvIbJACIBT/K8mj4f7tSwxdcMFB4lmK8gerUb4FWeNXjGuJiY+nmf3wZUjxZ+ix7wVbQUSWVdOKkMVWKxzuiXVRYB8aKSMeSSK2a/JJGLsWpGjhS+x2C3S5i1HSOkwZ1CisYABL9sx351qKq8ycPpIuGnkC3vbja7EkcE0N3TujvPGaX7BR69WdjBMGP8RYiANRB2Lq/VthNwVkJVjP4Lz6DQIg8J9SPCFIl924rbEhk/5fEqyymiDETRRRB+ueXlNNdEwcEfLKjSZY2BcCe7+PvygJzHTzx8TxMFlnqeCmttXQUl1f67qMgtqEQBsGJgAes0fTsCy9C+ZAliAyLot+s2BQyZ5/WvbX4bUnkw0udamOERY3abtFGzujTTszJR7tgsd8aA7Kfe90jL8GMHuSPFGqxWRtgsZKg1MsyIZI9hde4DQ94npMZDAaDwTi+wSQ6o8FIjI8VJOC8l9cK31E17XX2xP407fcrrd+F+vUPb28RBfl48cmIBFL9lZWaQH/436GUFH8ktV8Sxvpmyra5dBHxkWwSVYJWJ1hAppyQnUJrdxUJogVAYS5XAUqQ1api2aXQ1sl1EOmvaup0SeDg3ECye6XEm2Ajv/F7Ow6W0KK3tgSNC7bzjpb/d7iEhBdxgGcENeL8JWuMxZMBPFPhq9yrbdC1qs+ua+vUIDVrar2v+sk5WVRUWkWTBncK8ctuTJXi8Qq0V9gSfJtfKupzyLHCrxezX3iNFa73XcEglbSNlDTyChzB3x/tU+13GD9mje0VaPeq6jY+NoaqqmuFenzdrkKaPrybKBr8oxHdfAcD8DlkZNhqM+Dv+UvX0b0X5No9ieGPHRfrHENlHzMF/tSCp6JP78wPnIc6dgNQroMcH/+7d4MCk/j/IFFxf5bfMIbmvLwmpM/fNbG/KNQaLbK0KWDwCVn0k3EnBKyqOmck00KQy0Xl9E1+ifiMtKuS90taa+nAfcpISaRZz33hzEoKJ3PJq4BluqHvuNoiniueJaw/QO53aJVMs579ImSOeDcMe5potwPbOKIHM2Q/9yLdkxJCSWs5DiBrBLrwrfsPNzggifHJlc2AdpOeGC9EBdEmtL3G7UOlVTwnMxgMBoNxnINJdEZUPF+/2FkgFtIzR3UPqL2wmUVqpCslE5stbDrujIvlxScjbKQkxlpVi1IhDHJM30zZNpdeSnCv90M/H7wxlwSLBDx9zxQqtbrzA7mDtH+kDet+nLAhmf74hxEptF3kMrB8zR5x7OvH9qbrxvYShYBlEELfHOrqQHjDmkgtjAePvbXZs1CpRDT9v8MhJLyIg9XfFtKZfdrToys2O5W7SItfev1oYYchn50gzSb2p6HdsunA4XKaO2mAIN4OlVVQenIizVm8JqiApIkAaiyV4vGIuvoEsFc6YBwrwulPXmjIWII+Bq/l2ZMGCPVzSXm18NpNTogV7cs0p2KM8Our7RU4ghWFvCey37XPSKbyymqhLr96dA/qlJVM9y5dF6y67dWWfnFeX3r8v1tFzROMKaZxViWr9WCeqzYDxpniCjfJtS2vmOZMGigUwSZPY5yTLfCnFjzVz0Mfu9+86QwRuNVtsyRAsM5ZvDqIVMVvoL/jetHOAPRrWI00RjbE0cSf/7uNnvhoj/j/8vrkOIx2a5rT7p6SSxf/+YMQMhb2PbsLS2lI1yyRBSDbuzp3AOFkLnkVsNxTVBoSfPFqi9/UF5TF9aK9f7Yzv8kVgcb88fBFQ2jfoTL65mBpUC0OdRxBP4cNiYt0//Zg8D3CMzOtv8KxYLONT1h/PHv1CIqhDUHPRBbjhjXSry4aEnK+MlCF4sx1/aoizLoqHtmAKfE8JzMYDAaDcZyDSXRG1Dxf9cKh86fkUsfMZFEUTFfn6Eo0qLIYjHDxoxHdrUoxAJsplaRWYdoIpSTGOVWMUGKFo7TyUr9h06pbOqDgIPySkVYMVRTUViD/QKDrac7hbs5N5DI8vpeu2hVSPO2la0fS7oIyURywk0P5h4KYDS1Ueiz9v3EOyKSZvRhKc7Na7+nLhwV9RyV8oLyEHQ6yblas3yO+A39+jGnt0pNo7str6Y6X1gS+i/YAn9zbYUmxxT8BxBv0huFIfQJzAVk8T7TXaJFdXlkleN8EL3UtgmnlVaGEJCyK8L4fCwyvwBEs2KDCxj1R+13XNml0VkKcsMuYB4W1rrrFvY0hun9qrugjtnE2PTle/AaCiCoBhXPfnuf2rvYquhofEyP6IfrgDRU1lJYUJ4jD5LhYOqG+mKsfOxvdr12HF+mY2yUjKEBmKtJ477L1Ic/5b1cOp+YMkyJXn9NAVKL919bU0oBOGSJradH0oYI4l17dINI7ZyaL16979vMgIl3Og+FmLsm2KDNRgHatkujiP38o2uszV40ICr54tQH5Po4HZbocQ7yCwI1tJaXjcFmVUPxf+8zn1s/Ifi7v0e7CMkFCq6S7fo9sSv1wA/w6MB4gOFVQXEEn5WSLOVUvxo32gHuIPijHF1gAIYPBT3DaBrRL555lZ0Egm4XnZAaDwWAwjk8wic6IGJ7egZXVVEu1QtmKrYbuJXrzuX3pyqc/EX/7VdAxGCrOHdiBnnjyK+N7aG93Tx4YIIBNMJGTLiX4RX/8QGzW/G7KvOw4TJ7I2GBj04uiZG3SE4VPMFTONvKoIQV5cSyoJd83kGELlq4TBQahtuxGaVb1pg1+SCgXsYe/cY/gU19cVk2V1TWCYIyW3YYEfhOkwJCcLJFJg/PGeITgxRVPfSLuO4g4CZv6DoGHy0d3Fyn9+A6sLb7amR+yGcf17cgriYp1DcM//BCnQLQKXLuySqQiOpK6AN3apNFDFw4RRKMkpdFe0S/82lvIcUn/rBo4QhuGQlfN4pFjU3lVtWjXejAJxCfscbbnldDj724LHNdvEAifgX2SCzjmc1cPp/eVbBmJs/q1o6y0RJFJ8/Drm4KuC0phv1kvkrBzQScd9x0qp50Hj9iWSJLWBrxves7NFc9eNYw6tWtjVeSivZvaPO4diovuKiylZat3h3iPw0IIBWV/88aRTCC0e2QMuODqx2rw4veXDhVtCP+uevoTWnTpUJEZCY90ENwuqG0EvzdzZF0mpqu9NLR4dmPYo8jC5hLy+d2/fH1Qm8Q9uvSJD2nh9KE0e+IAqq6tDStQ7hdyfFq/u8j6++ozluMLxqdf/POroLlcjkkI+kG57nU+aKMLptYF1fW2KMfGbq1TxbqssZ4Xg8FgMBiMpg0m0RkRw8s7sLiimh57cxOt33OI/jrzNPF5bPylmgRWD89dPYK+/KaA/dAZEQHp1C5A7RgudNUcimlBuaYqwcNRWqlKTCilMlMSRbFK/GZJZXWQCs20wcYGV1ormIh0PwptZI0EVIAp8QEllSAWLYEwSSzK37eRkLbNuV8SyhRwWLe7SCjeFixdG/S7UnELIjEaUEnLFRv2B72Ha7p4WI7YxKclHvFetanvEHioodqAGtGlxEctCBeiReQyjsBPAVkEPkC66MV7I4VNgWsrKOq3LgDGFJ3ACbcwL76PTB2MoSaVJ4DMG9PYBOLRFkxCv5l6Uhf6+kBxRGrUjhnJTpU8rKdwPIwF6riIcfKO8f3p7leCx4xAQHXJWuHRXVfA2Zsc1cc1NWAAwGYH91wSeHg2sl6FK0OnpWJw12zKyEgX92TrvsO+VdZ4L7+kgh77zxZrRtlt5/cLItH9zHm2z+h9TM5TeL7zpgykB1/bEDguxgNbNomrwK/NnzsaxbMbYo9iKmwO1TWKbm/ed1hkiKgqa5MAAJkDIJEhTsA4Gc15TFfo92yXJp6LTUCgP+O84goxZ5vGJBDgeN92f9Vjo29DQCAzUvSxEfN3Yz4vBoPBYDAYTRtMojMihpd3IBbkIOhuHNebfrtiE/XrnBlQrA3NyRafefDVDXRebkdBuGemHqUTZ7QYdM4yk1ENtQCRqrlt+w/Ti198J9otlIxS1YQNaThKK0m0uFRoKM532wtfGQuT1dYeIWfDLZ4l6xa8b1DDehGLgPx922ef/3hnSBo8sK+oLKiQpp/zlgEHBNv0cwbw+3e9tFoocaOhAvOjTsa5Qo2P+3X7i6uc5LiqaHYp8cMNMDAaDj8FZP/vwx3B2QW92wqrHxT+jZQssSlwTSgsDbZrCoeUMrVllfjduPewmLNBTsm+A+9zlfjVkZVypA6COm6h/ToLgC5ZKxS9Uxa+H7YaFZ9FBsrbm/YLmySpJt1TWEqdMlOEtYccC2Iohp65ajgdLK4QJBfqDtiy43DuCFzi9502W73aCIuPQV0yacqQznTPK2vps50Fnt7P+vjopfz1S8A2J0SissZ3DpVXWZ+b/ro6d8hnqGdEoL9i/WkiSNF2QY7LLAb5nECa6u1ZJZ51X261MKc6hujtSrW3QXDhWGQgSXsUtTgugoY43817DomAF9p8fnGlUFhXVFYL6yYv72+/Fmzq/U9Pihd1QQpKURfkSJDFJiBAMApjlE6ki+Ki2h4E2Wouez/UJDFBPzaO6VLAow1xxhiDwWAwGMcvmERnNJrna6yyicjtkmlVh7ROTWBVByMirN1VZCUq/BDMXkDKONRWtqKl4SitoAY3keTYjGEDd8f4flZVOPrYtWf2CjqPSYM60u0T+gvvUkGQKQpz9Zg2Mho2E3MnDXSeMzbZtg2zJC7gOf9tfgn9/Jy+dOv5MeJ8EBBYs6tQpOLHaDYFJs9cFWJDXVjmtIoCye6HRPfynpXEl82WAiSjPNe8en/WtET3tCnJ8yyHFQCIG1uAQU+tZ0QHXsQpCsiGZBdsPkB3LV5NkwZ3pjP6tGvU9H0QOWWVNREHV3QS16YUV7M5XPdEHT8lQS/7CexjzhvYwV50ccsBuiOuv/g8VJ1+lMkyW+ZweZWwsVq+aneQfz3skq4cc2LIcWDbIAMBUMl6WahA6W4tMtmrLV07tpfwyAZpJ4sUIoCKgq4u72d9fLQpf2URygm/e5daEjDW3ql5vHuprGVwBrZBLkgCVZ878Axh0/FDg/pYkveYf2412BbJOVw+p5SEuJD2jONK4hn2JfgbNoUrt+WFZIbheGhbLtIZ9icgaNU5RrUkaqwMJLW9y2tEIGHJl9/RjeP6OjO+yqpqBDldUV1LlTU14u/M+s/5GT90ghp9CvVDBp2QSZv2HqJ9KQnUtXWq8DDX2474u5bE5+9U6orI4qJ6pmFNbWjQRQKv430dpuwAUwBMjn2n92gjAg1PzjxNjG0MBoPBYDCOPzCJzogYIOuw0L7L4PkK9R6sKv70o1MEsVdaWUOXDu9GV47uEdg4BIo/ThzAqg5GRHj49Y20aOZo8f91/0rpgRtOarm+ubrbQJyohQj9KoaxkUQBTxtJjg3cbee7fwOb7jdvOkNstEFixUK5/q9VRoU5bCT81C1IiItxboJBCpBhw+yyckBgTHq4pyZuo1dvGENVNbVGUsGGIh92J16WG35UkSC+XNfyP0O7CG96HEuqxzGuuYDP4bsIQNiI8q37DtH8yQOFMhap4ZJQWberkH78vZ7O32dEBitxKkjNgTTxd+85swuiFeg1BXYAtNUhXbMiDgrqJK5NKa5nc7hqNshrxbnq/QSWLi4Ul1XRkzNOq1OHK/7lJmWymi2DzLXPth80Fy0loh9/rwc9uuKItYea8eGV4QGoljgPXzQkyOaqoKSSZilFLPFfkHvwYLeN3bhv8EMHQJDGxMQE1jiSgAVJjD6OcVs+QyiDm7MHug4EGV0q691FZeL/q/0Hz+KzHfmUnZbgJJdx3965+UyREaRbEt07bRDd/I8vrQGO8YM6hZwXikNOHFRGf7timHh2CJbinwk4B7T3cf3a09Bu2WJe+eM7W0MIdLW/2OYjZDWo7Ugl8/F7KGzeWNBV5UkJcbSrICuEQJdjxIJX1oo6MAi229YYXjVfAJ1Al2OISoojm0T9jB7Q7pKVTE/NPE3Mvaq1CgoTq0C9BhdM75syeGRgJZZixLhjrYNSf53sjc5gMBgMxvEFJtEZDQKUKlhEozAUNqKZKfGUHB9H9y5bR199W0h/mXmaUHDZNg5YnEstB/sAM8JFaUVNUIqy6l+ZX1JOc9D2Iizg5eUXrhfds0EqnS4ZltMg/3YQCT3bpwdUmzcZiIPPdxbQ+1sOCEVrcUWVUNctmTVKqMMT4mJDyAkQH35INHF8ZcM8uGuWM21aWs/gOPC7hYI7HHgVdEMa+ITfvmt9pn69Z/H8oDS1XcvcxWtoSE52YOOMsevcAR3sNg31VhCwBigqraAFUwbSbC0Qg+KHUP/NWRL8OlSwvzivL81dvJoWTR8q1PgIJuC5qxYcjMhhsyfYnlds9d0FMK7ogV5TnYHk+Fhn5oMtsIOAH8hE/MOznziokwhSSxIJxxrbp52TwNdVoS7bITWbw8uyQRL0OinvRVjjHkiFuDrn631Qz5YZ3attEEmuAoTWz8b1DnpfPQ+XhYr0sG5TH7QwPQt8BmOJqjIGgQbbGAkTyQel7r6i8sDfnTOTxXOE9cyqbwro0mE5IQWubeNuc4XX+m3b/mK6f9n6oLH6cHmlaBf3LF0XYpci28vJOVmi4CjuI76r2v5hnEcfdAU4ZmjFPk1ELl574ZrTnUS+XkjW1V90BOYjx3yJQC3mb5kp0RgIDmCUi2vBXIWggj7+9e+cSbMdWWyo9YAxynU/dPsaW2APY5G7aHcbmjHqRLr5n18FfgfHrKyupQ17igIZeLq9iw7T+yabOpmBgGP89MyeIrjxyL83GjOVOIuWwWAwGIzjD0yiMxqME7JTqVVSnboOYh6k18JD9O8/Pp0eem29c+OAhTLStwH2AWZEAqkU0zGyR5sGFfDy8gtXi+65IJVOM7XNvI642BjfKlSTwlzdgN6hpT5DHQ6FJQgJVfkGf9JwSAH5WZDyfnzBvfq1zW4FxLHLKgoKepXweGfTfpqQ2zFwzl4FGlVV5NCcLKE2NQFjF9LG1Wt7dMUmuuW8fkR0pACdutGXVhDTTuoiiAq9QBlgUv/JwqQLpw+l2w3qv2gWVD2eIesTqEivLxhsg3xukii01Rm4e0ouXfznDwIFiNUAjyuwg2Af5kOQdrVUS8tX7w5q+1A8wk7G67pUYtblya9ei+2eqMB4gPFU7fN+CGvbnK8GJPSxrKrabZGArBbbcXQFqcnDGv3S9izU88RvSbuqlMQ6H23UcklNiBP9dKWirkcAbMao7oLkw9843vVn9abXbhhDmRY/fdu421zhtX6TPtLq/AvP/YdeDyUn5d+w8WifkRyYr9TvyiCIV3Ba7wc/OaOHqNeBMRnZkQg0wz7o1//eSG8qxaVVIh9ZA+qz8eov4dbegFXbSV2zxLGGdW/daISsLXBkKlzuFYRDv5XWcbb7oa+hbL8px1d70e48qqnPQjFZQ0p1vNe6IT0xLlAMWMLm6457gYy65TeMEffNFajhLFoGg8FgMI4vMInOiArkInr97iJav+cQPf/jERQfF0PXju1Nt43vX+cH/a9VAXJBJdqwicECNznBOxWbwVAxokdr+vi7OkJUBUgn+JY2ZNPjVTRLFt3zgtxIepFO7205IIgeIIicNajCoX6VwOYe73fMTKZDpVV0h9bfdAJL/v8vdyKN/kj6ud9NID637UCxL+LCZUHhZbdis4pC+j5Szd/SCA94lar2E35VkS4FsnotEjjuZSO6B8hxoH1GEr25fl+AiJDXjeJtOmkA8t/l2/pNfmmjF1RlBMPl7asStSAKXXUG7l6yRvRFqcBWSUMXkSaDbOiXf1GsztT3/QT/VGK2rMrdrsMJWuOYiZry3Ob5bSu6qAfXJImvjmVAapLb0gLBQjkWzNSOg773/Ec76LqzegmvdDUzSSVDvUhN2M6ddEldtg2u89mrRxhrY/zx0lOoqrZGZJ8Ul1ULNTMCjBjXHntrM90/dZDzeYVLxjZlICBrs69S+5A6/2J8dI2FPx/Xhy578uPAGC2/C8i5wxWcxrPu3SGdXrl+FB0uq6ZWKKybHE8PvLqeXl2zN/A52ZY+2HYwcKyA3eCkASKQoj4nr1obOrzmI3ily7mjsTIy/QSO1PbtFYTT+62fNZTtNwPFXT2KdqM9/GbFJqs6/pEfnGS3mJw6iKY/8RGd2LYue1bOo66xH+MFitQeLK6za7KBs2gZDAaDwTi+wCQ6I2oAKVZaUUXPXDXCWKgIr1/6xIeBTRAW1Fg4x8aQ2MDcvWQt/eqiIS1mU8lofFw6ohslfHUgpHDbvCkDafJjZo9jv5sev0X3/G4kbaQTiAeknEsySLem6ZqdGmIFACJAnqOf/qYSWFL5dtEpJwQVIQ0HXgEGnLergKgfuxWorkEaI9VbKjURmNMJdHlNUPMurCcZvc4PhcxgSYOsmVvP7+d5Laa0cHjkIs0bKfjSAx5Qr7u4ojpEGedFTsjU9oYUVGWEB5u3r0oIyz4PktRVZ+C28cHtSRJ/XkQa4CKR/Ab/JDGL+dilyoRqMxzAMsFWdBFji6gvkBRHr67ZE6JqNbV9SeLLsUyFK9iYlhgvakMkxsXQ3a+sDToOrgs+zrCuus1hUeUVBMQ486d3tolzgAL94deDs06AjXsOUefsZJq3xD72wlLreAHmoBlnDBDFFr2CKsXllWIOQD0IF+BXrrcjOT7KucMWnEZfff7Hp9M8zTYLz2fOpIH0yfb8wFoUfaTWQCTje3dPHhg0//qptaHDaz6qrKoJsY2JNrwCR2qAy6swtq3feq2hbBZQ6trIBdTxdI29B4srqF+njMC6AXZorVISqKq6hi77y0ciQI1/akDSy9e9LjPOPeZyFi2DwWAwGMcXmERnNBhiM1RSSbMXr6Z7pw6iOxebVXr3LF0bpNLDJh4pz/ASlZtuTotkhINbX/iKrj47V/iTw14F6nBs3OD17VIY+9n0+Nlc+YG6kdT927FR7ZyVTBN+917gfHUSDYSRDijIR9eTE7bCYHp/UwksWMc8/NoGodqKpL+5AgwICvRql+5UzXrZrajF/yQxAX9VeFfrBLrEu8r3vJTFr6/dI5SluH9Q2PpRIeuEovSnh4ctUvBNVjgmRb2Xl7TrfVa8NR6kihvFXr/NLxWvqQpm2ec37j3s/B0oXk3PzYtIQyFaedxoPH9XNgdeDzcYY+pT0koLff6W8/pSqcVaS2/bahBSjmXyHP+zcR/NGttL/H+djJ01trdQE8PiA7j/+4OP+NInx4vfkoFBl0WV17OA+lQe2xbYQHvQCXR97PXKcmlJeHvjAfp0V938dvv4fvTNwdKgLADVYz4jJZFmPfeFp8WZaSzE99WAlC04DVssnUC3zY02IlmvVeK31kakmS7hBOfDhVcQT10foD92zU5xBuFkFls4ayhbwANt4+8f76y3SfPOQvFSx2Nsw1j0wz9/6Csg6bK0wzOPj42xZlk05jNjMBgMBoPRNMEkOqNBkKocbIbgGVhSWe1LpQcPURB5WHx+l18W8CBlkogRDv5y2anUqV0bo4d3NFTkkRYR01O9sWGXykhJyEgyHhtDkHThnCuIIniAHiqr8q2KVQkJEANvbdwvgl/hpKX7DTDoyvlwN/SmcUAWgPTzPZzfA98fRDvySoTaURaKW7erkKYP7xZE6syfMtB4LSa7CACb6XD8cXVFfdv0JOuGHK+bSHsJVrw1LuSzRGAE/QJFKOGhHUzAehWvCyV65LjhGpNwzFgUFXEg3OdvyuZA8NoPgW4ax2xqfXhXT/v9SjGPe/mk60FIOZbBjgFjFhTgg7tk0aRBnYIycuBjfUJWcoBAl9+1ZdO4+iWexTn921PfThlBBUIxRmzcXUQJsbGemSOwcHKPvf1FodnjtT4JgpSm+wN7lDmLUWz+AA3pmuXbV1++hi6izmV6RgSeV4+2dbUjwskYsT1rtc/5Df5GmukSTnA+XHgFjmBz8o+fjAgaI9R+qfuPm/qdacxQ11DIQPifoV1o7strjcWVsRZyBRsglHBfY3zEawzTeCH3Nyj4jECNnmXR2M+MwWAwGAxG0wST6IyIoapyZHEnpE96qfRQgG/elAH0XX4pTVn4fqAQFxapWHgzGH4xuGs2ZWTUKYIjVZF7+ZuG41vrSvV2kfH3Ts01blbxuu3YOW3S6OOvzSSBropVCQn8/zW7CkV/Q/aIWjDLKy29oQEGvxt6E1mI34Va18/38Bxuf3F10HNA4O4X5/Wlq57+JMj3FoUM1WtBFgOKHeNaUERUVZPi3oF0D3fTrCrqgQctpD1++75l64y/EYkFByMyuPq8rpxWgbktMS6Wfn/p0CBSVvYLP2NSNIJ/rrbXkHEM5/nwRUNEVgiCU1JpvLugTPQTl2UV2jZw9egTQ+4txrJf/+CkgKo8MyWe+nRIp0PlVVRUWqcyR0HBSO2ndOD4IHPhbW8qUFhSWeWZGWLKOFBRWl5FOdmt6HiErR2gDamFnK3tpVdbunZsL7ry6U9CCGe0tU935geR7yp5j2NgLI8kY0R/1nqfiyT4a5sv05LixVhRWFpBr8wa7XvujBReQbzOmcmU2SnD2S/1bA8VXjY36rUtdKwbXAHtbw+W+lbH29YYIOoRcMH4jECPTTygZx2ogRpxb1qnUvtWSUygMxgMBoNxHIJJdEbEUFU5cvORmuRuUpmpCTRhUGeqrK4RadnwQJdkw3Mf7RDp2QxGNOCH5FWVRtggQZW4/UCx8CHvkBHeBslPqre0ANG/t2DpOjopJ1uQBGoxvHuWrnPWCfAio6GKVdVuICdmjOpOa74rFEXzdKWeV1p6QwvjyYAFiIPnrh5O72/NE0SKSlS7yEKodb1IRttzgPKxhmrp4mE5QcQZ1Pwb9hQdsWjZd5h+8KcPApvtS4d3C3omjdU2UVgZxQhnTxpA5VVrjBYcaYlxgsAMN3OAET3oymkJ9K3rxvYSimzZniUp68c2IJoWUg2BaxzD6/dckCsK9KmAb7gkNU2WVb3ap4v+g+uGH3lGSkWg7epBzL4d0hvtOlEUFoQggGCVyepj9uI1dN/U3MD12CwoTBkHKkCSHq9Q1eFzJg6gssrqQFtX/ehNKvLubVJp7a4i+nh7nugr6tj77Ec7aEDnTCdJ/9D/1K0hsb50QX9+6Kvq+G7qc5EEf73nyzrVfGMj0rHFle0hIQqZv/BVUEDetZ6wrRswFqCtYA6E6rukvFoEjjE3omYSng/qDcCOx0sdbwoaYE5Hu8HaR10DmMQDetaBGqiRNns89zIYDAaDcXzi+F3lMxoMVZUjN5pIuXYpRVLiY4Wi7OHXNwZ5G0uiT/WfZDAaChfJK8kimarr2lh5qdUbkuqN11es3yf+mSC/ZzoHlyoWr6cnxtNt5/cTxRCxkW2dlkiXPvGR+P+Prtgc9rk2BCalGs4R917aq3ht6P0QASCZwymgBrXrRX/6ILARVzffuhcyXoeStrHa5h3j+wuSD+eBoqSqBQcoH/gIh1PQjtE4kApNFLKDVQrIta++yacrlCwHlZQF8XywpCLQb03BtGhkeHghGuOYqVimTmqqqmCQmlU1tfQLQ9tFpg0CiOrY11htemdesVCe4/z+MuPUEMJPvcayqhpRryWWYqyEbXF5aNFgCbwOb30IBI5Xog39YNU3BSGZBxnJFSGfU8fZ124cQ0O7ZdOSJbvoN28cmaPUYLBOvmN8RBAU/QTjpvRbdz0f1OJRfxt+3Bh7kUUC0h51PXRbsmgVGz9WaIyxBfM6hAeu/uRnPeGlZIeYAL9TWlFJD9TPjy51vGmtgPbiVzxQXVsrxgnV6kkN+JuyDtTx9eScbN/3kMFgMBgMRvMCk+iMiKGqcuRG84XPvqF7puYKz0tdKTJ38kB6de1usYDVF7Hy77sn16V8MxiNDUkWQUXp2ljBW1u3BjERPZGment9Dz6itg0mCCqbbyn6G8hhXKcENoV+it1FuzaBTd2Kc46JiaGXrxsl/KD9bOi9iIBwCqiBPMHmWJ4L7iPI0Yaqgf2QlS5iHc+bqJpqa4ngkl1bW0sP/ntj2AXtGI0H+F3fv3y9eCboV3e8tEa8jraIdgLPbFhGQBELVSVIv2/yS32RxOFmeDTUogUKTdleQXi7YBo/XMpjMgR/ZNtFf0MGjkqiN0abhlJWEugun3MJBPO7tU6lW87vS/sPlYt7gmBkRVWNuE+wctiwu9C51pn++If0xGWn0vGCkT3b0IfflnqOly4iGvdu6ardYj2JtvTTM3oKH+yUhDhavmZPUC0LlXxffO1IEZhS55n1u4usqmX4b5dVVgUIc4hALnn8w6C2jd/spqnEm0KmSLgwzUWuIF64v437Le0cw1lPYDxCABIWkFmpCfT5jgIhaFChjwWR2KipawWQ4bbCxyrZj3O755W1QYEBaTkp26CedaCPr9t/OTGsc2UwGAwGg9F8wCQ6I2KomyF1E43NyVWje4iNSmlFtVCMYJP+xro9NLBTJi18a6sgLvWCXtg4VXts4BmMaEGSrWiHro0VilP6IS8jTfX2+l5mSqLVXuHW+nNQfUth+QEVJEgcSaCj/8EDuEtWCv3zmtMFsYc+qFupeJ1rpHCpW/E6CPRwNvZyQy0Jgq37DwsrKfxOapLbZkFaT8F+Y/ak/rSnsDxwL0C24D7265ThqdizEeVeijov7MgrFuTi+xrxA8Luk+35gog9GpkDDP9tWpKyaCMg7hYsXRvy/P525TC67C8fH5PAhy2I9emOfNpxsIQWvbVF2B0BCAi4ANWviQS1KY9dmSHob1AX68Bv7y4qqztemEWcTZ9Hn/5iZ0Fg3dGuVZLzGtHfoUJGbYTr69c18bExgfXKfzbupTG929H+ojJx/ihSiYAJLEKgcJZj7/Fk6fLwhYOpIjbZU+FsI6LVQs6SIMc/tDVkctjmaHW+kn0S8x1su3YXltKssb3prokDiLC0jCXxHGHXBdL72mc+9/xNHXqhTMzPlTU1IqOpcE8RlZRXiWuMttVWJIFZP3NRpAFf9X5D9e+Cfi9Nc5xOUkdrflPJd3igu4C2GxgrLUIfjAUY59SsA9v4ymAwGAwGo2Xi+FnhM6IOfTMkNz7dslNEuvu8l9cELURRXOz83E5CdTr/lbVBmyK5gC41pIozGF7w2gia3pfktZcqEQX0TNA3d5Gmeqvf01WsGSl1KlZdoaWfAwhomc6MjfODr20IItCfnHmaIMpkQTeTlYrtXCPZZOvfgQd6tJXvJoJApuWf3a8dvanYRUmAOO+SnULPXDWcPtiWF/CvVjfwCEQALuWbjZwwZS0AfolT/K5OLkiyEYrXJy8/jXbmlYQEH6OdOXC8w0+bVzMeEJiR/Uwn0NXnt+jSoaKY9tEOfNiCWCCE4MOvnq/NA1zO4YnxsaKdw6P4Dc2GxaTGDSczRAUKjxeUVApFuG6rAYQTrAIZrlp2qR7uOtTxD4UD8Uxxj9T1CsaRsX3bU+fMFJGBgACErKEAkh4CAqhrka1wvADP3VTk29SnEIhBgdrDZVUBhfDS1btD5iIAfaWiuiZoblXvNVBVUyOyDfDbNt9rPO+5kwbQ8tW7qW/HVqK49v3TcsW8qY+np3bLdlqzqBlDc19eIwh7PZstmrZEkQRm/dRogcClISS77NuuMUNfT9jmOJWk1gMmktyW55FeX5S1oLSC0pPtaxL93PE9L7LfFfDHOV53Zi+6dFhO0PFc32EwGAwGg9HywCQ6o0FQVTlIzUQad2xsLS18a3OIkgOLzI+3HaTlq3eF+FTKBfTsCf3FwpdVlYxobTBdhCf+K5XJNrjeV8nLSFO95ffuX7aOrj+7TwgJB8LGRHabzsGUwgyvWPgyS6WpxHuGTat+rqZ7ByINnqQntE41Xo/pO89eNZxcgGJz895DImCRnhRHaYnxVFpZTYWlVSKQkJYQJzbMqUl1G2bARBDU3bcNwnoBxIg6zmCTf/N5felXr22gFRv2BxEx+Cz+xn3LSo13EgcucsKUtaC+LwMb1t8urTQSEQCupaKyhq58+tOga0LbwO8wogO/hJWaQQJCDgruuJgY5/O7M+7IWHI0Ax82ItuUhaN6gEO9rZKVCEBt23+Y/vXZtzRv8kC6Y0J/YcegK4/V/pOSGEc3jutNMTFEuZ0zQwhLfXyV/RKBRKi6MSbgXsXHxVIbpRipq/gpvNZR0FSeD773mxWbAs/GVZhSH6sRfNSfKcbS2uXr6b6pg8S5JsTH0PTh3UKI2zH1v+ciUvWxpme76FhtNCWYCngDKOB9Yts02p5X7FSaw15Hzq3InjCR5AgKI9vK5nuNv+9dup5O6Z4tMiXRzvR1KsZTBE26t071FSjGNQ3pmmW1g4OQ5N5pg0SwINJi0F5tHdccFxsTMkehDgpsVpApserbgpD+h357J9YFYZLs6vwvx0Bbf5LtP0jQ4JjjTDVLAIwhuiWU9Mi/5PGPRNBDH593F5TS25v2i0AYrjm/pC7AMq5/e2P9mXP6txfHwfk9d/UIka0nCqb+a1WQJR7unR7U8woUMhgMBoPBaFlgEp3RYEhVDtK2//cvH9GL1460FhnCxvhdxwK6tLLOc5RJdIYfYLN457I6X2LTRhBqN9sGFEpK+ImDEHEpL6Gy8pumHGnhLnwPhBTsWUyETQ3VGhVapnPQVdTCTkEj0IMKH04cQOP6tTcSYaZ7h79vf3GV2Bx3yQ4m0m3fWbktz1rkDff40+0HhaJTVREGBxLa0PwLcmnL/sO0ryheFEh1qcVw/+G1jGtDYE8qHWHrIAl0ExGD+zBn8gBnAU+X6syWtXDk/Qq6G16rlt8GseGCVMmr1wrPdNj5MBoOP+pNU+YJvOt//58tdO3Y3s7fP6Q832hbJrlgs4wyqcClNdtPzughbDRABIaSlQPpl6+up/umDaIeGulrDLz1akvXju0pAkAyEIgxF4GHj7cfDHzOpSIGYfbA8vVC5Q1lucseasu+w/T0yu2BflVZXRs0nuiFKUFutq4vTBmiMHWMnd8VlNJX3xbQpcO70VMGIvVdjwwU071qaV7Kfgp445ni2dvqdaCvyLk1v6RCZHWYsj0+35FPI3u0sRLyeJYzR3UXzwxzjknMgUAYjhOOlYnpeLieHw7LoZv/8WXQmjdchbqXFdo3B0tEv5IBILjW+Ol/CGy7Ar77DpWLor+m+R8ZbQ/8T3ARbrU/YVxBEEvNkJPwmuP0MQm///nOAkvA/IgIQO1naHOwqVq6aleIZcz8KblizlSzaECgz540gG594asQ/3zYc136RJ09E54pAnJYUwUFRTiIzWAwGAzGcYXjJ9eU0ejAovK6sT2psMS+SPayzkABL/hMMhh+kFds32BiY5fveB+bKKSJT8jtKBSFINu8ZY4AAQAASURBVHNVCLX6tEG0cXeR8fs2ixZs4rB5BImL//oNCIEgdSm0pHrPzzkE/667P4FkNp2ra/OOjSZU19isqrB9B0o1+N3q9xjk+LVn9qJ7lq0Xf9tUhCAh5ry8hlZ9WyiUZ99qvuCma8LGWl5bp8xk4WNaUlntPE6/zhki1dxGouJ65f3Ehhq2ECACUaAOCkao3lwor6xx/raXohyey6ZnAaUjo+FwtXk1k0DNIEEfHNQlU7RR0/NR0ar++frpt9FEenK8IIT8ZtmAaAPxrFuyyfaGYo3Thp4QdD+cgbctB2jhf7aIfieBvvf7t7dSZ4Vkc6mI8frALpmCHNt5sMR5vVhnqP2q2GATJ+3nQCwmxB6pyQCCDN7JqLPgZUOFoNmw7q3rrzHPV7s53nyUZZ+yPVvcH1iiQFFtAvoKfMzxTA4UV1BZVY31XmMegd2QF9BfTQFd1/PSIecB25pWXq9+rmq79AO/dkj4XSivb3vBX//zCvhCkW0l77ccELZiCGhgjYRnpPan5z/eKTIMdAId8Jrj1DFJBljuWbrOc12kPjfYQOk2VfLz85asEbY+b950higei/8iQH+XVpxdHetk8WXM8cjqO/uRd4QV3Nm/fkfUTIC1DIh4BoPBYDAYxwdYic6IGqA8Gde/g9h82+BlnYGiiF6+hQyGX0sEENO6bYdqJQBVFJSUIMQWWhTk2GCVV4Vn0RIJvBRaOvyeQ6QFT70279iE61kjtu9I5SfqIQCSBEOBv4v//GFAHecq8ooN8JWje5AfyHFGXpskPLcfKHYex6vILK4X99OmmIXHLgIFqm0B2lxKQpxIFU+MixGEu9oGce0Bj+yUBKtiH6/D3sIE9kSPDrzavM06adO+w+JvPB/X86uq93b2028bUvDPZIeBIBZmZpVYgl0B2quJLDvdoejF9aGYpn4/vPyEVasG9CFYYeSekEXPXz2C0pLiKC421tn/fz6uj7BlMVk+mPq/2mddwDgRiQ0VjgPSFtZTLpj65/Hio3y4vFIEG88b2IEGdMoQY7g69snndNfE/iE1RdA2rx3bi8b/7t3AZ12Fb/EZjLMuwEIGBLELfsZT2aZsa1o/c4mf/uzVdtXjI4hry5zQ+5/XWhz902v+X/T2Fpp6UhdhjVdWWeMr+841xyGo3qNtmiC35e/A6seWoaAHMSDAwbiJYLlLkIAisAM6ZwZe27C7yBpUwet3jO8vLF7W7Sqi9XuKAgWK5XoS93z+lIGB4B2DwWAwGIyWDWYrGVEDPEtBoMfH1gp1CqxbdNJSbNp7tTEqiZBqCWUw/jEYfuBliZCZEm+1B9C9pG2FJCO1aAkXXgqtLlkpgtRBf8JG1HQOJuIt0oKnfjbvOtng+g42wrEwZiUK+HqDUFY3yF6ZKtjY45+rkBlex/v6teE5wjsWxIztOPJ1W+AFm/RubdKEatKkqrx32Xp66vLTqKaWQooRgjgAkXnzP78KKWaKv3EvoYaFRYauisN3504eSNMf/9B43kfTGqQlI5KAkyiomFy3lAIJi/R/qBf154fnWltT61lcNtJCgi6ANNTtFtB/4eV+9+SBNHdJsD0G2ib6igvFZdUiCBaJatYWhHIRpDJTTahPc7I9+78E+hVUsa4xEEp99Et5v2X/x+u2IIM8zuTBnShB8br3ajdyjEYWFZStOqHckoBrTUqIE+Po/kMVtG53kbjWk3OyQup8lFZUB82zqJMB//MrnvokrHuTmhBnfdZ4lpmpCcIf3AUc2wtyXrXNRV5zmd/Ap2v+1tu61zHV972KgaYluu8Bxg9JzMPeBc9OZnO4gPHLNsfBPx7zq4p0j6wAGQxAn81ISRRWbPCCd0FvT7pNmg5kv1z7zOd0Vr92YnxH3Rp9PYmgo9p+GQwGg8FgtFwwic6I2mbpvc376c31e+nW8f1F8VC9YBM2yJVVtXT56BOpxlCAaMbI7sIKxmN/w2AEAH9KFzkC8uKv768zpvWG4yVtI9ijCS8VMoJL05/4iN76xRniurFZ23agOECWY2N4q4F4g+o1koKn2Lx7EUjTTuoS8h0vwh7nbFPDeanjqmvqvOFlITN8Wh1nEKCbM3kg7covpSmDO4d8H+nlDyqKdB04vsuX+cKhJ4j7NTQnSxAHOvAMVm7No8+2HzR69tYqHq66p6sk2kAiPHThEEF8yqANSFr4QZtsBo62NUhLRiQBJ8x98OyVhBT8c9HGoNQ+XFYtnl1WakJI/YBo+LKHExyQdgs6Tj+xjSClVXIdfTshzj0Tg4zU74df1axu7aEWE/WjjrUVMpTe6SBnVULUVvQZFgx3TxkobClkEcbV3xUIu4+/vPd14Dg1tbXG4zz30Q66cGgXcd9cNR/kfTIFR/RgWkuBuFZYi2wxXyvR10F1PjDO6bU8TGOsi/zFM8DzNj1rfAdrzNkvrRZBUGsdlF5tAvYxrgwQ2aZgeYS2AKi/h8xMF/wGPm1t19TWwymSHphDY2KMawb0Ndf8jwAcFNkim2xYDu0uKgucrxdMcxzWP6YAod8gAp4pvPKF7/3I7s7j6x7mMgjqdd+gXtcLvwPv19vNLfQZSGAwGAwGg9G8wSQ6IyoAudM+I5n6dc6ke1A4z7DIxDL0lO6t6c//3RakiMOCtlVyPD26YpNYpOrEHIMR7gZTbgRBStjSeqWXdIcMahKwKbRQFOyeabn046c/FRtbELGmwpdIe4eNiArck9vqibdw1fR4DxklKCKqno/cvP/9453UVvFYld/xIuwzkiushIiXwvyDbXUeqNIe5vkfj6DLD1cIwg+b+S925NPURe8HyCiTeldVpOsEAY4/Z2J/qy8zvHtxH11kFwi4R1ds9pVSL/82qeZ1QuHOiQOEYq6xbYWOZ/hpvzrQp+DZq5K6MtMCbRb1FvwS6H592cN93i4iKiUpzkiunzugg7MvJsfHhpyHX8JLtbpQg1byc7Zjqli7q5BuO7+fIDx3F9YRePh9lYzGd6D4rtlTJOoj3DM1lyqqaoS9DQhSeBnf/mJwDQRYMv31vSP9X1XwA1ivwHsaBPq8yQOpvLpGrF1MdjkgdVGcVRY7NAVH9GBaS4C4Vo1AN12rvKdqoMErq+FIADUm6Pdxr1EoHOtQAEXFQcTDdkQGhmTbwHO65bx+MPLQCljXzaMTH3vPOYfIa4R6/qdn9qS05Hi6b2qu8GsvKa8WbQRZDJFkgJmgZsOBeEZbRrFuPfCCYqB+Vev4HubwX100RKyDTOsCzP8IZOiBkKtG96BaqhWBJr1IrN9sGdMcF2kQAcdVA9uudQTaml67JDst0RoEs41bOt6NcGxmMBgMBoPR/MAkOiMqwIYHhLhzkbklj645s5cgmORnpE3Bb9/YSNOHdxMFiXRijsFwwWW3AjWZC00t7RYKLWxcv8kvDdr8L3hlLd06vh+t+a6Q7jYU+8Pmsrq2TqWt9z9JvIVT5FTihNapgjxEEVH1fLD5RsGvSOxvVKJNV5TKv6GBNRH32DBj0w+ckpNN/163V1wvFHFf7cy3FnHT1btSka5vzFFEFvYMd7y0xng/5L2EOnH5z8bQodI625zK6hq6+R9f0bm5HT2tAEwp936I8KNlK3S8I9z7jLlPBnV0uxT0lSJRnDLYoiCavuwNDQ6kJ8YbCScQ0yaFreyLpvOwHQfE1XVjewlrDr0PqKr0L3YWOBXmG/cconH92wvlK77zmzc2B0j4p97/OmTMgMocgbXi8jprubziSmEpN7JHG6qsqaE7XgTRG3zdGBvU13QF/7IbRtOkQZ3oRyO6ic/CT/mtDfvpw20Hjc+/vKo6bL/45o49RWW+vLlxn/Cc0DZ02LIaZF9bfsNo4cONwCKUxCBC1UKWIIaRuWXCivX76H+HdwvKwACxumnvIbry6WD7GNMc4rJb6tfxSFQ+kgwwG1SVPo7/x3e2Bp0nfndsn3Z0Rp92nv1Pfh5zOO6ZTUiA+f+B/xlUV0Rcmf+/+raAPjFkWzUkWyacMRlzLAJgKPz7yqzRIRlutkwV273HPUAABkXFbeuOaFr0MBgMBoPBaN5oEiT6okWL6OGHH6Y9e/bQkCFD6LHHHqNhw4ZZP//Pf/6T5syZQ9u3b6fevXvTgw8+SBMmTDiq58wI3fAcLK7wXGSC6IOtCz4P9Q5UZNU11fQTQa5voh9/r+dRO2dGy4HNbiXSoprHClC33flSXUqyDvQtqOf8qpwj3dyZfNUHds4IbGCRKYJAl5eK3ebXjkJz2LxD1Y1NtyQfrzuzlyjSBwUfNq5XjO4hFHe6ihB/Y3M7e1J/mvb7leK3QYqFW8TNRpaqm3ETYP2A4obq5vzsfu3o8ctOpfe3HhAFEl3QU+5zWqdSJ58+10fDVogR3n2WY4zNLiXczKrGGrNs7R24/qze4r9qm0aB76v/9qmRGEZfBHll69+q4ls9Dr6DY6PGgIQaeDcFI+BnjnUCskfadMumkT3bCNsqea7qd356Zi+xxqisqqG4mBg6eLiCXv5qVwghj+KFGakJxtosXmsY/PbAnOzA3yUVVSHPX62pUFhaRVv3HxaWMD8/pzflds4MqRWD7+I+vXnTGdTcsTOvmApK/Hnjd22dUkdkP/WJaBtqn5PBVuGLrtWnQCAk26OP6sEovc5F23o18vX18wrWpZh7veaQcOyWwg3I+S0m7PW7tn4u+184AdgTkEVTS3THS0cyNnCvbOuQSLNlIhuTjwQn1Qw30ziCPt8pM9l6Xjlt0oS9X34x7luVeAZ6ZouXXU5TW08yGAwGg8FooST63//+d7rpppvoj3/8Iw0fPpweffRROu+882jjxo3Uvn37kM+vXLmSLrnkEnrggQdo0qRJ9Oyzz9LUqVPp888/p9zc3GNyDYy6Dc/H2w8KQshrA4pUdyzC39m8X2w68f+7tUkVVi6mzRSDESkiLap5rCDUig4F341n+y8cFsnmzqWwa4jXp/67IDTgYXrXxP4iJV7d1INIuH/ZenNhuF5thG0LiJfdBWVic4vz89rc2oIIpo25uhm33WNdgTe4axbtKiylZat3067CMt9FD79nSC1nHN9jTGOOWbbgQLfWqTRpcOcgshyk9Sndso2BAf08/BZClcdGH5fXqI9ZejBi8bUjqb9CWmOM1PuW/I5cT2CNsWTWKHrwtWC7DtVa7o4J/Y33KFyiLDMl+H7aaipADXztmT3Fual2M9IjHHUumrufMtrBe1sOhBSHNN1j3I/X19ZlEpnGaLQVkQV1sCSkSDO+C8V1Zqq/YJTtmYxW7r9flXG4dkt+A3LhFhN2/a7tvUjX1VCkw+8bGQbf5pd6Fh09FopsfdxUxxG87kcdX6fKTxbjE4Ir+hiMudtm+9IU15MMBoPBYDAaB+7dwlHAI488QldffTVdfvnlNGDAAEGmp6am0pNPPmn8/G9/+1s6//zz6ZZbbqH+/fvTPffcQ0OHDqWFCxce9XNnHAEWp2f2aUedMpLFItMEnUCCIgjokpUiyCcseLHw5ZRIRrQg7QWwwVHRVL2kvawcwlU5h7O581LY4f1IYPpd9HP4l963bL1QmqpWM7ZnJgrDjTqRLv7zh/TVNwXUJTtFKDexOc7yeI7hKMTkZtwEkDfwZdcxtm97WvifumKhUJZCSa97OGNcxOt4vym3QcaxHWOOxZiFTIgJuR2pe5s06pyZLP7bv2MrcTyv84hk3FCvMVzS2muMVMlQWz0MoUCPMRdOlX7KJpjGUn280IumBo65+YAYI/C+en74LAKKLYGAg+UHSEiMkbZ7iNehJJ87aUBgLLSN0SC/FylFmNV76TUnqc/F9kxAhj69cju9fN0ooVR2QZ5fY9gtNdbcG02gz/btmEGndssWhZKbmiI7muOm7bdg9wbbl+aynmQwGAwGg9EClegVFRX02Wef0R133BF4LTY2lsaNG0cffPCB8Tt4Hcp1FVCuL168uNHPl+G9Ed+6/xDdfF4/ionZGLQhUL0FJZk+oFOGUJbCwuFP72wLfJZTIhnRRHPykvayckhLtBcrA8GLwmKRbu4ao6BhpL8rn5lUvgEytRqbeFyTboESLfWuyz8a9RumLHzP+D2TvYRU9oKU3F1YKiwm/nbFMGFF0FTbIOPYjzHHYswyqVeh9PU6j0jHDXmNsP4wFfm19V2vMVKS8ijw6AI8s00ZIyB2oWaPjYkJUQWbxlJ9vHDVhTFZbomCxZMGtIixoKi0rjaOzZMa6735F+TSK6t20a76TCLXGO3KzPKak9Tn4lUQEs+6fWaSrzmkMeyWGmvubQzI82iKGX7RHDddv9Vc1pMMBoPBYDBaIIl+4MABqq6upg4dOgS9jr83bNhg/A58002fx+smlJeXi38ShYWF4r9FRUVRuAKGjl378umqv31Kl488ka4dNYj2H6pT0Kz6tpCue+o9OumELPrBkLZ06wtf0cKLh9KMUzvSngN5dPjQIfE5+J0m1pRRUZE7tZYRXbRq1YpiLMq8poCG9mNcWbtk/IOSu4aoCm2sjJoaEmsqaMQJKbRya6iCEn0jtqqU7jqnO1WUFgd9Bu/NOac7pSTG0eKrT6bDZZWUnpwgLALSYiupqMhbHbdrfz7VlJdY39+9P4/aJYffLyP9XTyzTqlEqRRHecUVNKJLMo2bMdh4Tfis7b7MPqc7xYT5vNNjie6b2JPyirsG3cu9hQWBsUrF/gMFQdd4uJzod6+uCvz915mn0eVPfSLO5+ELB1NmcuO0wabcj1v6XBztMaapjFle59GQcQO/nZ1Ioo/O89l3XWPk6T3b0PbdB8T5lJUccp5XTXmxWItUlhaLoqASuV1aU15+Id0ytiv94syuvsZSdbw4WFzqPG5+QWHI+/vz8sVY19T7sFc/jq1C8ygTYyTWez8a0Z1+OKSv8MeHWALrwPU79tLKdd/SoaK65+Maoxs6J8nnsgWe9J6/k+1rDvGaoyNZvzbW3NtYiPZ8G+1zi9a4afstP8do6v1YRW1trfhv4bfbqKa+EHIkOLzvO/Hfoj3bKSkpcpu6lvg7TelcWurvROtcDu3ZIeaz5tSHGQzGMUDtMcR3332Hmbt25cqVQa/fcssttcOGDTN+JyEhofbZZ58Nem3RokW17du3N35+3rx54hj8j//xP/u/ffv21TZlcD/mf/yvefdj7sP8j/817z4McD/mf/yv+fdjFTjXY32/+B//a2r/mlMfZjAYRx8x+B86hnYu8D9/4YUXRHFQiRkzZlBBQQG9/PLLId/JyckRdi433nhj4LV58+YJO5evvvrKUzWD3+3WrRvt3LmTMjMzqTkCEdKuXbvSN998QxkZGdQcwdfQtK4B/aIp9wfux00TfA1NA82hH3Mfbprga2gaaA59GOB+3DTB19A00Fz6sQpkk2RlZbWI+87XcGzRkq6hOfVhBoNxnNm5JCYm0imnnEJvvvlmgESvqakRf8+aNcv4ndNPP128r5Lob7zxhnjdBKT0mNJ6MDA21wFeAufP13Ds0RKuoamnrHE/btrga2gaaMr9mPtw0wZfQ9NAU+7DAPfjpg2+hqaBpt6PTefaEu47X0PTQEu4hubUhxkMxnFGogNQlUN5fuqpp9KwYcPo0UcfpeLiYrr88svF+5dddhl16dKFHnjgAfH3z372MzrjjDPo17/+NU2cOJGef/55+vTTT+nPf/7zMb4SBoPBYDAYDAaDwWAwGAwGg8FgtDQccxL9hz/8Ie3fv5/mzp0rioOedNJJ9NprrwWKhyJFNDY2NvD5kSNH0rPPPkuzZ8+mO++8k3r37i2sXHJzc4/hVTAYDAaDwWAwGAwGg8FgMBgMBqMl4piT6ACsW2z2LW+//XbIaxdddJH4FwmQhgoP9YZUbj7W4GtoGuBrOHZoruetgq+haYCv4digOZ6zDr6GpgG+hmOH5nreKvgamgb4Go4NmuM56+BraBrga2AwGMcLjmlhUQaDwWAwGAwGg8FgMBgMBoPBYDCaMo74pDAYDAaDwWAwGAwGg8FgMBgMBoPBCAKT6AwGg8FgMBgMBoPBYDAYDAaDwWBYwCQ6g8FgMBgMBoPBYDAYDAaDwWAwGBYwic5gMBgMBoPBYDAYDAaDwWAwGAyGBUyiMxgMBoPBYDAYDAaDwWAwGAwGg2EBk+gMBoPBYDAYDAaDwWAwGAwGg8FgWMAkOoPBYDAYDAaDwWAwGAwGg8FgMBgWMInOYDAYDAaDwWAwGAwGg8FgMBgMhgVMojMYDAaDwWAwGAwGg8FgMBgMBoNhAZPoDAaDwWAwGAwGg8FgMBgMBoPBYFjAJDqDwWAwGAwGg8FgMBgMBoPBYDAYFjCJzmAwGAwGg8FgMBgMBoPBYDAYDIYFTKIzGAwGg8FgMBgMBoPBYDAYDAaDYQGT6AwGg8FgMBgMBoPBYDAYDAaDwWBYwCQ6g8FgMBgMBoPBYDAYDAaDwWAwGBYwic5gMBgMBoPBYDAYDAaDwWAwGAyGBUyiMxgMBoPBYDAYDAaDwWAwGAwGg9EUSfT//ve/NHnyZOrcuTPFxMTQ4sWLPb/z9ttv09ChQykpKYl69epFTz311FE5VwaDwWAwGAwGg8FgMBgMBoPBYBx/OKYkenFxMQ0ZMoQWLVrk6/Nff/01TZw4kcaOHUtffvkl3XjjjXTVVVfR66+/3ujnymAwGAwGg8FgMBgMBoPBYDAYjOMPMbW1tbXUBAAl+ksvvURTp061fua2226jZcuW0Zo1awKvXXzxxVRQUECvvfbaUTpTBoPBYDAYDAaDwWAwGAwGg8FgHC9oVp7oH3zwAY0bNy7otfPOO0+8zmAwGAwGg8FgMBgMBoPBYDAYDEa0EU/NCHv27KEOHToEvYa/i4qKqLS0lFJSUkK+U15eLv5JQHhfUVFBbdu2Fep3BoPR9MH9mMFo3uA+zGA0f3A/ZjCaN7gPMxgMBoNxHJHokeCBBx6g+fPnh7xeWFhIGRkZx+ScWhIKSyrowOEKKiqrpIyUBGqblkiHyqvoUGklpSTG05zFq+ndLXmBz98/LZdeXb076DWJMb3b0sJLTqbM1MSjfBWMpo7jpR/vKiil2/61it7dfCDw2vd6t6Vf/s9g6pyVErVjzH15DfXrlEEnd82i8qoaOrFNKt2/fAO9u+XIcdXjP+bRL7/LL6EdeSVUUFpJyQlx9PnOfNq4u4jmX5AbOG/XtaUlxtGs574Ies/v8TEGeX23uKI6cOzUxDi6YvSJNLpnG2rXKpnuXrImaDyK9v02nW9+SQXNWRx8XP2cW9o4eLz04ZYIte/OOqsXfbEzn9732XZt/RP98MmZp9Git7YEjTtYB9w9eSAdOFwm+seT731NJRXV4rcfmDaIqmtrxd/AfcvWWfvQwxcNoZv/+VVQn5fjXXZqAvVsl05VNbXWMQlU0q0RvNdY40ZT78dfbv2OUtNbUXxMDJVWVosxNyslgdq3Sgp7LIv2POiaI9DeJgzqRHe8uDroWAsuyKXC0gpKT65b1+IaGnJefuapYzXm7y0qo5v/8WWD5iPTvcG9vW5sL7riqU8CfdZ0v3Bv1u85RI+9tTloXBnVqw1df1Zv6t+xVYubD5vrXGzrA/dOzaUFS9fRivX7jsmYaNqL6m2mIZ9BH7npH18a573RvdrQr39wEiXHx1JecYWYV2owT5VXie/qx7Hdwwf/Z7CYq7zOsTkCe4Q5L6+h6cO70V/f/zroPuL+/fL7g+mE1qlRO55rvMW4MmlwZzqjT7sWP18zGIzGQ7PyRP/e975HQ4cOpUcffTTw2l//+ldRYBSTv5+IO1TrXbt25Y17FKAvBNqmJ9I/f3I6zX55DZ3WvTV9tv1gyKL8LzNOpSuf/tT6m/++8XvUp2OrRj93RvPC8dCPj8YmG8f4xT+/oouH5QQtZL365Zs3nUE926cb3/v2YAnd9uKqkM3v5aNOpL9/vJN+ddEQ8Zrr2u65IJfO+NXbER1/677DdPYj71i/+8bPvyc2dzg2xqgnZpxGv359Aw3JyQ6LDIzamPnCKpo5qrvzfr9+4xjq27FltOvjqQ+3ROjjktdY8dqNY6hTRnKg79j6p4uMx/hxcn3/xDhyw3NfiNf/OvM0WvjWZrGu8DyPn42h83/7riAlfnfJySEb9we+P4iWr0JA3zwmjdeIVb/vtcQAmJ9+/MonW6hNdiYt/M+WoPs8pp4c8ktWNMY86DVHmNqSbIML39oijnv/tEF09ytrg0jCcM7L6xxcc1xjAnPS9gPFNP2JjyI6NzyvgpJKmq0JZkz30Xa/dhwopjsXr7aOBfdekEsntjv696alItK52NU3QYSepD3nozUm+gluNfQzRaWVYj6x4dWfjaFf/3tjyNpaP064QeXmFpw1BSGAtbuKaOW2POucH20RnZ8x/+mV21v8fM1gMBoPzUqJfvrpp9Py5cuDXnvjjTfE6zYkJSWJf4zoT5TqYkMuAHYXldE1Z/QU6qOz+rWn/y0so4S4WKFMhaIMKjDn75ZWHqUrYDQnHA/9GAtP0+YE+O/mA+L9hi728BtQoOuLfK9+eais0joO3KER6ID8G5tnHBNwXVtxRZXv4+uLdKgFvcYUqUbFGPXQaxvovS15NHPUiSEbvmjcb5eSCWTFJcNzKC3JPfWClNi891BEKs6miuOhD/tRujW3Y+njktdYsW1/Md2/bH1g44/zMwGqcFv/w/hxhdI/oSIHoFRF30VfxrrChcPlVXTjuN50dv/2tK+onK4c3UOMR1LZjr5lItBl/58xsntE731XUEoHiitajILQbz/eU1RKz325n77YWSDu++hebamqupbSkuJEW42PjaH2GckNngf3HSoP+77a2qCrTcs2KI97x0uraebI7nTJsBzxeZlxhfbkZ77wOgfbHHs01vG4JhNkBkd5VbUgv/RxRpKOuC8mAl2/jxL6/cL8/77j+4crqsT8ebisqsUpdJvqXGyaX1x9E+MyAp6NtXZ1nadOfMvj3v6vVYIkBfx+5rMd+SLAK7OW0M/f2bSferZLC8loUscArDNNa2v9OOo9hKgDAcb2GUlUWlFD1TU1NCQniz7bmR/I3FC/29Tbuy0IIbJ6yiqdc/67SjuJxtrGz5jf2G2TwWC0bBxTEv3w4cO0ZcuRAfXrr7+mL7/8klq3bk05OTl0xx130HfffUd/+9vfxPvXXHMNLVy4kG699Va64oor6K233qJ//OMftGzZsmN4Fccn1IWAVHo9/BrsIILVqFeN7kFffVtAp/doQ6N7tqX0ZHeTS02Ka/RzZzCaIo7GJrvIspBNincTUq2SE+zjgMfmGeftle4kNwxexzct0p+9arjzuxifAGx+QKxhs9eQwIHbpqUyxMIqkOoMFeOG/eI1kPnOc06KowsWvU+ndssOUiHpm4v0pHgqLq8SGzj8DYuKlo6jSVT7PR+kcKON3/2ytzVQNM7/aNg+2cYlr7EC76sb/wzL2OHV/+T7KgmHcUuuN+Ji7d69+Eyb9ESRDffois1BaxJ8F8p2r+MnxMcKtZpOlmCscn13e14JXfvM581OQdhQtG+VTF/s/JYWTj+Z/vre1yH3HbYc1TW11MnjfnjNgzsPloggZDj31dYGvdq0+pzR1yAQuVRRbOO6cL2rvyu0Es1+z8E2xx6NdTxIcB1qBoeuIpcWbHIMspHwEqb+os6vsP5Rj6sTlQmxsXTXi6sC86d6HkerfzW1eacxYZtfbji7t/N7eF6m5wdrk2MpPgH8fAYEuqnNj+nVlu6a1N/4npxTWiXHOUlieRw5voFAf+aqEbRg6dqQLE45R6lEelMne23BjE935NMH2/LopK5Z9PWBYudvFJdXRm1t43fMPxbBSwaD0TJwTEn0Tz/9lMaOHRv4+6abbhL/nTFjBj311FO0e/du2rlzZ+D9E088URDmP//5z+m3v/0tnXDCCfTEE0/Qeeedd0zO/3iGutHBgskUfYciKTkhlj5VNrKI8CPtTxJZKrB4SE1gEp1xfKIhm2y/GzwcY3dhWcjrX3xTIPqfzdoEC/5ICA94Q2anJgqPXBcQXLONC/L4tkU6UkRd301LrJvmsMGBMrKhgQMTsPCHWmnpql1GFdKdL60Wqc4gAbDJxPW4xsHV3xaKcRUbMklGqr7uEvgNKOrlhmv7LydSS8bRJI/DOZ8hXbOMacq6iiwa5+9HeRfNzbY+LrnGCryO9+X5YExCW8c14u9wyXgJkKYV9UScXG9AVW47jzmTBtDcxWtDAnzys/gNr+PHxcTQZYrFh0pu2L6Lvn1CdkqAfN+RVyzI/g4+FNjNHXg+uK8INLxnue/woZ2Q29HZPr3mQSDcdm5rg3qb1aE/Zz1TEtcVSzE0flBHmvC795x92nUOrjm2MSHnb1Oftq3r5TgDCzY5Bnn1JRCprvkV3vku4h5WD8j+WLnt4DFR6Da1eacx4ZpffnpmT+d3sX+zPb9wLJ2iLT7xovDlZ35yRg/aV1QmgraXDu8WFDyF862pP+BvUSPj/H6+hBlyfMP90Al0+XuAXP+p342WtUpjBINMwQy1PyNDC2I6FzJTEqO2tvE75h+L4CWDwWgZcK98GhlnnnmmmJj0fyDQAfz37bffDvnOF198Ifzctm7dSjNnzjxGZ398Q93ogJwybWTFIuA/W4I2VFiMgPQB+aNCKJXG9va0OWAwIllIwh8PJNfW/YfF300RctFngmuTjQ0ePBbh/zft9yvp7F+/Q9c/94V43XQMuWFVgX6JVFz0Q/24WOzbFq4mwgMLZwTLnpp5mlBGwyt16erdIb8tMaZXG1r1TYEYF/TPYJyAFy2Ob1McyTEFGzXTuWelJoj/LwoKph05X0kcmOCH1JDt6vMdBwVZ1rt9ujUlHWPg0JxscV+e//EI+t2KTdbrvfW8fnTvsvViXFUtDEybC/wuNijS7qIlw4s8Ptr9Wj0f2xwozw9tN9zzt41bfpV30Rr39HHJNlbIOgh4X934o++CbNLHNrRpvc/aiE1kW0jlubzXtvOAavDknCyrVQu+i99Ys6tQFDoH4f37S4eK7BD0T4xf6IdQz+nfQ18DQY9z14Hv4bdgFwV/bajRL3n8I1HcFPd/WxOee6KBxPhYMcaZAoPy/sFCR7bPSOZB2S7Udi7hau9og5hH9PaGuWfW2N5BbVY/lgoTWYx2pgdJTH3a1g+85tjGhJy/TX3Ja0xTLdhccyn6Ep6pzAgzza9oF3g2NuIe451pnjO1g2gjnHFbbYPNFa75BQEMfe8mgddR9Nn2/MKZo/E5+OSv21VIn2w/KKzt5Hf1ft46Nbht6etQEOEQc6jjuw4QqZkpCTR+YCdasX6vaM/o62WV1TSyZxuxZjtwqMK5vjtYXOFLmCHHN1i4uCyM5PpP/W44MO0L8DcK+E5e+J7nXiEawQy1P2OMaVUvljEB96SiusbX2sYPbOOtuk45VsFLBoPRMsCMJSMiqFFeW/TdlNqGRRiUXJhcbxvfj745WCoWHvA77JiZ5Mszk8FoiQoiLPpg+wHVskpEYNGJ102b7HBVqfj/3dqkhqig0S/x+YXTh9KciQOoqKyKMlLihYrcpaLU1R6q8gR4/L1tYgH92c4C8Tqgp67OmTyQpi56X/yNcQEqIIwpGBewmcHC2qU4kmPKy9eNotiYGEHcyc2KvHY8b/iRQ4kuFXdYRJvOyQ+pYWpXINBcwL3Bxg/jIhTpUNWZrje/uEJcE67huatHiI0H/ITX7y7y7TnbEnE0agaEAxQau/X8vnTtmb1EoAbPH23CtNGTKjK/5+8scOZDeRfNcU9uRjE+4Dxlf5s9sT/dPr4ffZtfKsg4tNMrnvokyJpJbvxxzIcvGiLathxbQH6c0add4Hf1Ta4sJqqSmSA95XpDXUuofahdqyQqKXfXWMCYMqhLprAd0S3onpxxmsicue7Zz419be6kAeJ6dZUb7sfvNdEAgGcw9+U1QjmPYGFTnHuigYOHy6lDG3cmIZ6Rl6JStje9/ertQv0dr/aO9xEUGZ/bUViXyLYCGxYQZUNzsoKem34sL8W6aQ1sGpNwLtIX2TRPHW2o87fel2AV5oLaz21zKQJaM0Z1p0dXbAooa03zK37rujN7CRLWq06C6iN9uKxa9GXsH5LjY4+awtb0jPU22FyzwlzzC7JzEPyvDXnOdeu4g4ftRLPfOXp3QSntOFgi6l+ovzWuf3sx9t61eE1IPwdBrs49towGk1WKJFLLqmqEZdD04d1Cvof18g1n93GeN6yq/GR0yvFtZ16J8/fUMSVcste2L8DfsNZRVe7RyugwCWpUDgD3G8/oiRmnUQxtDCmeij69pyg0S1aF19xhUt7juvC7WKcAeEZ4/rBKPFbBSwaD0TLAJDojIqgbaz9+kiowmWJixQJbIiYmRhB2DMbRLjjUVHwucb4Llq4Tth+Xa8TqPUvX0a8uGhJybpEQi12yU+mX3x8sCqXJgptIY52Y24nmvxJsgeBFvOkEm6o8UQsDmgivrq1T6PW1e4VPotzQmDbQ4/q190zzx/dBoPdsb/YEx/lDyfr1/sOB4lc4R3lOIELxPtRIrdPcgQNbu/ICNlk4JtKE5TmbrheqWLlhgKIVgEoPhPolj39oJGm90ohbAppSYb6decWi/6ibZWy04XF6yz+/pHunDaL4uFg6VO9Vn54YJ4pN+jl/r3ELSmgXkM0VbbsXSf5BgQ1PagDjEjImZN8FeXDxsJxAm1Y3/jaSE5tYSSoWlFZQeWWNsGeSJIdOZsJ/Ojn+CFFr6kOv3zgmYOFkQ7v0JPrNik3GVHqMI6d0y7bWaSitqKa+HTMC551fUiFsPjB23PnSGuN31PFQWmEcLKk45nNONIF7gjHOBcxnfhSVaG/3XpBLW/YfDpoHVfJL/g4I1Nte+CrEuke2dwRvZPFLOZ6qkB7OsycOEIR6SiIsHIKPJe1EVFJdvy4TUCuB9h8Oesb4b1N53vr8rfbduyb2d383JUHcF/RpfX6X72NOhYc83r/53L407aQuASIRYwL6DcY9jFmllVVizHShsrrW6CONvcR1Y3vRFU8fIVKjJZbwM+9EuiZoirCts7pmp1C3tqlUVllDN57dh2ZPrBtjD4hCvwk065nP6b7vD4q4QL3I1iqtoJSEOFqoEegAinbqcy6AdotRB/PiHS+uFq/ZMhp0qxQ1oHNg32Hq1znT+D0E2K49073Ggo3X8x/vDFpfSuiBI1FwW7OGso0pkWSquPYFtkK/kRRs9rJP0delOK/pj38o7v/MUd3FGN4mLTEwJvitjWSCK5CKualjRrI4Po6njkMMBoMRKZhEZ0QMubEuKKkMLKZVeKW2YeGMQn8AlEAMRjThRTBDnQASyK9as7ELS+G3V6zfJ/7Z3pfHA3EAVSc2oUuvH11HJBhUsKZNC64Di9ufj+st1JNId/14Wx7NeyXUn9EP8aaq61BcTW7E9QW0TniBLMbfXgpuuXBuqKcsiPHKqhq6e0mdKlRVr0KluH5XoVAhPbB8vXPzbWtXLhUSxkeQNVBMZXgUV8b56KpHHA8Blt/8cAj96C+fGL/T0tFUCvOhr5k289ho37N0rcjmMBHssz3Ib3n+XuMWbDNc/SAxLrZRFPv4zt6iciMRqW/O1ewZV1AAr2PskMEvfBaWS2f3a0/xcTGUX1wpiFnptT3r2S9o2fWjjesNqYiEghb/XJ9BwN6mmLQVWtSfkyRDcc5IiUcAwQU5HuK6QQ7L+9hUM6PCBYJEGw+W2MfAXm0FUQMFoB8gu+Ppldud4z2IE2QY2Ypb47uYJ23FL9UiiMiQQDFazOvwbR/WvXVALQ5u996l64wkj0uhju//4E8fhDzjplSk0qaOB1zjDCxYEAy6a3HdWCfndxn4uuzJj8Xv4nXc54R6gnzbgWJKTSwTRRzVIBzGjLsmusfILtnJRh9pqFprKHyFrVxHuTLv/Mw7rjG7ucG0zgKB/rcrh9HsxWtC5rV7pubSG+v30IKpAwN1K8KZo3XyE+tBkyXUqTl144Zct6l+5fguMihf+9mYumdZv8ZCXS69z+L875rQP4RIRV90FQZFcNc2p+B+gaSF0AWBs7snDxTzFo6NYJKJsM1Os9fFwVjZNTuV3rzpDCvZ6xpDvAI/JtFFJAWbXQE527pU3Qfg+lThS6RrfL8Zuer+CbWhNu497CvjlsFgMExgEp3RIMiJ6YFpg4QKQE3RwkSFxYDJmxSvHy4/orRsSZtJRtOA10IS6X1+1ZpHwxbGr9LWpYK99IlgpbK+aTFdB747d9JAmvfKuoiJNzkOqF6gfgsH+i1qalqkh6vUgTLuqjE96bH/bBYLeUmijOzRRlhLwAZicNcsmvfyGqPy3/WcZEo7Cs2pYx7uL1SMUpEHH2bbuIj7gHFTtxIA8MxM6kAXidOS0FQK84F0cXmjfpNfaiTYv9iR79yEy/N3jQNor9icX3tmT2F9EKTGrO8H+w41LCXaBow73+S7U9BTE+MFCaJmz4STLYP/5pdU0r3Lgsc3NQ0fqkOsN25/cVWIBceMUSfS3UvWiuPeNzWX7nppTVA/w2euG9ub8opDPc1VxMSYiVYA6fDYtKvnLO2iXFDHQ5XEOJoFEhsTqGdks/Wos+0aQJn1FiHwNPYikL3GewBzmYkcVwFSzTQf2Swf5LyukjvwZ75yTA8qraoJsbG4dmxvuvLpTzyL7LoKRB/rta9NHe9nvkWxWN2SDP0UdQnw/+V9XqBluenWGujLX+7Mt86NmEdTEuKdPtImha1t7WJbR8E7P6dNWljzDgIDLQWmfrfo0qEhBDqAZzZn8Rq67fx+IotgWX3tG5uQQJ+jTeSnieBFG+qUlUxfvJdvtWfB3KTuJ03WLRIg+wd0zgwJloBYtQFj20vXjhRiBn3elXV75P3TSW5ReVR5DwBpi++Z7Bvvm5Yb1AZ1eO1HvAI/trV5Q+chPWMN1moYI01BTtOaLRJLSyCcNYbffs9gMBheYBKdERWc0DqVFlwwUCwm4VF4Yps0qqVaOqVba6Hg0Umluy8YSN8eDC5m0lI2k4ymAa+FpA36oitc3/HGOl8Q4i4VLPrZ05cPo72HyoVCZ+PuoqBFKq4D3rxDumYFfGGlmueh19YHqbgiJd7Ua/Aix2VxvnC8ySP1lMW1I2MGRU7hz45rvXp0D7Exw33TN2YgsaEoMv2u7TnJlHYUoZp5qDslxMcKD1Go3NWNHNR3der72qDNBTYbCy7IpSWrdgUp9FQcKg32esZYCo9Sm81AS0I0giiRQt0QV9Z79Fs/a0nTvmfZeqGinrdkrfP8XeMA2i0CPLINq+QV+hPIhvSk6Cv2Me7c9dJq0dZcKKmoCiIycM8QLEdBN5DQuoIQbVwdW3CfQcrY0vCRso90bPRNk+2V7Gfo6/csW0endM+mn43rLQrLyYJyGBf7d85wXkfHjJQ6ErS+loONaJWkp7SLsgVJ9ECXTmIcC0//aKNLVrLVpx7XDh4JIxqK2/klkF3jPYh4r6wBIKBK1eYjm+WDPq+jTYJA/GxnvngN1l/o46qnOghjPWigB0Lxu2IOejnY09l0zKYCl0pdBkJOyckW9wZBM9XaSV6/X2sNOUYis27Oy8FjANoISK49Re4CiCYC1rR2ca2jQOD9+gcnBZSptnkHfX3elIFiLPLyj29u0J87sghcgeO7YF1WVukMos2bPNCXHaGJ4EUbwTrN1YZ0mNqXaw5Eu95b5LYM3FNYLmyfEEgvqB8DMK7ABnH+BbmBMcxGcmN9B8ua9OT64GFKgiCHEVgrKa+mVj5U0X72I67Aj0l0oRdsbsgYJANyULVjrYLAdo3PukN+LS11FT4EBZjfbXYwcgwIp98zGAyGF1rWzM84psBG9amV28Xk/sr1o2jyY+8HVFzwP1MnxKrqGuqQmSQme1U52xI2k4ymAddCEmonl3q3tKIykOp7qKxKLOhAPkviJxrtVU8lBnn2/ZM7U+fs1BDCSRLiUMpYbQi2HKCZRWWCxJLKCvW8sNmD5YCp2BKur1NmEg3olBFCcoVDvKn33Iscl/9fLWqG4mJJCbGUlXLEJ9EG4b6rKEZtkBsakC2StMb1g9iDssm2MUNKrtc16gCZ8u91ewM2NZcZrC9wT/GM6sj2ukACNlNvb9ovCJnfvLHZei2pSXEiBVYSGunJ8VRcXkXPXjX8qNmZHEsci8J8+oYYc1skKi88dyigvc4ffz/w/UHCLkEnnU/v0SbQd00BL1hQwNMZZD3GFRT7hGft2t2F1K9jHXFcVVNDm/YeEsVqQUj7uXfCEmNLHg3JyXbadehjanE5vMLrMlRsCkK13QpSxaBCVYt64nwRrLcF/MRxK6oC1liPrgjtT2/94gzrdeB1OE/8fFwf4a1+//JQ8sZEemLzfZ9BRecqlKpCeKsrCvfmhvatkgPjov5scM2je7WlBa8ECyr8EMiqSlqSJ3j+WG/6CdbCNkEUH9TmI5d1gzqv620SGUVqdkJZVTXddE5fuu38GGEXBnJN929X22W0rJaOliWMrlK3EYTLbxhD+SXlVFoRXNcAWV5exUIl8Pn9h8oDdmtATutUMRYCh8uPjBXqM5DjJMZOnUwzzYte2UR4XyXT5LyD4ElJZbUIZqclxYlFCBS3qG9gC6A1V6jP/aNt5nslgbkM61dXEK26JjTAYcq6MvVnV1/F5xDYgljBT3aCSREvr7dbm1S7xUrvttSjbaqoe2Gao8qrjtRZspHcsD5C28ZYBGu/RW9tCSmwiYCNC35U18iisQV+RO2Apz4JmZ/w2VvO60OxMURrdxUKUj8zFdZoCaIOiJ9xRt/TILBQUVnty97Gj6Ul9jCmTB5cly3rQB0Dwu33DAaD4QKT6IyoAUosqA3mL1kjvExdxfOwKEpLjBcLiYv//GHQxHc0C8QxWi5sCqLR9anlUxe9b/weFnjpyYl00z++tFoKNLS9mlIKz+7XjuZOHigUn2qfUQlxePj5UWJhQQj1nEpMgHRwKcJQ+OvaZz4PuVZ42Pq1ytDvuRc5Hi4hGq6tjqra0dP+vTZmtiJ5tnalk2WuYp9oP7ATeuajHQH/WLw29aTOTnIPRbd6tDMXTz1ecDQL85lUX/uKyp0bbVdwLi0pwfP8QdQsX7UrxPoAc6UXQMTOXXKkYCYIJQRzPtyaRw+/vino99Du4P+vKui8LDFsgTFkUcye1J+m/X5l0PdAoM/2UJYHZcuUuouvFpdX+8rawUbbhYPFFcYCcPK+7C4oo5lPfSLunctvG3U1VIJXquiuGN0jYL2jZqKYFMpHrr1SeKv/7crh1BzhNS6WVVRbAyR+CGSTd7KzTdYHa0GK4LzwXZXgS/MoPivndZXow5hus4HBdS6Ykks/qh/LI2mXftcSR8NeLlwVLLLcJImIe46C4JjTvfq0Pk8iUKwWfexUfz2w1EEwzpUhMkZbo9lsvuR4ZoPpfTw7rM30cXnW2F406IRMymmdImL6puB6cwbaGshTF/CcVY9vfV2F1y8+rWvI90zjuKk/exVOx94T3zNB/S6e1/wpoYp4iS7ZqfTL7w8Wa3NTEezSSu8xDPAq6okx6DFD8VQ/GSl+bR9tgoPCkkrxuhrgwDF/fdEQ8TcyZXBeR8a54CCybZxx2aT09rlm9bo2zKem8Qd/w07MlHUQbJUXfr9nMBgMG5hEZ0QNSN/KLy6nuVMGUlW1mYBSAV/iSYM6h0x8x4OiknF0oC8koVZauno3vbFuD52Sk2UkSFAYUBbL8pMeGm57taUU9u+cKVSMplRDSYj7KUqpLsi/KygVBd+gHqmpCfZQ1q/t9vExRpLrzD7twiItw1ELh0OIRmKro6p2dIWw18ZMEiEmxZ9+jSj2uHzNngA5BpV719ZuMgPvQ5UkN/zYtECJjk25idybNba3INEZRw+66gvPaOPeIlFMDbYjJt9OeP+agPehwopkbMDf8No3eeLrbVr9rhir/rPFOpah/SHl+t5pg+hwWZVVbSbHHZvSEN6nIJ5V8hCbV1i7+VGWy36W4kFsSksWL5/iLI/7DPsFBK5MiklcH/o2jtU6LVGQtSYbGgCBMBSUk4plVUWnKmWRht6jbZpVoaym0zdnYFyEGr+grJIOl1WLTJl99UWvYWUQKYFsGvtVxareJvH8ocaUqkKcF54BLEigFAdQuNYFOa+rRB/aiMue5O5X1oo5E/WBImmXftYS4c6DpvkLiETF7kcFKwkrmSnmdU3qvIwxMj0x3lhQESp+2L2A2Js4qMz4DLCew6yOZ7TqmwKrzZfXOkp/X9zzF1aFrBfl8ScN6iTIfhRahVihpQiBZFu75by+1sCxnNdEJs60QSLQoM+LEIf8cvl68b6edaWP43KOQaFQFACtKxTqbkP4ji1whXUWitjL8d2PNelCy/pVrfljAj7vtfPF+IQ5QRTKtticqet2vf2GU2Ddtr7WCzbjPBAswd4oXLuraNqkeF0bSHTb+PNefUaCbrsWbJXn0e9T4oPqdfQ8zgUrDAbDDSbRGVEDivJhIQBywZX2LTeMMirfu0N6YGN6NAvEMY4PqAtJLILR1hZNH0pDc7JDvPqgXsOGwEU2Xzm6R+BvW3t1pVrbUgr9pJerah8dJpuA7XklQl2O87zh7N4eKtbKUFJg8sCAEuxYq4XDKR5kUrboacJehU+zUhOMij+0kbunDBSqMzx7kDVYeMtCpVIhB9jGQDzD19fW2b4A8nuL/rOFbjq3L11/Vi+6fXw/QUTBkgO+0l0ykyN6FozIobYf9dk++d52sTm7bXw/oY7GmAHCFRtFEAblVaZiYYM8VaKudGOQ0SClXYXb9JR2r2wLjGUndc2im//xZRBBdE7/9qKNl1XWiHuAAPkD03IFiaVnl+F8QCJ9pxRlk5tXKLVdgFUWxkr85q3/WkU3ndPHw2Ylxpc/Pp6Vi2THOIoMG9O9wXHgdY1n/ci/NzqLIQJy3NFVdPp9WnztSFG8+NVu2c4MluYMjJcgTfR7hmcVr1ZrNcBFtprGfl2xKu+1bAM6aYO/VSUjiCM/Ba1Vog9ziGqppAO/O3ti/5C257ddymO61g/hzIP6/IXjg+Qf3CWTduaXUFJ8HL25YZ+wi/OXkVLptFOBVdQv/vlVkB0DrKn81AqQY2Q3S3E/4RtdT7D+7YphwlbDBDxP+FZfPfpE6xrEtY7C63hfhZfNFPYx7TOShep+cNdsaimQbW1vYRn9+bJTRU0Z17xWW1NLt57fj+6ER3ppXdtFDZErn/pEFNz++Tl9g56JbRyHLV67jCS68I8fiP+PwqWueS/vsLlQ9ChtnYU+hnYR6fo1HALbBqw74eFty2bB67hXP/l/nxlV3w0tsK7e80935Is+fN7ADiLDzq+Fjj7ORMsmxevaUHPFBYxB79x8pgi4YbxA0FIG3r36vbCj21EgggES23850fOcGQzG8Qsm0RlRQ2VNrVDhYYJC4bOF008Wysl+nTICC20QU1CBSU82vIY0Ziwc/v7xTqFWaq6eoIymDyyCsWh84r1tIiVYVyKCrIQi0wUsyvAPJIxJ6eSVam1LGfRSRkPlAsIW6ZFevrsSkijGovSnZ/Z0/r4pewR+200FtlRPuZkvr6oWQRKVdFA3PTrp4uWlC+Lw5n9+ZUwdvW/ZOrp0eDfaU1gmVOggUUEW7Dt0RCEnU87l8SRGSWXWq+sDr0nVD77zw9Ny6C/vbgsuOqr4yB9tT9zjGWr70ZVZsN6QJBL6CTzGk+NjBQn00IVDxLwmlWxoHy6CCmOG+LylKKkESGmbDQnIO91OxWtMgRr3T+9sC/ot9KcfDssRpLb6+rj+7elf14yk3UVlImMCG9Y9haXUq306dclMofLqmoCFg1Tu2dSBuoXJtWN70Wc78kWquctmRZLofjJeXCS7tPgwecbOGNldeMJ6FUPEWIMxBL7yfgiW5MQ4SkuME+cMpSECnHpB1OYMjEd3LltvVetinvUirW1jmmnsV7MioFhFwAdtNzY2RtguqP7y6u8im6OiqkYU4p0yuDPds3StcayV31VJJ8who3u2dd4H+AdH2i7xGe/1gz87B72QOAJwXbNTadW3BXTRnz4IKQKKjBRZuM8GjGMIPpyak20syg0iasao7rRya17g91EQEFZUutUJ7vOCKQPFc5Ak3sOvbaA7Jw4wjpVSxY/flUXJrfegtJJ21xPvpt9C/zeto6T9hE74ed1zjLNFpZXUqYX5KcvrPje3Iz342nrRThA4rssyiQs8M6kwxxN/8LUNoUVFpwwUfdWk0NfHcay7EuNiaf/huvohGB+xX3zowsEiG0sNZuC34fHdOTNZzE9q8EYvuq7360jgl8D2Kuo5eXAnYf1lm18QNLCpvqNRYF3ecwhn5ixeLWohRbIfkeOM55jkcx/hdW1ecyTqFOiFm8U4c8FAkeGC9RmCiMggi4mJCSj/kZUsvOKfPuIVz2AwGF5gEp0RNcAu4vOdBYEUtXbpiWJzg4W8Hm3HRInFjST5kF6GBTwX9WA0JrDIVQtdqe2yT/t0obbBJtarnb96wxgREDJVl/dKtbalFHopo6XKJadNmkiPFEVPy6tEMTO1kJcklaGYg/IOG1hsnMsra0QBSqSz69YE6JP423bMpgATSWXzp5Wkg7rp0a0o4mJi6H+GdqF5L681LtgRTDGp53DM6cO70VPvfx1CvsybNECQkjbrC6QWQxk1/fEPRZFXEPHydVns9PF3g0lN4F1tM2UjWpqrn3JThdp+VGWWV7vDJtWvN/GOvOKAjdML15zu/Gzr1MSADQkKX4KEBrAx1+1U/Iwp2amhWTemNG5cL9rrvVqRTbT5B6YNoi6tU8MmHc7q1078F6Q1ghD/78rhVFBSQf/67JtAYUHVZgVBdqwR/Ga8HCEK6oqRoVAa0rVBsqrvq2QnAiHjf/eueN1W4FcWsoOCH/172kldPK8V4+vSVbuFxQTaB8ZfWX+ipQBF31xewMh6uP6s3mLctREkt1rIY5sNEr6DOezCoSfQA68GkyfydxEa1sdKSRxPf6JuHJ6ptLVe7dJDMn7UtoJgrQsiaOajXYIIRv9F3wJxiP+61g8guaEWR9t57uoRIkMJNgr4vPRilsf3KiSuZlOo1k5evvQgN6WlhakoNwjOGgr2JsYxQIJizSStTnC9X35TQEtW7aLczpniXHFd3dulW8l8FBeVinavcQ3roh/8+UOnul1dR9VZhsQLpappD+IVIMP5gMBDoKIlQV63nPteXbPX+DkozIG76/20bYFH23rS1F/QVqBEl0B20PhBHWnmqLqAULv0JCFg2F1YRjW1tSJr8uoxJ1Jecd36Fh7ZGGvQlnR7p0hhI3nF2m/KQNGOEVT1qpkzIbeTM9sVQT5XlmW0CqzPAeG8JU+Mf5HsR+Q69Nbz656/DdijYJ1jyzJR4bo2jI/6HCv3O9jX4Tu4xwgcyr0NxgsE8lDzCTVg9DU7irBjSTD+d+81+0A2g8E4umASnRE1lFVWCZuM3YV1JGR8bJwg0G3KJJB7yfFxIootC08xGI0JLMSw8NaBhdiffnSK8ELHZhKKKlP6LhbCIKxBnNiqy3ulWttSCkEU2VIN9TRNuRkAQRQbE0Mje7YRfz//8U6xgH/2ox3ib5kBMvzE1mIjgaJncsMtN9PPfbSDLhneLUTF3tSslUwklR/fRnVDIy0W1KJlj4Xpf2k7Jp77/KXrQggElcCAv7IpgCOL5PlJoQVsRAsjulA3zaoyKxy/UD/2F/J3MDa57EzwvmxTaCtXPv1p4H2TPYUr2wKv69knGAfPHdBB/DYCPDLYBnLZ1uaR/gwPWVvNAxOhAAL9tvP704Kla0OzNCYNFKpHl7epX4CkvEsrbCrVpiDR1N+TtjVzJvYXBI4LSMfXiy77KTiMZ4f3H75oiJVwb67w8oEGqdW9dapxvAVmPfeFNfjsul9QFsJCUJ+v8dm3N+2n5at2h7wn2wNIZr2dyeKYNqJPEjnSCkG1MwGp7WfORFAHSlSd9IdK3ha4RXbIbS98FbSeRlt+5qoRdOkTH4p7qs7ZXoXE1XlKWpJ4+dJL32N81mUThfdVoN1jrYKiu8C2/YfFOmjxl98FBatkXwEZqfd1/I0xAO3Ba1yTFjFYS8GjG5lBNkW6X5sJmyUNxjIQ6ACUvVv3H24xWWFyzeVXlWwrwoznhOLy4awn9fUegi2Y72QA+zcrjhTQBrBmv3daLj3x7tf0hqJIt9k7RQqV5C0orRDiFOwJJj9WR8LK46njXEoi5tEjGUfIWjDZIUlhC1T4Kkz9sqGWiepeBf0Fan5ZtBfnhcAl1qWqYluSzLhG1LuQmZrIdHHZTOL+fLkz39oP/V6bPse6ijyrgcIBnTNDCHQA5z5vyVqaPWkAE+gMBiNsMInOiBqyUxOptLKGVqzfKyat9hlJnouqqb9/P/CaTLfzq+BjMCJtpzqwaISiRdpwvHTtyJB0S5UMgW2BCX5SraGIuW/qIFq59YDw0ZQL6AOHyujCoV1CSB8TgSQUINqGGpuIf/7kdPrV6xuEUlpfWGKR+8SM04QKWirQQMDPnzKQ7l22LmgRqSprgKO9IbSl9esklR/SGffbpdoJ1//SdUy5obDhhOwUo18uXgd8b1ZbEPnW1CE3zRgfIvEL9SJ51b6OY7jsTNRz0NuKblckX8NGGP1cbTMgfm4c10co9VB0DeMPslWGnJAl0vN1T2v48z+6wqzMxu9CVeulvFUtTACdQJfnjddBwsksDRTk7JRZV7wzHHgVO3vkBycJojGk5kGvtjR38gCxQbdtrDGHgLwdqxRdxpgFmxtsyJEB9PWBYqNdC9oHslxsaevNFV5ZSzmtU6lj/dpOf5aoKeEKPrvu19CcLGMhT6le9vKyVpWMeF4o6KefozofCeuuaYPom4JSeuytzcF2Jr3bCt/7THNiRuC3bEHQGfnmLDhb0A5tGXY0WB8gm1NdJ3gVEteJbvQ1v770XvOU6X31t70IfqiKXWMJ1iUQMty9BFY87voCuEcYZ037Cr+WaJLA158bxtE7Jwyg+UuCxUItJStMrrm2Hyh2fg7P1mvtm5QQG9YYrq/3ZJuyihi2HKDZi+uyGO6YUCXGYPyDj3aJZu/kBa92If8/Cgmb+jHaCdop1p4SKEA9rHtrsYZL9iB/9foRjZERqj4vWSfqhrN6EeLHKEZuI6WljSWyx+S143oRzIO9k60/Yv6z9cNIgxh4vhj/bOPIT87oQZXVtcIuyrVew1jJYDAY4YJJdEbUgHkIVgSSwDP5rKmArYTLsoDBOFqKZpBisj1isQdrBJOlgFwM2ha1fgsPQcm4fPXuEBK8Y2YKDTuxtbBBQkqnKU0zsAk3bCLmLlkrSNwnLRvuGNoYpEBDn8NCdN6kgXTzuVXi2qqqa4RSbkdeiSCFYPkAAqRLtoMZiAC2jYqXJ6xKiKMOgx/SWSfKcWyo4bCZRyowiiLjfXWzZLNn8CIQbMBvYSNlU2LifT8ptF6bVUb0IduEbA9+gx1egCJNBRTf0mvdNPaoKlm9rej2QRiLYPmAgqcL69scNrFQTULRPleod9Xxp43IWEE9ExUYR+B964K0lXHdv4KSSnHOuCaMJxhfEbDUiWpJ8EF1KJXBkawHvIqdHS6vElZOOsmKvxe8so7mTBwQVGQsuFjdHmHNAsIU0McsBCZcdi0ymGobC5ojYGPg8gsGoW2D3+Cz6X5tcxB8Xv0UhPgr148WNhQ2WybTfPTwhYNpyZe7PG23THBlq9ngCtoJtfXEAUHHxPzm5UOs3xtkqrnan/qMvOYp/X09q82L4MeaxAZ1Lv/VD4bU2bGgnkR5lbW+gGk89lpn6MBrIGgPHCoX6yPUN8BYWpcFEZqR1FKA62ybnuRUJfsZt7JSwh/bTDZKXiIGBNyg/HY9WxdJ7rddhFvoXm23OMZf3zd7ooM+l4F0eezGmBfUvQqe5XXPfk6Lpp8snq3pvBCIV20s1UxNXCuyYf7vyuEiWG7aM4WzLvKCvJcbdhdZhXpYW2BfM3/pWk8uQmYQtKR+y2AwGh9MojOiBkT7oUCXKgFd6aLDtBAPR8XHYEQCk6JZLvokPkXRuJ35xsU61GYgwU1pu34KD2EBD9/Pdy1+oiCXkuLjRF8ywbV4x+vwJ7RtUHEMeEqqgKKkd062OK9f/POrgI+qboHwy+8PphMs3sfhwrZRQXHO219c7fSUVzcjUDC6YAp24NiwmTJdp7pZstkz2Px5vdTmerE6HTjWO5v2exbfA9GKDa2eAszpqNGBbYOttge/9Qu8gN9XgU3nyTlmkmC0YlMAQP2tWwyodkU6kacSbMI6I2T8ySPQamqQzS+g5nUBfQ4qQV2lpqZcq0DbxvXeMzWXdh4sptTiirAtEmwFnCVAottUynj91vF9Q/qizZpFH8v8to+GpuQ3JTSk4J3f4LPpfmUkH/ED1+H1HDCWQ838mVLLR46rGIvP6tfeqBpHYMrWdrzWsK6AAfq3yUrOO2hXRZmdgklAV0aUfm/Q17q1SfX9jFx2Kvo4pT9/PwS/37lM2rGs310kPND9jsd+ateY7gWOBYL/wdfq2jjmYRuJ1xJgWqep4/Yp9apkPcisoyFEsGqjhPnOqy8goGtTiGPdPW/yQBEcNZHkCBj4bRd+C/zaig+7ArxXjO4ROK+GFkO1Qd+roM8hdmVrz7gnEJ3Ic9HHbIx5lTU1QRZzOqKtqHfN8VjHSJW6FxcBsYHMNGEincFg+AWT6IyoAYW7VJWAX9/CcFVtDEZDoSuasWleunp3oL2arBHkBhGF8KYuej+gXlAVKn6IBJG63gDvSK/F++Ey9wZU34TIhS3uRb9OGda0cZf3cThwbWChfg9H3eMnaKFbPMxdvFp4wOOZwzICBe8kEa1vlkz+l6WV1U6i26Y297pvONaE3I6iIKwo+KS1H/g47z1URt8cLBWKsHW7i8Q5g3SVm1qG/xR9E7xUaLI9QFVt88gNhzAAiad6idrGHfn8UVANVlKyTUEJHS5p6QrC2TacdeReG+O4hb6QlmhfSh7JnDH7UptIexTahX/y/FfWimCiDAzYVKIm2Ao4S5RVusmYb/NLRUATVjboc7qyDoGDwV2z6GBxhSg0etv5/QKFHl1rn6ZWayKasBWFAzDvyT6ZnhQvgrdY64m/k+PpnP7tg7yM/d4v1xyAQJNrfkChzM925FutFTC2mvqKF5EH/2+bfYQrYID+v/jaUUI9qbYdr8CtbOvq3Irien7W34HiwB6ZZup9Dnec0lW+XgS/1/WaPm/zZMbr+u+FqyK2tXFpd9cSYVunCVUyxdCSWaPpwOHyQAC1IUE0P8D30U53HCxxfg7nY3u2fTtl0B0vhmZxynXfPRfk+m4Xtn4s7aGwvoQQR65BALkuwVyCoJ1N/IDx8c2bzoioWGhDxUR+AwOmcRcZa376YUPWaCpQKNyGcLgI1LfAWkqfuxgMBsMFJtEZUQMmSLUgim2hDaXNjFHdraRPan2RHgajMaGq2rCo27i7KMiPWFojgCDBoreyuobe35oX4m+rK1Rc1eWBhnpHeqn2vMgjVYGmEhQ4L69U2Whkibg2sLrFk47i8kqxEQf5ghTuzNQEum9qrlAevblhf9CC/d6puSE+8jvziuni4d3oqfe/DvF9lkS0vlnS2wk2zgsuyK3zYw1Tbe4FeayFWvtJTogV1hMrNuwznjPR18Kj+XhHuCn6kagT5b8Ho0AY4JzumzZIFL/DxlNasqC4JZ4nim27gjDwXg43YOM1/pg20jZyD23w+rN6ixRvG8Ih7UFAzJ7YXwSrkII9NKeucKcpwOUFWwFnuQZJ91hngGDFWIjz0K1ZbAXNZKHHq57+RNSUkNco0ZjKwqYCXS1u6pO4TzMVRT/uC8ZrwFQU0HW/XOQdPOtdgaZ9h8qsHsv4+zuLR7mXwh0KyeVr9ggSHvMU5myQRejvLtIfn3917e4gKzkElEBO2UggkOBo63pfcxHdmL+KSut8xf0Sdfp9lusjBP2xZoFdh+u3/BL8kQSZ9HFUbWd4XR/7G6IiVtt41Z4iaqlwZjxugeChWNgGor6P37VvQyEyIWPqxm9TJoi0xLNl6nnVMimuqGoQiWyaF/DakzNPo0VvbfGdiQVrLNVPvTGA/ghF/I3jetOdE/uL+ijIsHVBJZZN4y769/M/Pp3uXrLG2g8bskbTkewoxK7CNhaqmWWvdssO8bFnMBgMF5hEZ0QNILTgq2jzaFU3BM98tMMYgYfaLTHWvUFhMBoKkxICG0vYfKgbWLTnrq1ThU/42F+/Y/wtnXT1Ull4keBe3pGuTTg21CDRbeSRqkDTCQqcl1q40IRoeBq6NrAucgKbkVYpCXTLC1+FZAfcfF4/+tGI7sJSSipG71m6TniYylRgLNxvOqcPPfafLdZCRFIVa7tOlSBa2IibRZ24F/YbBkWYes62YmzHCyJN0Y9UnRgtwqBbmzR66MIhIjAkfwcBab8bynAtQbzGH1MfVMm9O8f3FyQh1MNQE5/Yus4GwjbuFZZW+CLt0b9Bfvz+P1vozpfWBK0JbAEuF2C9AFUsiojqG3oE8f+9bq+TyOvVLp1e/OlI4a8bbqHHu6cMFN72KGx27wW5InsFPsqYT7ysb46HPon7VKuMXXiusPuBNc7t46tEsDQzJVEomvcUlYlx3aVW9OqL6ntom2lJ8cI7uaK6ls4f2FF8xuTPb4OXshHH/st724IKnkoiCf1dkk9QQOIegNyTbXbF+r1BClX469/8z69o4fSThQJYJ+KuG9srUBhPnVtN6+/ubVKpS71VGVGar2sN5z67gO9A9Q8FLoJjo3u2Fee+cmtd5p8MpkQaZApnHPUaA9E+/LTtz3faM3SaO/wEW9H+kTWnZig2tkXVCdmpwvZv58ESIbqQRDlEMCjqfM8rEBvsN5LVXkprr/7vRSKb5gW8hgLEXmtOv0GkaKi4XXaK4WR22sYDWz9s6Bot5F6UVloLsWOc8+IiXl+7NxDEYCtZBoMRLphEZ0QN2FBjUlcJPOnRCmCxeev5/WnDniK6cVwfqqyqDdkQzJk8UNgmMBiNBbmA/EzZwG4/UExds1Pp3mmDRDuGekzdIKpFdEyQpKsflUW4FiQ60KegjodqRM/wgCq7a5s0uv/7g4UqSz8PlwINf+8tavjm0mux79rAYmyw2WRAmYtiiCbiqpY2CIJPVxnJRbEkSF1+8aoq1pTKabqeo6FagfIdyj2kwOvqKvWc0W6PZzQkRT9SdaJOGKCNqLYVfje40irmaMArCNeuVZJQzsk2BgJd9QHHeCl9TyXpZRr3YM8h1PQetikntk0TRCFqCTz02oaQ4J8kqJ7/8QhhsVJRVW21ytD7KTbvckOPLDmo7T7YVpdNBNiUurimTlkp1K1tmvg9UyFqV6HH28b3E/9/+IltaK5WvDRS1V1zRDhZCLi/ILYxpkaiVnSRd3pRP5DSNp9nlUgTNkaG+Qj9An0E7em/2u/cel4/enTFJkHK6z7rK7fkiQKJEHziWiqramj24tUhNjLquSCohf+u/q6Qxg/qKGqaqIX7rnjqEzq1XkWpz63q+ht44+ffi4qthus3bPP+4fJKY/YG1i0vXTtSFPjunCkJ/sjgdxx1jYHS3gFrHddv4RoRqLdl6DR3+A22RitD0S/Qf3VP8zH1mSy/fHV9EIEOyOeCgCaCSK56MvDGfvaq4UHkvBrg8SKR8R19XnDNFfoY6BVEioaK20VkI7tSBp79ZtiZxgNkyJnOJ5I1mj6eqFZgyFpf810h/XxcH7p+bK0o9Itw4n827qPX1u4JGrvVsbDOqit0v8BWsgwGIxwwic6IGgpKKujDr/Pozgn96YHlG0II8hmjTqQf/vkDOiUnm07t1ppOPTE7sCHAZrd1agKtWL+HzulfpwxiMKIFuRCDKhLtDQWRsHh94r1tISoQLEh7tEsPu/BZOHYQkXpH4hi3vrCKPtuZH6SqwIYGfrwffX1Q9KWc1qkOpbRZgYb3UFzMpWLXN5e2DbNrsW/bwOL183M7CZVajR4g6N1WkHmqss+Pl7NcFEuCNL/YW101xrBZimYKarjApkAvcmtSVx3vHo4NTdH3W9zQhmPZRsKBbfyR9R4u/vOHYsOJoDcIIijQJaGn1zLB99/etJ+Wr9odkl4v/GdfWi02qybVLhTZsK2pqqkbv2JjYoQPOtSduiIQRPrMQ+UBWxXbfbU9gxvO7i0Iy8u0omdSnYa6CNico7BcfFyMUI5Loj4S71jUpUAAQU/hb4jqrrn2SekRrJLJkpzS7yP6aLTVin59nk2qUJzj8hvGhNSowFwUG0NCuYk5ZnteSYDUzi+uoA+3HbT6rGPtcekTH9IvzulDg0/IoukjutHlSl0O/Vzwm+ibuZ0zrUX7JAEVDXK4IXCNgdkpifTQ6xtDxgH0jwVL19H9ii3IsRoDTfYOrgKxGKcwPk4c1CloLWar99SckO4glPV5IBoZig3pv+/WZ7JAbEC0V7ymjjsoiNm7fbooLGqz8UO//HxHPt2hZEHJ9//+8U4hQPEikU1iG6+5Auv1xdeO9MzqiNa46CKyYaV1x4T+jWbJE+4azWUFhmt+YsZp9Mn2g/Tois0hfXjx598KD309IKD2cR1lldXimE1pvcZgMJoumERnRA2pifHUt0MG/eT/fUZPXn4aVVXXigkJUAtyyU0lCHSkPMsNMxQpU07qTO1bJR3T62C0LJgWYiCIhp/YWqjF/CxI/ajHvVQWKHKmKiSRug7lXTgLVRQsQ7+5ZHiOUUkDlY1Uc0SSVoviYr/8/uAQpY9pcwl7AtOGGUoWeJTL1G2VPHln035RPNO0gV04faiw08Ez0QME+4rK6FCpW2lt2qxI6wRJkGIz5QKey/wpA0PUxY1F6qgwBSSAu18OVd+rRAvuT0suVugXDSXBG5Ih0lhtJFoFuHSoCjqQgNg8rqxXaMuxBGTDL19bL4rv4rOq3QT6lfwc5muTP61U4KE/64rvIz6xm42khcknVu3fpvvqegbXnNHTOD7gGBg/T5meTVv3HaL2GcmBsQoByTP7tBOKdF1xmJTgtmSBR/yp6dnWoN/xkjqO8dRGJuP1+JiYkD7a0IwSF8ItqguFN9rqhEGdAplAkiSd+dc6BTiKEaqe+ciqcPmsw+7nqctPo1XfFgqrGmlD3DkzmRZNH0rXPft50LnApgJz6uZ9h53XhnYJFX9DyOGGjDdeY+CCCwY6s8Bg3XM0gT6NZ7dl/+FAn6+trRXZBbCBw99Yb9muX843f3pnm2jL8AdXr+/mc/tSS1ozyz777Ec7aPrwbkEkpD63Nta85fRp33wgULAWfRZ9aXdh3f4zJSFO9LUhOdn0WX2QFp9BgBfvPX7ZqdQmPZFeW7MnaG6TRVQfvLAuMymSNYhX/QQEbxG0hdd7pNcezrjoRWQjCxciosaYm8JZo3lZgUFw9PDrG4xjbEz9+9jPqPM2AogIJJrWF2jfWAP98Z2tx0WAm8FgNBxMojOihtjYGLEAfWz6UJEWhk2ATTmDTfc1Z/YM2jDjtdmT+vPkxWh85cqWPKoxKM9sC1I/6vFtB4qd5wIPR7U/SIWWX0sQFMWcs9iupEEfwmbQjyrItclB8aZ7lc2lJA1U78CCkkqaranz5L0DAX9q92y6eFiOkTw5vUcb6t42LUTtIgq31l+bKf311Z+NcV6TvlnBseIgF1QIUgQdbEWp8DrIxHA3L98VlNKB4ooA6R3J5tGm4LtrYn+r3yruFWx90K5aerFCP2ioTVJDMkQag/hrTGW72v+REv39P6wM+QzIhOkeRXjlmGOCfN3kRwrrlodfQ7aaP59YU//W76vrGWBzPLKH2WIBaf4o3Lt09e4QSwZYzeA+6EFJZP3YMnbweuu0umwcF46WevNYAqSFjUzGyCz9bNU+6jWPNuS+hVNUV/b7Q2VVzmAIyF913EE7dVk4gMRLio+jZYb2dteE/vR/Vw6jPUXl1DEzmZbMGkVZyQmU0ybNU9EqCShkUyAQjPtom79N41FDxxuvMRBBdxeOhR3ZwZIKsSZTC0KGWORNyxX33zXf6OObWhuqOeGrb/Ipp2MczX4J68zQbA0Qyrr4SZ9bozVvmdaofvuvHNNNfQzPGXM8zscW3AsOJh8QxHKkNkGu+gmYKzDvyHNw3aeGZtpFsx7A0VijeQU8bx/fzxqUw7wsbeR0MRGub3m3bKtICM/9eAhwMxiMhoNJdEZUgAUPLBhQhBGVuTG5/e+Ibu7vlFaKAqPqhhnVwhmMaCFc5ZlrQepVVMtrcYoAk02Z7bVgA2kDctqrOBE2zOHaTghbhUkDaGhOllhAYsNSXVMbtFHSUVxR5VQE3XJeX3rwNbNKRC1EpV73x18fdJ43+HAXcSXTi3E9syf2p0EnZIoxZvPeQ5QYF0s3justiPopgzvTgqVrg36nzm6qOz3/8U6hQgtn84JUfnjs1ilrg+0b/Gwe8WzhyX/JsByxkJfZBdhozPQg4vC8/bSf4wENIcEbUjgPcx/ImGgSf42Z/aD3fyhnTXCpadUxB+OYCSrprXszI2PGFRzSx2XdPkCm6sNfGin0YsyqrQ1SEapAf7pw6AnG8WNs3/bWsQpAnQmdzHEVLcXreB9ZRi4cD/ZLuAcuouOK0T1C+mhGckWD7psrQOw1R/domxZireBVDwXkrzruoJ3KQqEmoN0ueCXYQxvA3/cvXy8sjVTvXthIyIwP1BmATZJujQO1Os5X9m3MJao63ms8co03eB1zItq0C17zZEl5tVj/qJlzx7o/yPbw4+/1EMFCk9UMasvcMzWX8kuC25M+36hEKNpyc8SlT3xMf/3x94wiAwCvg0RXCXR1bo103tL7bHJ8LM1bspZWrN8XIirwynzxM6bjnPXMAVcQ9zA8uH2o601rEFk/AXZlJlsSVdHvuk8NzbSTCMfyyeVHHkmGQThrNK/xBJZpkay5cF3Y73xzsMQYZHR9l8FgMFQwic5oMNRN+QvXnC42x9jMQm3mAiYvfcN8PGwsGUcP4SjPVHilp0KhqC8eXYvTs/q1o6y0ug25SZntaeNSXOFZEBO/BcsYpJibzhkL3rKqmiDCdtW3BTTkhCzhDa+q7eALbrNVALxUZfK8TLAVospI9piOYojumzZIbGp14uqW8/qJe/SnH51CJ7ZJEyT5nZpNhFSajO3bThBdKFIIv0+5iLb5XkJVBtKvfUaSWLij+BSIb4x5uA58H5uux97aHHLNNtsJ+VzSEuPpsx0H6Z5l6wP3WVVLocijC9kRWPa0ZERCgusIxwZJzn0yjdyGlHpboUiDf7qv9O6issC5+gXaHcYHZC6gL8A/Fht8W7q534JoqYmxRnJaejmbgl5eUMdljEXzJg8UBUVxTshymzdlYGiBQseYhb9RUBnjh66yhKOIa2w9VF5Fkx97PyQwBnXqr39wkhh3isqqxPiVXU+w+1XdNZbtQXOZf0HKvHnTGUF91OXF7JVR4qWC9XomnTKTwx7/kxPjhPpbjjvF5ZWU6LD78SpKq6rz0f7Q3mXQGeQPgunq99HH7p06iHbkHabiihrRr02BLXUMqayppa37Dwfam5dNBoolI7DuCgZ7kXxoC1/uzDf20WNlR4ZjIjBxdv/2Qb7KKrCf2bq/OKiYsmxP0Zhvmhoa4uFtakdqu9u077DI0lHHOZfv9cqteYF2gj47fmeBs//mZKeI7wKuMd2lYtb3pDj/NmmJNOu5L0LGFXhuV9XWCmIZa2KMFQh2mdqEWqMI/RMKdNNcpVs/YoyECAQiNVOR43DnExzv2rG9RNBZz7q4fHR3mvXsF/RWzzZiztVtHVXiX47H4WYY+O0zXuNJerJ7TYXfRdsC4Y9MArRb3BMcH4ImW5a8/C6DwWB4gUl0RoOgKw/2Hy4X/8WiafW3hdY0tjGKskwu2jBBIwWPwYgWvBZiJgIp0vRUm8oCC98bx/Xxpcy2ASSNF64/qzed2DpV/P+Ne4oESRwTEyNICCis4TkOD2JVAWrzhse1wh/UZKuAa/dKV/bKKDEpPUBAuZTmWSl1BBUUK7gfWBhLdcyDr66npav3CKXb3z7Y7qkwqqiqoXunDRKbH5ADXbJS6Ky+7ahEKSio2lTpqiWczzNXjaBHV2wMKA9txIiaPu/yGpUbE1Ut5RxD2QfdiEhqATR07gNxhb5kUlfj+aFYZseMUILOD/moWg2YiiD72cC62t3q78xtzItMwfv4HkhFbKzhU6r+xrpdhTRn0kC6d+m6kCLjICRdQJDyn9ecLvrpB9vyaMrC90TfQL/72xXDhJWU6q8uSRrg/105nP6zcV+Q4hXHXLOriLpmp9L903IF4QEbJj9jVXF5tTUwhvEIqsmEuDriIqG8ipIdBUnlc3vofwZba0r87crhdLzMvyCnVDszVzs1BTlV0gjknMmGQg9khputEh8bI0ivbw6Wiv++v/UArd9VGBj/l67aTau+KQiyZsN52QgvL+j9TgadgbsWh9bHwHx51+K6Ar4YH3C/zh3QIahPe40hh8vdwQ4ENLyUxLhPtmuWmSRyblfXFeFkCkUbOObdUwbShj2HnJ9z1WM4WvPN0YKXhzcC9zYLQj1o5tXuEHxy+V7r6897lq4ThX5RO8fUf+Fb/tCFQ+i7/NIGqZjV543i13NfXhsyrkCxvTO/hBb9Z0vQmnVM/bm4bBrziius60WT9SP6z1Wje9Dlo7qLdbl6PNd8gnNB+46pH2uBW/+1StQr0usOITCItQDmTFEU/MVVIesZ/blEmhnnp894KeYPHCq3rrnwvcS4GLrlha9C1u0IpDfU+o/BYDAAJtEZDQIW92oBwbTEeJG6hknoiqc+EQslQPelmzN5IE1d9H5goYXXsBGH6gapoy1pUco4dnAtlrDAhOJDRUPTU00qC2wutx4oDluZHY5Ku0t2CnWChUB5Fa3dVRSk4gOZJQuZoY9dMrxbkMJv4X+2GMny9+o9t/XND+4P+qxrEYrCei6YlB7SImH+K2upf+fMgOo2OzWBTshKEe+DZLn9xdXGYqY3ndtXeJr7Uc++sX4f3TGhStwH08YDBcdwXGxMYNlgIi5QIA6K2AsWvk+//kGwBYxO7h04XE5VNTX0+Y4CMV7q5wWoz0CqpWCpoxdlBDBezps8wHmPGY0LVXWHfrT42lE0f2mwTYOaATGse2vf85pKPtpsVfQxyKZCU8cwXdEOEmNcvw5CifngqxuCNucyNd6Grq1TBHG382Ap/eIfX4VsykGaXfrEh6Jo2+WjT6T4uBjRp1BwPIZinEGHL3cWUPe2qXT13z4NUurh/HYVlnmSg2pg6uScLPEMcK9uOqePyO5A8Axj5hc78ikrtZXzOjF+2wJjGB9A6PSrt9jYXVhG+1ITKKd1qihqZlPdAbqyUf5ucwX8lDu3jw1SP4ZDVtjmWuHFXF/sUbUU0Qn3Oosg77oE4aiHUYdEt1GTffqh19bT7RP6i/EfbVQnVh+0FPj0CiCh7+j9FFkYqEOizx2muQ3//9EVm0R2FlFd4N5rDMF8p0M9h7TEukCZqdCmfA44N/Q5KGZtY2CA9J84gMb1ax/UH6B2DzcjIxqZHNI72QWvegwtCaqHt94OMX67sqr0oJlXu5s7eYAIQMuiveq61GTrJTOKXP0X/bu8slqMB/pvyrnES8UsnzdI16HdsoOKX6vXhrVziAWQZW+gjlc4t3AgjzHsxNbC7gnrclwX5mjXfIK/MT9hnkagD0FI9FPdXk1CnpffLLTG6Atqn0bmDQIOOF+s7XHNewtLqUtWKtVSrVDUo/cGKep7t6V7p+bSPINllhh7XlotAi0Ntf5jMBgMJtEZDQIULKZNLDbIcpJCgUF9c/31geKAsgyqMywOuKgHI9rwUp5hkwByy7aZjqRgoK6ywKIQ6hEXvDz4vFTaUAehANptL64K2cBeOfpEsfi0FVkSRbEs3vD4HtLtTffH676Gq/TAfaqqqaU7JwwQdRX0lHUoSKBEMhFPILqxafEqSqcqjKBANxad3XxAKPsmDe5MJ3XN8lW8SLeu8kPuqeSgacMItZSpKKMcQ5FiDjKSx8pjA1V1h+f0dV6x2Kzqz0k+63B8NlXy0U+Wg03VjD4KpbUk0M1zdVtaMHUgnd6zjuyS5476ATZlKb7z5vp94new8bZtygF4CYNY+9M724LIb7Fh13xiVcIN5LcpuIf0bD++7aBBnv/xCHprwz7atLeInr1qhAh8qTZPuL5Rvdo6r/M9CzGL83jg1fXGAsoYr375/cGiSLNJdQfCMBKVclP3U45NSg3KkAhH+e1lKQJ/9eT4OoIFVgT3vAJ1aJ7vzAm1//lRQmI+AuFiy2pCX8f4r9pNqOsBlawH+Yz2gvEA/caWXYTXoQY19lMPizUUOFVrrkCJibHoytE96uwkHGOIXhzVNVaohTb1wIecq247v5/IhDP5DQMIYp3avXWDClFGq4AlxnHcc2vB8d5txfs6WqpvMshmPHs8OxSWNo1tEC14FVsFXHMXlNzw6DNZHMp2burTaUkJzv6LwBeIY1sx7FNyskVhX+uY37utyEx87WdjxLrbViDab/YhIOyfXvgqcE6uYqN6/Q99jQiFOo6LdblUu7vmE/k9fAdZr6Y5VULebz9ZaI3RF9Q+bS32W0+SY/xfue1gyNoYwiis7d/asN+6bsdY3L9TRouzYmIwGEcXTKIzGgREwh96faOhIE+eiBBjg2mLeEv1+T2vrKN+nTO4qAejUeClPHPbqLjbop+2it/3qg/g5cHnVcgOlgI3/+NLK5k0YVAnp8WJbdGM/m1LS/W6r+EoPeTiGaokbKpMCpLZi9fQKd2yg4pN6ZsWL/sA1SsWhL3XxqOwxKu4UZXRuspvUUYV+jOQ2Qcu1RCPlccOeluDYtmVoh2Oz6ZKPnptaLEhvBuEoiVbBgV1XW0SxNGcxWsEea2mkD818zS69syeRmUpFGAfb/cmBEBMIYCoHxdtGseC0uxnZ/cWG1+dcLMVflZVoS4iA2uQyw9XUG6XTNpXVBaSJSA+s/kALVi6TihxQTDoGSlIn4dHrAnY5EOBbrqnGK+Ed7Ulzd1rXmnO0DMk/Cq/ve5JQWlFoJ2bCtN62VDY+p9NzSxIfQ/fZL14rByP9d9EMoPsW5Ickr+j+w2v3VVo7qebD4i+aCPBsMb4vw93hBCS6NfIhPJTHFUSWK6xAmsQ1ALAmkQPfMi5Cv3SVdhUZrk0pBBltAovYxxHXYRrx/akGgod6647sxd9VD/WHQ++yTJwX1cofbNxbJNtAOtOve9gfYdng2fhmrvQxuYvWeNcI8FfXC0W7WW1AbJazxxRfxMF59tnJNP0xz8UQVV9ThBijam5Ym2IeRX2XK1TE40Fq/0G7bC2RR0idSyRgQr13OScM2Nk96Bio7Zjqms/v7Wf0F9c9VvkGOpl16iPtdHoC3qfto5Bmw+IvQD2Cis27DeOhcuuH+08lrx3Lc2KKZrYuXMnHTjQsEB/27ZtKScnJ2rnxGA0NTCJzmgQUKjQb4EWdWPdvU2aeE8WZ7pkeE6LX5wyjh0iXSx5kbJ+2yr8kBvqwecqZCeUKDa7mC15YnMeTh/1e16u++qXPFEXz1jgy0WxnkoMAjyndR1RID1iVeAYyGqx3WdskHB8/C5UrvvrrXxMx0H6LzZSaR5pv0gLxvd025Vw0mFNGxOMkVBb2tRxUq007aQuzvNjNB501Z2LTI7EZ1P2H1iEuID268qWuWNCf18FDW8bD/uHI2jTKpF++KcPjVkQVz79iTg3XNMpOVk0aVAn4TEuazCAJEAfu/m8vlRaUWW8JyAlUMwYhKiNcDMRFTj+uP7tBYENa5bfXzrUmLIPwEIGCnicv22dgqAcsnVUWwGQfCBwHnljo1H1i+eJWglOEt+R5u41rzR36EpMP/Ov1z0pr6wJtHNbuwi3/7nUzH6IqfYZwfMDiET9N9E/X7jm9CB7idXfFdBp3VsH+hXmLaqtpYf/vZEuHd6NfvPG5jDX1G1EINdEHsKMCMEqFzA3Y7yBZQ7WEiju6horsAbBusN2j5yBtd5tRd+KNNPP63tQOB8srhC2T3pBQRPQLk7r1loEOUxj3RX1Y93x5JuM4vSw5LOtKUUbKKmg+5atN/Ydue6rqq2mJbNGUXxcLB2qr2GDDKfrnvncc40Ey5JNew8FFOQ4Jy+rDbRL13705+P60GVPfizmplfX7g7KHEMfbJUULwJ1qlAD14SAAuxJ1bnAT9BOrm0vGRZMJOoZhvgsPMsRiB//u3eNcw6gBhXUvUcktZ9sa0pcb7c2qU4/clUpb7LlisRiSe/TXnOrKxhgu38SzDF4E+j9+vWn0tKSBv1OSkoqbdiwnol0RosFk+iMBqGo1LvgoT4BzxjVnSYvfE8sZLDgUtP2WvrilNG8EG4BGtsCUipLTUXToOrEoi+zriaoE9i4qr6w4SpRbPDyhjfBz2LZD3miLp7lebrSyZ+YcZpQEukLZSyMcSwo829/cVWQYl9mvcArVqqRQJK7bFemDO4sCBGXjU5mcgKVVtSEbIpSE+PDeh7qxkSOkdi04Vrh/ahfC9SFKLTXdrQ5AMJofOhWFVJdBtJKL/wVrs+mXjDRNQaBzHUBXqJoM15jgF5AU9oJ2Tay2PCjuOICTc2HPgol2Bvr99Dj/91qDeBJuM7LtPnftu8Q3TWxv1CjeVklwcMXRZMTvucmEWA5o18nfg+2FAhYqtd3Tv/2oljbofIq0c9BsJgIfMCWKeKaV1oKws2S8apfsnJbXki7UAOgsCQ5f2BHWvVtAd27bH2QetXU/7zUzF7EM2oCwE4LFip49iD50pLi6eZ/fhVEoKNN3r98vXEMv77eXmL8oI7inHEtaR5zhw69xpCEem9gJmezr1DXMVhbwAph/e4i5zFloXMbeSfHQnjZ6ySr+iwizfSzfU/eb93OQ9rBdTNYkAAJ8bHOsU4do1qyb/KzVw2jTu3qxAYb9x52fhbFO12ZAMhg3JFXTAteCVaGi+LQVw6jb/LcxT/jYmNEn0D24as3jBGkvtc9l+3Stc7FvvPW8/oJwh2F5BH4Xbe7iHq3TxcqdtM1of9gPEDQN/BbRWVWkYPsU3JtayJ81fYmrVkwJmEcUW2V1KLZCXGxwqLsz+9sDdp7eBXhVElvZKzon8XYMH/KQPH/rx59otWGS2bLSKW83hcaYrGk9+lwLWVUZKTEi3NFQXddIANPdS+l/fEOKNBBoA+/Yh5ldLIHK1wo2r2dPnpyvvgtJtEZLRVMojMaBExWLkAFAhWO9DHV07UBTHLYFGGyR+GTlrg4ZTRPhOPp6rWARBE/2KpItWNA6fTUJ2LhHG6FexUNUaJgUY3ju7zhG8uPVF88y/N0pZPL9/WCp3JTATIFxZdUf2d13IHCCWok/AYIdZvtCvyTR/RsQ/dMzRV2F+qCXN43jG+SjFcX6+0z4n0/D5w7xr38knIa2aONIIvkuT7x3630wLRB9E1+qSgWK68FBDqPlcceerYFgknIFoHNQ6Q+myYlK4habOT1/oY2kFdcbiRyZZtMjI+huSjQZcjeUIG2rG6uvYqvoXjm7JfXmO1hXl4jigdOHtzFUxVm29CKws9FwSp8bIxvOb8fzV3stgHA2IDP1tSQINVAyIQ7PuL38FyhVrxrQn+qqKoRzzcxLjakuLGt1oFN8eaaV1oKwlX72e7JpEEdRTCjoKyKRvVsS62S44WtydSTOtGkIV2M9XiW3TBaKF/hn2zrf14qaDxnFzH1+tq94rj4/+h/3Vunin6v/qaXrRfmnxE92tCkx94LskLx6neyTgmKPGJekjWGJPTgsPwb1kpeAT6MaV7ktrQas5F3OBfMUVC2q2MhFO6wjoFlG/qSzSrDqw3Z1ju2+60WFFTXJ3KsRftyoVvrVHpl1igxjrRNTxJB+JaIwV2zKSMj3VcxexvUOh22ouxYT5mK2apAm8A/9CessfzMoV7n3LV1qnjWEFOontnow5MGd3LWZMAcuvyG0bQ9r0SQse1bJVKPdukhFkBjlD4la/T4zZJRxTayUK/Jkx4BIfV+2MZOHFMGDJCxhaByVmqirwxRUyap7L/PXjU85HsNtVjS+7SXet5W+Bz3E5m/ENMgOw7FX/XaEmf0bR84ZwRWsLbG/gxBUKxHeF1dBxDorXP6HuvTYDCaLI45ib5o0SJ6+OGHac+ePTRkyBB67LHHaNiwYdbPP/roo/SHP/xBpJvAb+nCCy+kBx54gJKTW+aipqkjPbEu4qsuzOXm/fQebcQiCEq6tzftNyq1sKiA5yAmZ2xWUXmdyKwWYTCOBfzYkvhZQOL7qpJF/1xDCuo6VXy92oQozfUFZzh2N9H0I9UXz9hs4HzdXscHaOao7iG+8IHFfGmoqlQF7gXGIYxHf//JiKBCg+oYNiQnm87s014orm4f319s0Ba8sjaEvMeG5q8zT6PfvbU58B7UiTYFO65P2lBgwY7U2S7ZqdSd0sS9hRpwXL/2Qe0MhINsf7BwgQKdF/pNA6a+0yEjst8y9S20VQTaoITDRh6bWEmeTVBSv1UiF9BJNPRLm3IObRXztDrOZSUnOLMwyqvtVm7yO52yUsQ1uRTGJmWcDBDA4uLVn40JjLsgvfKLKz29qnF+904bRFRTSw+9vkGsLcIp5CbXMOh/AzplCLW/sNxA337ui5Cxz1TrwCurzjavtATIaw83tV+/JyBKcO9v18g4OeabSDq0jXkvr/Wch7yI4sLSCisxJYvfAjh+XExMnfWSFvTxsqyYM3EAHSyum49km8PcgDnC1MZxX2HpoF4X5m/d8kknk9VMKQSRQQLi3toCDChU7ixknpboGQxC/63LnKt7DX1XV+ljTPvnT06nnfklotijGgh09R/besfLsgprA0miB9vIlVmvF8/71bV7AgGT+6YOopYO3BtkEcCCSLXoknMN5hFT8UsJ9N0Kj/kB84crSIVjqr/nB2iXrnUXrMW27DssLJMuPKVrkA0Y1nkuYN7FGC2tx9B+f3JGj0AABvcGavlO9etpdW3r8kDXg1ggc+8Y308EDh5+bYO1PpBeb0MdO1E/AkFfkMJ6wECKXWy1jlSEsy+I1JopEns8tL+u2Skhz1rM+1OPiEvueskQ5K/fpzzw/UF0+79WB62HcLzrz+otgmZYuzAYDEaTJdH//ve/00033UR//OMfafjw4YIgP++882jjxo3Uvn1dpFDFs88+S7fffjs9+eSTNHLkSNq0aRPNnDlTTPKPPPLIMbmG4xlYaME/DuldUMlhsnLZI5iUWjKV8uI/19kzsMcvoynCazHpZwEZjSKlrvPD4tFUeBQkL9JATUSV37RklQwBgdeQxbJr8YzNxuJrR9E3+W4vPmwOQEJLZXZZVXXYqnyMNwWGwqG2MUymsq7cdjAwhuGc39tygJav2hW0WFc3TXoa/4xRJwbGOwDXLgkfWzuTr6NwFlRFSLVGFhDIDpO9DyN6kPdc1CFo5HtuG0ekfzgUqCBzvYhcQCfRpG+/bg8kCUl5TWr7cxUz3qMRhq7iXTYyEkXUvv+HlfSLc/vSnRP7U0l5NaUlhQYIJCmHa3hyxmmeYwMyUe5duk6o8HAPYOliJDF6tRXWSWohN1v/l+cAhaCXX7UcWwF4TNtI5JZY2AzX/tD/DBZK1EiyldR7gr53k6FgNtojsnNMZBmAdiYJbdv99ZonoGJXiSl4QIOEVbOavApbe1kSwGopPSkhqM3JuQPfVK/bNl/Lv9X53UQmS6U7/kn7iEgLmavjnx74QP+Din/foTJhl4E2D+jZNYumD6XdhaViHKmtrf+tzGTx+rMf7XBmWtnGFC+oayx1rMW5wZoK2Wcm2x01YIIsG1vB4JYAU5ahun8bmpNFC6YOpIm/e8/6GyCbvYrZwq/eT5BK/p4fuNot1sHIYPntm8HFUuW1gUdwQQY5ZT9Df0LtAlm/QF3HSaifV+3+MC5AQIE+iOKs6hwRHxMjxjbYpVnrHFnW2frYefM/vgz5jUjFLl5o6P7Grz0enhdqrTzw6npjxuk9S9eJDJi6wtD2fcr+QxX0mRKoAWS7mDS4M03I7dhi+ziDwWgBJDqI76uvvpouv/xy8TfI9GXLlgmSHGS5jpUrV9KoUaNo+vTp4u/u3bvTJZdcQh999NFRP3dG3SIUBVhWbs2rt0YYIDYFj/x7o2eqtYr0pHjx+sbdRS1GicU4vuBnARmtIqU2knvB0nXORaWfFE4TvssvoR15JSLlEcqdQx6+kyAaXMSR1+IZBZ/O6B0aRNVVQWoxQpAG8CfGhj4cf0goh8JJCa81jGFQBuobFVX5B1sLpLTjfrgIGNs9kgEMkDhQd2G8laowSWqg6Cwj+tiZVyx8Uk0q2Ma4537GEez11SKYqpoO5wnrERACJhJNbZOHtOLE4RYzBknqdzyTRBuyQHYerAuQqX0BAQKpAvvN0k0hm1/0EfgcQ7mamhTnOTbIa//JGT1Drh0kBgL3UA9jvfLMRzuC+qOt/+McQKCZ1jDqNb9z85min4KMEmpMpb+qJHKkBdiag58yYAr0hEvguAoFSotAG7btL6b7l603kva49yCp/PiES2IKFiQoPmmDqbC1lyUB+m5xRRU9d/UIWrurUAR79LYqLVx0BbprDvUi7/0E7F1933R8/LPZvKGGgfoaFLzJCbG0bPXuEEITYwAITy/LFFMmRyX8m3yOSepYi9+49IkPRZDizokDBMErbGcM87WrYHBzB/rFnVqxUADPCMp01LpITYoXxK/q3W3qOxj7/BSzdc0L6u/5RUi7Tak7XyjfFywJrt8hrw1AX/MaD/DM0UaQWY3+GPDZLiqjsX3aGUlttRaSnDfQzn92dm8qr6wOys4AcA7IUNl64HCD+rCwljJkiEvLQa8gY7iIxv5G79PIUJ91Vm/6+Tl9AoIXtA8821fX7EWowPg7fkRLsMEzCftkMLyl9nEGg9ECSPSKigr67LPP6I477gi8FhsbS+PGjaMPPvjA+B2oz//v//6PPv74Y2H5sm3bNlq+fDn96Ec/sh6nvLxc/JMoKnIXzGH4h5ykpMJlYm6nOg87R6r17eP7ifRoufHfsLuIXl+7h77cmR/i88ZgePXjTXuKqHNN3WI8GjARG4AX2eFnARlukdJIAlr4Z3sfqpdw+9e3B0vothdXBW08nrlquPM7IKagLg1HfagunovLK4V3oyu92pRKrJIzJoUTVKco4nrl058EXoMCTk8Z9UrBl8SGhI2wkOPimX3aUXxcjCBg9I2MHAdBkG/dfzikbXmpwnB/oLrCprGpK9Kb21yMjbFOoAONec+9xhGMP8BXO/NDCu7+8X9PoS++qVNWYQNq8kmXbfKMPu2EjZCf8wcBgUyWhLgYQT7jbwB2EM6iu4pnqRxXEYgz2QOo6wMQ6LZ+ckq3LKqqrvVtzYLUeFMhN6n8ff6jnTR9eDdxDPl7TispS5E4icyUeOETb+uvGI/mvbyG5k0eGFLELtKaEk2lH6t+ygiiurKVQJr5CSC4CgWqBLWpvbRLT6JPd+QHzQtoh1A+f5tfKkjBW87rK9q1ancgiuxdMJA27T0k5m2cH56Jnzlen3tclgToI0tX7w4i1lRSR22DUI57zd3qHFquZGbZzjWcdVDfDt5rB5fN2wzNKmNs3/b0oMGqQv597wW59PHXBz0zf/RMDs9C4MqYpD9PXC/maFixoR15BUyaM2x9OK/YnlGJ12tq69TegFetoMPlVWKtiGCXGuiVwX/5LBCMhXUJah0gi2FoTBalntWT+tb7AHXNTg37+upshJKD1k+wptH3puq40SopnhZMGUhzl6x1FsOFkGL5qt1BgV58BnOqCZiDrhvbi249v68o1o3rxNrik+0HhSDCZDeCjIhfnNuvQX1YJZFd2VXRmnO89jcgxP2Ia/Q+nZpYStsPFAf1R2ShNlS0BOB+mILimEOaex9nMBgtmERHxd7q6mrq0KFD0Ov4e8OGDcbvQIGO740ePVoUyKmqqqJrrrmG7rzzTutx4Jc+f/78qJ8/I3QRWkM1YrOtQt/cYAWCSuhYTCEt8N6pg+hHf/lIpK+ZfN4YDFc//v4fPqDvDewqAjDdGqgMtRX0W/TWlpAFs77w9EOQh1OkNFw0hlUMNsV3aAQ68MG2POdGFYUxI1EfqovnPQWldOeE/vTA8g0hnoV6qq8kztQUfmOKeXwsVVbX0Is/HSk2ctjEwdoCvwfI6/RS8cn35djWtXWKWNTrG8XAdcHXNyYmKIVdBVLY8ZnJj70n1F2qUtVESuhZPXgOUOY0dRK9uc3FLhVsY91zr3EE7diUoi36SAzR5MGdaMLv3guqSzK6Z1sqrawWqcuybUJp+Yt/fBmkqDcFEL0sOTDu3mVJnZfjo1cgSO0rIBlMRRFxLSi6W1gKX9p4umdKLt27fF1IcTh9bEhLjLcWPoRlBLxxoUiH1zwCani9WnpLhAkcBzY0Xv21b6cMMa7a0uz/dqU7SNkc+rHXfATVqUqK2MgcV6FAUT+jd1trAT4ElmQbQ19F5gWOKzOq0B/W7SqkG87uQ5eN6C6eO/z58XuwqpDtUrZnv0FwPSB84dATRBaF+j1pDaa2VVe2ppy/vbIX5BzqqkPg5VcfadFwl6WdCbaxFa/j3v/gTx+Enfnjd0wCbM8TY+Q/rzndeZzkxLhAcdTmmEFi68Ne60QE+/3UCkIbshVffu6jHTR38kDx/R15xSF1DfCs7p4yUFje4bcjJXv19ZO+rjMRy8Knf2J/kTlRVlFtLJ6JvjwkJ0vU5VEDvAiOIuNTbwv5JZX02FuhFjLzJg2kRf/Zajx3UddhSpx1ne1HdKPuz13ZVdGydnHtb2A1iT6pinz8PlO8v0dbM9syfORaISkhjg6WVNBzVw8PygTT9wwmUYz8/YZkBjMYjOMDx7ywaDh4++236f7776ff//73wkN9y5Yt9LOf/YzuuecemjNnjvE7ULrDd12NuHft2vUonnXLBSLL6iS/p7BcFDmS8OOPPnvxarFgwoYKix2ohJrbgpTR+HD1Y7Q/LNCw0cLiKRJiy0RYYjGmL34BLBDxWSyYVR9hPwS53yKlps2tawPdOjVRKG10ewe5cIxkQVjnKRi6gD/iVQjPxuA0VHgcq8SAes/8pkfiOm/51ypBZuAZYLOC1GAQHGu+LQwi3nTiTE/hV+/bweIKcd86ZR5Ji8d7D75aV3hQelWCFHcBC2y/tR9wT5D2C8yfMtCawt6jbZpIcYe/JtoWgokuUkJf/LsUm00FTXEudvmde93TxrjnXuNIQYm5TwJoK0gR92qbII+xgZSK+kd+cJJQAurjHwpv6Yo7feONwOVDFw4RakOh/kpJoKS4WHGe+E1YtfkJBKn2SuqG31Wf4B54pJ+Ffn0kzRvnJYP2AMYNXMfdS9bSG8oGHvcCCnR4rCNwpZIIUMu54CqECh93r/7qUrqH4+/clPuxlwoQxTPVTAkbmeMqFLh+V6GwPfh0x0EjQYR2W0O1dN3YnhQTGxOSUSXnjt+9uYkGdM4UzwTKWb3QtFxfPHzhEN9BcF1Nqc75mJ+hQDfVB7KROrAq211QSrf6JLdd44jLrx5rKPQVk5pcX/OEEziRAQ/5u6h94IJqFaVn/qhjdmZqPLVKSqBSBAaVdZE6JmHtAzVwTU2tmO/lc7HdI4wH8Kt2CQVQhFIGgZpLBomfPuy1TsT6CBZnCPrbari4gv8QE/zy+4NEIXUQ7abCwLjnaIPoU/Iey/Hh4YuGBKzxvAIY+vpJJ15NxLKwFntpjXjGaEP6M4VS/+JhOca5FWMJ3tfX8nMWh14j/obaXJ//VNEZ1qvzp+SKumPvGuaa7XnFlF5cYb0HapDIa86JlnWJaX8DnkAS6LqoDkGUuNgYzz1bZkrwuekZPrLI6/iBncR91dcK6ppc3zPowRW8j0wpjAMMBoPRJEn0tm3bUlxcHO3dG+xphb87duxo/A6Icli3XHXVVeLvQYMGUXFxMf34xz+mu+66S9jB6EhKShL/GNEHPAPVoqJ1xXmGiyro2Ojbot9iMUUxYrLFJvb28UcmUKTZgohnIp0RTj/GwruwrJIerCfTbaolGxFtIiy90vpBtlTX1AYW2n4Icq9iciYV2Dn92wsv4LsWB9sEyM07+h+yOHTFtlw4YjEYiVWMa1O85rtCumNCP7qhHIXR4sQmv6Kmhi5Y+H4IMeBX5SSfDVLR5XXqGwwslJfMGiWOgY0zlLkr1u8N2iiphIyXkhbPYf4FueLz8lhI53ZtoLGAd41tAN5f9U1BELmC5wCrB9t3bju/nyDRca5YxCMd2gV18e9SbDYVNLW52Mvv3OueNtY9d40j334drMjSAeLa1TZRpOvW8/sJlR+ANo55XE9hP+L1H0rqoh8O7ppFuwrLaNuB4jq7i8xkOpwUT7drCutnrxruOxCEMQvjH9Tzsi+66hPMfXmtUAx2yY6nL3YU0PMf7xT92pSyjmd6y/l96ZuDpUG+u+iTOgHqpTjG+sT0fEBqyLHPZC8Ciyq87pXp0hL6sVddin+v2yuekW51o5M5rkKBcyYNFFmMv/nhSSHEtwTazYIpuTTbQNYF7HtysgNBF5vPOo4NBXv/ThkR1RZR53womG3rChupU1VTQzsOloQUtVXnOkBf25gILdit4X6YMiEwHqLewooN+3ytefwGThAoWX7DmIAiH/ZmLiD4FnL/SyqEh7Qcs48E2NaFFGDFOAAi/P7lwf7eOuFtG2tBhqp7G/VZ4HVkr5ieQXPZt9j6cJu0RKsvOK4dWYgxPdqIsb9b61TqZGgHruA/Xi+rrAn0NVem123jg+1M/lvf/qY/caQGmiuAoa9fdeLVtb4X+4nSypDfxfzqWvfdPXmgU4iizwuodYDaDGhOg7pkUWpCnAj8ybo3gFj7exTd9gqkRaNGgl/o+xs8M0mgGzOG6vcxriCUPp9IIQ/W+4NPyKKz+7cXmWQg0PVxDc8Sgh9kl+wpLAvx3FeDK7ImQ/fWqc2mLzMYjGOHY7bzTkxMpFNOOYXefPNNmjp1qnitpqZG/D1r1izjd0pKSkKIchDxAOxdGEcXWGTIAkhXj+5BHTOTxaJz3pRcmr9krZuE3HKArjmzp5gIQZphgpWTGhf0YEQCWAG4/IpdacqHy0MXkV4LT2yq9c2T2m7FIr5+r+VXgW1S8CD9XycRACwoUeDIpBaVi3oswOHJHU5/kmQ2Ngy6r7K6EH50xeYQdYwLLpWT+mxcfocDO2eKsUVdKOsKW3lvUIhI9yeW76nPTW6kYQUDhRk2yOP6d6BaCvZsRXAQ14giq1BSunzTUWT5RyO6CdWUTPuuVHyXTd/Rx1aooiVMpBw2FngdtlhQbDKi63fuUsHi9XDvuSuTxPQenm9Nba1IS8YcifEmPdldVBPtwYscuOJwRVCgq6TySNDKa/xzbYSvPbMnfbYzuFYBztkFeQypDqvLwjjS/73WEN8V1ClC0Tf/8ZPT6f5lwYSa7O94pujjHVoli/sMsmjaSV2sQU4/imNdcZgUH+d5jxZOP1kQJS0dekE9CV0FqGckmIpS2wpclpRXCRtABBxdKKkILrCnAse/cnQPQSx7FQKVRJMrCK7D1K+9VPo6qYP7hev82wfbjVYv8H2HZQSK3prWNqiFIudYFDGEp78rm8Xk+S/nH5Dw63cXicCbXujUFThBsApBJElYY1yzkbV4ff+hOls2FdjiqWO2KcAmA3zwUMZeBPcOQQG5fnEFHVAUVl4PgoNqcVe1UDtehyK/sdS8xxKYaxZcMJDmClFG8Nrn8tEn0qxnvxA1rRCggD1S8b5DovZAyLrXAdmPYCnmtZ7Xoc8nrgCG3s8QZMV6FueNcQbtF4IJ3epDP08VyGZwreEQYArXlxzt/boze9IVT38alGEpg4souo1+BRW+XoTUdQ8w9oiA2aQBIeelAyKYaEOOfQhI4b6Do3nSlDHkIwilz8m4T8L67Iph9MDy9WIvYvK8DxxjywG6tbY2pM7BmPos0BeuOV08n7TEeJEN19z7MYPBODo4pvI1pJPNmDGDTj31VFEo9NFHHxXK8ssvv1y8f9lll1GXLl2EfxswefJkeuSRR+jkk08O2LlAnY7XJZnOOHrAIgWTmfA3n55F9y1bJyaxwIJbU5PowELmmY92iOg9Pg+yCYtUbHAZjHAhCSaTX7Gr6BUWY7AG0OHaUMv39c2THz9Rv2p42Y/OG9jRSiTZ1KIAFqvoWya1kA1e/sUub0WozEDaY9Efjoej/mxs9z0chS1QDPLEUdxOfW74Lxb7GH9A3IFkhTK8oqqG9h8up8S4WEGcl1RW0cynPqHnrh7hmaWjq+CwyHdB3cjh2UtS4lOr528b8ZsnZKU0eT/05uh33q9ThlUFi9fDueeucUG0XWMths0hwaL7pg6is/q1C/ICV9/3E/yThKEcXwCTp7+pH9r6YF3RuToVvNpGvcZQWKOgDavqMJD6En7rEwgP2ZfXCq/aFYZ7I/u73+LKfrOK1GcLsg7PAMpm2z0Cs/fL/xnkVGm3FOAeYj745mCJyBjCmKirAPWMBFdRar2/Sd9vrzZWWq98tQGq6KTaWEFmmQpWS4RriWbr87AXsj1/jOmYZ9AfVdIWbVHP3JD999wBHYRlhM1jXxLG8lwuGZbjPG8/3tGmdU24waf74JOsZdfh+meN7SXagSqsAXRVuB5g82ux5hV0kEVk9eKu+rpLt8+D/31zB3zo/981Z9KEQZ2E4l4GD7AegpoXwN8gsxe9vUWMdci4U9uBnwK84nNKkVcTTAFjU1/X13JyfV2tBGrQNnCOejFbW20O9Tz1gJwL+m/48SU3zZ16cBHXiDWJaT0rA0e7lcwwFP+et2RtwIMc2ZuuYtworhxNmMY+ZKnb1lx+glD6nIx7O3fJmsDazGutUKxZSMk6CQjSnmiuCctgMBhNl0T/4Q9/SPv376e5c+fSnj176KSTTqLXXnstUGx0586dQcrz2bNnU0xMjPjvd999R+3atRME+n333XcMr+L4hSR5MIFj4y0nM7n4lCmyNmBBhEm1srpWFA07qWuWWMxAIcZghAMsiPYVlVv9il0ppljAwTtX39jq6Z8qZGEaveiXi6j3shdR1fDqhhDKHxu8F47+fZv9FLL08lZE2qnJL9hVOFV/Nrb7Hq7CVvVVNUFXGiF4hw2hWmRK9VdG0WQQLmf3a+epCAb5Hk6RNQBpvQCuPS0xPkBKvLNpv8XzN4+QBwz/dEZ48Ot3blPBhkOge40L4wd18lWLAX/PWbyG7pzQT/R7nQyYNbY3/WfjPsrtnBkVT39TP3T1QZOfs2sMBcHx1oZ9QRktAAgp+R0/gUwJBBNRPyFaKet+FMfqs5UFLqE0d6nnMUa5VNotCcjqgfoPpPC1z3xu/RzaMwqBhlOUWh0fXfM0LBBcaJOaSKu+KxSk7vxX1lrXF/CBjkafh9+zDM7pxUZnjDpRBIJNRfDkfcK6++ELB1OnzBSRiYE90bse5BTgFaSW0K8znKKE4QSfcJwJuZ2E8l1Vel/+1Cd0ck5WEKmIe6OvZfS1jx+LNfwe/vv/2fsOMKuq6/s9vcEwzDDAgAxVYJihiAooYItR6WAXjb2i6M9Eo0gTwZ4YE0vsUfMPicYoIiD2GFEEO20AAel9mML0+v/WeXMe5513yr1v3gAz3PV9fDqv3HfLOfvss/bea0+3BB1MWfUYp+v3HAyQEMIzQgPZpo7fDOlCf/4keO3h1zhtVJY/0YDbe9xTcRw4bcCL52+q9BL9ef77uiAXt+0iecvXOGRAD9AENnW9OXTzXdbmDn4/JiRdctXa6aTvjalnCIIgkIWBLQHBztcWVV8IJJCEi0hmtu8tyLoFPn+dVJab9Vlck9fuKgoYOza7huqJxXcMD9mP8+DBgwcZR1xIFdItOvkWNBIVER0dTTNnzmT/PBx5YDEDOYaO7XAQ0KhLzGZjzYR6tFFmyooOEcr6kDXQEP1mD8cuQGqiZBEyGzyjMl0aQ7YSU2zQZGIDYxjZRmiGZCpJ5xkrNqIeZecPLFjjKBte3BCqGo05dRzdZM/ZGllOHZllJaahU+5WM1Z+NlzvkP+uU/AMWwAbFzjNbu6NmEmny/7G5mTO+L6092C5dgOoIoOcEIpLNuxn3731rB6spJSTErCJqux+4ItmUkZ+OIFNXsv4aGX2tUrvHButhmy2bHYBzXhF2CRMQJqN7psRIDOwt6icMlrF00/bClhQ2hb8c0I44Z4gIx4WhhNOTjPD5bmssqG3ntGDyhQZp/gOZE/wHaeBTN3viwilubKbZ4trwJrw6jWDjN8BmXB8u5b+LG1ZKmLNA+dRcwEnkWzrFJo5IwC7ePXuoPFgylKEfRyZ057p6MuZxXydrqqpNY4hBEaHdktjAbMZY7Kpojq48gQZi24aR5rmPBrcThmZFbROouk0skdlAj3A14iNpn9cP4TmCNq/JvkzAMcXxRxscwq2UfTb3TYldCp3g+9BnkUF0e/hlT9ihQogjymnJKWT60HFCvY2kMtD1jnPON9TWEbd0lswol8+PirxmpIuugr9jmtFLy1bp3wP13jviN4BPWi4vRXHgakiAc8RhC3PmH4YjWzfW02fCNVDeN73j82hS19YGtS0HseEBIsoa4f1G8eSA1fcHmMtG2Go5pR9bNN8dxogCEWXXPW+re+NqWdInRAcQILGZIM80du3nErhwu6icuWeP5x7FVVVgMmucfk9jzT34MFDsyLRPTRtYKGGJplKoxjaxS9fdTLNhsyLgYRMio+ivUXVyiZfHjyY8O+bB1PrVq1ZY80A/WqpWY1NWggOnFh+zp3M5ZsP0HXDutLvft2Lyuu1+1HW+um6PUGOs46o5xnNyHZHKTXGvkzcydnw4kbP5ByizFanLWqSUFHBFmhAdnWqZW7iPrrRjFWV/4qbH+jVYvOA3451mJXKM99x391seMRMOgQGkfWr2pzg9eljshiZPm1eMOFy/9hsGvP0kqBj+wlFQuZgYAYiAih7ispoSLe0gKZG2BjadKXD2RSqOYKXd6PSA5lk0w1NeDH2QtE7b8i8kjfPts325rxSNk7Kq2v9BFzv9i3pjx+uoz4dWtFJma1pTL8MmrMA67IglcD6FmRTXnElk9fAeFQREngdG22sx51SEmjsgI7+0n6QnTZ5FrmPArRobz2ze1DG6bWvfcP0/FU6zy1ioxg5imxb1bXIPgSHLlvYrS0M9dniekGGmgC7JGZpN2eI2eKmhIoPVgc3GhXJZJON4+vN0wIpjbG8YOUudpxnJw40ZmEi4xXEcSYlUee0JHrswv4s0MHnFsaUGwLdyZxH4gjIWHmdBHl37dBiZvNR0YDkEgTNoMENTXGQQFw2MVRyShekxhyZdGYPuvbVb9j6iZ5FuA9JFr3kUNcf2z1qlRBNn/3udBYUBPEKm/XwhByavTCXjQ3ZLwqFpDRdD/Y2cr8Z2NBrpGoXsWJt/d5iSkU/C6HfRVMC/CwT9h2sYMlS3O6KY08cB6qKBB4k4hIjfMzNHp9Dd59Xw+ZEi7gYlqDw4ZpdbAwCbZPjaP/BCnrz223KxtFYry89qRMbI7IfzKuieTWnqrcM1iokXLx50xDrfHcqWSTC33OnMFjnX4RqHos+LXwS2Z91Gjhi1QOZ6s/a/B1TLxfVfmR7vrr5uWkfE8r6LFcF6OwaJKJgV3UEupvr8+DBgwcRHonuIQxlW8HZbFj8n5o4kB5ZnEt3n9uLbj7d55CL0W9OWECrrGfbFk0+i8PD4ceqHUX06Rc7jc1qkD2NzGKbA4fxjMZBonMNAqjvha3ojx+uDQoUgSwSCU+VFqRTnU4xG17OWtE5hzgGSCYQsMiCciOhooITLUtbJg4yXngjTafOqOqYfPOD17mmKxqFmpqRZaYm0ie/PT0g81214cFnZ47NZpsuQCUTgA2P2N9B3nTtzC+nu976iZ6eOJCmjurDmlXxElE8R1WjKh4c+NeNQ+jqg4GE4pwFa2jGmD5sA8fPZ1dBGf133T7KOS7Z+lw8qCGWd4Mwxtg0ZV//uDXftd65DW4aCar+lgH9UvQJy5Jknu46tzcb65g3fNzeckZ3iouJpJQEX5k9UFtLLEhksku8CSDG4tDICP8cwj00ZbF+uCaQDP3nsi0sw/ii55bSpYMy/fNoYGZromE+2zbpDF9zNz7PMMdq6oh2FJYzwgzAe5BqSahvyolKD5lo5Vm08vmFYgsb+myN8iL1pKTJljYngEQ6/fg2NKRrKssWF4OOtkajbmycGLwFmYOqDKaBvTWf1uwsZPrNchYmmlEj8CRKCOJ83ZLmMpzqQsuA3UETwJnvrqJLBmUGZZli7UKgHxKKz3++SUkm68gpPtbEIDUn2bB2IuMa74FwRNYq5i96Fpkq4UzX0pB75OsJEh9UXYDrR3Uggk/cL4II2hKH0k+4Bwj0mYBg/Za8Epr2TmCwVaVfjXsrNqvEfxEwWreriF686mRqarAlKuCZ3fz/vmPXj+oPjFUeNJU1zvl8ZIkApVVsDVFJ6EDWCHOT+3to3p6aGENJcTGske00NJPdmMf8JlnTXGwGjmrUUCXMIMXTpU2So3vkRrJIvBeAqReGXFXFX+PrF2yD7M86DRzp9hC2/i5Oejxx4DkfQLArNjookG5KIsGcnjOhr+v1WV4/RbsGnwJ2IbVFLLVOjA3L9Xnw4MGDDI9E9xAyIE+ha2qIjcnTn6xn/80vqaKOrRPouf9uDMrARNnezvwyJnMxa1wOtUo8jBfgocnjhE6tafaHW6wSKlyvFlARLHDAxOZ+IlGuctzxNzIJOcGrI0Wc6nSK2fBy1oq86eUZocjeAwmALDW3Tr0KTkpVdZk4w+uz2Eb85Qu/0+zEGYXjDTIbpDa0Yr+wNCR71JAFpGqgKm54CsoqqaKqlhFwY55aws5Td47QTTRtusb2z6ArhnRmhDn+cRKCbxp19xHZQJxolHHfqCz23417i6mwrJLiYqKojuqYbnQ4M3iOFcjl3SBuTVlb00b1od8M6Rz2kl/bvIKNIhdyC/g8ssTdbu7FDSMajZns0kPjD21qxeOieR4IBzloJ5OhP2wtoNH9KlizX2QvQuJkxfYCRs5x+4DM5Lk3DKFIqqV3bx1KD7y3WhtoFPsULLp9OOtdIBLonHwpLq9k546qHsxLt7bQbVaa6tlClx7NEcX7ya9n8lnH+6WadLa0Wc7Dt1dS7q4itp7eUl5NUZERjhqNAr/OasvINNhFJ88F4xzjE/IPIDw5eaOy4xizCJTX9O9AG/cVhy0LURwXciAWASpcjw6YbyCV7nrzR2VyAHTbR/XN8M8NU2a5uH6KY00MUotrJ/xvca5jLmENCle1m+4eyUCgQKVb7mvOW8cIVWS8RkdEsGd465k9KC0pzhhk75qWxLKeEaQzkZmLVu1mz8rUsB3jE8/1pauC/cOm3NtgxfZC49rz5cb9xmxw0X4iIQAN2SHZgyoknW6/ON95g3oxoQr7QoxbHNfUmBIJMDrAzmBM6dY8t1I8bqst+XeUvnMPn+983WvfBLx2/7hsRgTfMKyrtucAxrIJPLDE9xBsXo3uQ0Vldl1w7j9h7yRXrCFQhEoxlW+hSxTCv/98t40li8CHEZPqZs1fRTPHZDNJLadrsep+4jcQPIWPAjtrekZOelh5SX0ePHgwwSPRPYQMU6MQlJSjUSh3tsTMuJjoSCavgUZ9KNt7+tONbPGrqPYWLg/uUCLp4qnGKHeSZCIazuDx6UlUVV1LUxUbNjjXyCxy2lFe5dQ5LbcMaLiUGEvFFdV+zW15Ew4SBiXoyHYCcST+fkPgtFSVO/LcEfZJ3BB9KGhlOnFG5SZQzD6cHpg5K3+vIVlA0N506jBjg6ELgIAgPFBcRd9uPhDQFFEk5PFcMKYCy0rb0FVDuwRJUAC4fmwBb/vnD0EbEcgJ9evoa24qZyWaMuqPBZg2WrIuMW/catLYlLO7wwHbvEIJvUhcmHoxoHloSmI07TlY7teVFa9Zt7mXN4z4TZ1dw+sgoeVrEI/7+EX9WaAPx8E8FMlQMfgkavnLm2qQVCDokAkHAl1lfwEeqOQ2u7q21mADnGUThisrTfVskSGMLM3xAzrSnWf3pOraOnZPYiIjAipNdPasuUGch2iaedPp3eicrPaMREfWM6p55KxFnkEJAh2kz13//ikoIxl6yselJmrHOZrq8fUezwA9PerqiLbmlzJyD2MWlRKXDe5M45/50hhUdQs+LsSMctEPsP1OcXm1lXR85Utf9QaOy30bVEWhgkkM6oa6dqIapLqujtkXU/A61HXHFJDv17GVvg/Ihjy6+mBFUKPaT393uvI8WcPWU7vQ6Kd9gXOMqTnjc5gEoExmThudRbsLK9Cv2wiMT9zvP36gTrAAzs5qR00Nf/96M7120xlBaw8kMaaPyWZENeSEVNngIMtH9s3wPzex8gsyhiaIGdU8+UVc17HebD1QajwGn7+q4Ah8ZciC6cYU/03dWA6X5Ic8BxNio1jgYvnmPPY68+8TYqhzWiJ1bJ1oPQ/sozGe0WdBxjApux2B9zN6piuTTVTA7/DkI1UAEmscTxpRkdFyohC+c8sZPZgfrvI90IsCTdxB6jtdi0PZDzjtVeP1GvLgwYMNHonuIWRAo1CHVokx9IcP1/kXS575gn9wVu8bmcUaAVZWH8oe8BYuD25hIx24/qw4BvnrcA5RBgq9X92G1W1HedmpqzJkxwBwmuXNKJzShxblMnmG+Oif6dLBwZtwTiI4dYidbgKcOqWQyJGbpKokanRzWnS8xSABtGBbR/gy9XR2IJQsILcOMzJ0sElQBUBwri98sZEGZLZmGWeizAtIE1QGIJNclg9o2zKeLnlhqVLqBce8H6Xrmg35yV1SA46H0uNFK3dZM+qbM2wbLVlzt3WSzVY0njukCjxh/cR/oQErjxX0YhjSLZXu+NXxTLoFerLoxRARUUePf7COPhUasTl59vL431ccmP0uAwSnClyjHw1B84orGFH3v58LAghQN9U3IF+QUdq7Qyv6WLgm8Tsozb78pWVB/S7Q/C9caEhWms5mdmiVQFPeDpQwUD2rUOxZU4I8D7M7tKKHFgXqestrR5c0nzQX1gGZQPfLtb29go0DkWySG73K9vujO0+jnm1bsjl4arc09pq8XoUrC9GUUW77HSd9FMQgPJN12ZpP5/RpxwITol8QtPa3iNXOHZ1NxX0OR7WbfD6t6glSBA1wXNhESO8h0GG7fhk4Js6JHw/PuKLalwGLqkGsy3ydfmzxWv/nIG2F4y3dlEcTnv2Kff4f1w82/j6ITltlU1PEGzeeQh3aJNHY/h1Y9jjWRASXQcYi0ISAl85XxpjBdzjEBBInUjsiQJiL/SIwBiELZgLG0sPn96UteaVsjeLPmieboOGlCfhNjD95HQ235Ids79snxzuaV+w8mHxq4HkgIASIRPpZvdNpyogsNq6HdW9DKUkxRlkTFTA/TWs5pJZ4Hwqdb43P3XNebzYWMIZM1QTwBTAX46MjXa3F4v8zu1kfALPZJpuN9XoNefDgwQaPRPcQMpCtoSv9Q6aPbrGEE7CzsIw5ScOlzZONtPTgQUSaotkOB15P0hBj3DlEVvENp+kd/FA6yotOMkrQTeiWnhTkFCKzeMLA4+gvn6ynywd3plcVTiwcTGT+ILsOTmM4df9spI7TzBOTM8odb51kitwYtqFw6zDjXqLBrJMqG7mMG88PDbLkDTYric1MYWNO1llHMzJbxYK4qUQ5u/h5vsF4/Trz5r+5wAnpKWvuVtfUGUvVLcmHDQYLPL0H8nB/EDmge/YAstIvfv5braa7E+JPHv9Yn00AmbBpXzHL4IUkRmm9NEpVTS0L8Mm61uIa7rT6hgOEB76jg+wTiP0uxMBjQzIFG5qVJttMnA/ss0oD+FgrFRfnoZMAC6R6OqYksPuD9VP3XDAGQZghG5PfS5udR3AIwU8c94qXl7Hf4xmgYmPdcCVzmDLKVRm3fNzaNNV5A19IFmANxbqCtQf/LxLobtZ+6Mhv3l8S1Pwc54lj4D41NHBlOh8cG88F2cKweSao/DKs4Rc/v9R/PBQebdxfGTTe+DqNsQDC8v75wcFrEOq8ElAGfJMOKT7is7kBzW73lVfT3W+tYH9z/XkOJD45DW6I/2+TKJP1wGVgDI7YWmD09RFovvftlUEVK2gqiTmhSl6QoVpXGlvyw0kQ9VD/seDzmDpvFT00PofuOLsnu8bkhGi2viOhwxbAVf0Ot0fIkjet5bgn/LMm7Cgoo1v+n69q5NnLBxo/i8rfmEh3a7HNxul8g1D7Vnjw4MEDh3kn5cGDASiPhzMKJ0gE/gZhYAJ3sLDIw8nFZkbOHPbgwWlJMJxleQxCZxBN+OBQyWCZEVsLGPkDfVYd4NyjckIFJ3qgXPdTBbZ52FoQNFdAXGFO8GxTU+YPHNTznvyCfvfmj7Q1ryToM7ZNAN53Cx3h5NvMt6Zzs9sxZxmbfBB/yBDC72CDDBIQ2rM1dT6JAx2p8kUDzk+FUBxmBCZ0VTY6Igivo9mW6rmDkLh+WDe2McV9wOYUJenXvvoNy+p1k3mnkiZpzrrKoZCe8jMoLK3Srld43VbC3xCYNsHf15MDKogEA2yWTVrK6fjnpIYKsKU/bitgcjHQX4Z9Of+vS+ndn3bSgxKBLo57voY7bXYmEmKm76gIM/F6sYmGDNKvnvicZZL+6o+fM+11EII/bfPZG5sdCXdWmpPxeaxAnIemMYzXkR0uVmXZngsCMOK9dGrniyuq2Nov22H8jdehBx4O2M4f2a/yuMV4tvkN6KuB833io/U0b9JQGtQ1ld5YvpXSW8Q5WvvxOppn8nmB30TG/MSXlgXdC6zT+I4tk9cGJ74Iv18m+2RqwiheH2Bbp9k8VYxHrNWoUJR9v6H10jAj/7KESVk1R4hjVn4ObjLKxf/H/TStvXjfRqrPXrCGZZTL8wJ/QxJsptRTB8Df9729gnbkl9p98W0FQbb5aLHjpv5jOL9t+WU0+qklLIi0YMUuX0NeTQBXtxbK6yiOYwPWRScBP76vt40fBERtNhNBdb6X+HnPQabPDtkZ+VoRRNiyv4Rum/u9axvr9Rry4MGDE3gkuoeQAYcdTZlAnIEYAnGG/+JvN84WnFpsrrB5NxGaHjyokBQbxbQY5TGIjSAcazjYKmeJE7jIOtJt2NbsLKTfndsr6H2neqCc5Jd/n28esDGQHVvoTvKNn1NCCsQWpGngHIpkNXO+w7wJUDm5PKMcvzvmqS/9G/Eft+ZTZGQE/e7fPwU4srhufB4l0aESg24QisOs+050VISRCMLmXPXckSW0v7iCnv1so+tyb9FeYmO/RLOhOlbghPSUn8G3W/NZI17VegVt5JRGzAw2bYIxF2aNyw4aa1gPRYLBZgtMRK88lnWkBj6DJn2oFJMJKBsByrPJ3az9nLxAoE0FU5YirtdEzKEnAUrcxY1zOIJsckBQRUp4peKHIM5D2xhGNriYSW17LhhL4r002XnMJwRv8cww3kwEa6uE8NgC2/nL4EQXYPIbuE1gjUYXrGZSYWJ/FBsBiNc37C1m82L7gVLWWPELS3AMsksNCWo7IST5/dLZJzxDNOeVSVeZiMXvlFv6PmAs6OYpb8R493m96L3JQ9k6wdcKXnHzVX22ugq615sCxDErPwc3wQ3xs/x+8rX3latPog/+bziN7tchQE5JXvNE4DNFZZUs+xtST/Mmncr+i7/Rw+NjhS64WLEC6BJuxN8U7cnRYscRLHT6fijBdtU6ivvRNvlQUE4FLj9jCk6s2l7otyEYE7q5gc9CdslmM1ENwfcSv/7T/2jBip3+YJ+IXhnJNE3R68pmYxva68GDBw/HDjw5Fw8hA4sMHHcsSGLzUGgJo+x77g2DWXMnrpcqvg+iCZmqvGQUQAOpOEuZuQcPMgpKq5g2r1ySjTEHEmXKyKwgPU9IFAAYtzwjHZDLficO7kzXv/YNXToo069Z3K1NEmW0infsZKGkcPa4HNqwr9iveSw24pNLFKFByeGGkGKagiWVNOqpJf7XVGXRogY5a0q5r9iV/IHKydVllOOcpr6zkpXQi5scOOt1dXV042ndD8smxWnTVL6hAOmJjcm9I3rTlBG+pqloGOjbyJmb2fINoUorGeOOl0qLcFru7NtkdqHb5gY3Jz2W4JT0FJ8BsksvGNiRZsxbFVCijE0dAm2Q8AlXAzE3m2CMF8xbeaxAD3raOyv94ykUaSnd+OekBtbcGaP7UFllDfs+KhxG/OULdi5/+uhQ01zARoBCAgaBifSWcUym7QvLWObkxTvfb6dLTjyO5l4/mN2nhJgoNk8QHIVWFfTXUdEi6q7z67XpsXLpGFv5PScCdFIBPMjmVB7DKxUPBJ+HaEZrghxMwX2HzVM9Yz6WJgzoaLXzvLkkbyA679ahrhrrhgqcP3SaVf4Jk/ZSBIi4PwB5E9wzZIDDx0GzcdFvEM931thstq4juMNtF6/20slY4HzwW5Ad6t8pRUlCyvJLDZG5sUvtVFG7Vgl+OwBCDb99w7BuVFpVw3TIcU+gmfzebcOY7yI3NZalIcy/V80amOuA46E6ad/BygBJEw48Q/iN6FUhBkgR5L7r3F7UVCHbwlU7ClmD5Mln1bGG6xcO7EhzFqwJ6GExvD74isQJ8f48M3Egje6bQW2T4/3jH7JBZ/ZMp/YpCUwPfFCXVP+ax9cf3ZhNivM1ZpbHIKqmnFSsYPzMMfjism0+Wuy4by3UQ/QNQgm2q9ZR3I9Pcvdq13K+LnIeAEFrlWwS7u0bNw1hvRo6pyWwhrt1tFb5WSSocIlO9EaQZQ/3FJbRN1sOOJKRNEnRyDY2HL0ePHjwcOzBI9E9hGVzBIcWDdBmzQ8mKOBoYlODzY1KRxjvt28VRzvzy46pxngeGo5dBWU058NfjE3KisqqmNajTJSilBrghBKcMGzaYqIj2QYOGer8GHzMYrOAZjpunawDpeqNmMqxFbPg3GpJFlk2jjoNcjeNkkDuycSGyWEFkQ4HWfU6mh8drk2Kk6apquZNuM/IfhvTrwP7GwFAp0SQvOFD9qocyMAGISk2mm0uImld0IYcWcr7DlbQqL4Z7NgoU1VtMnXZQM0RTklP1TP4w8UDGGmNuQJSAE1kQaCrCNJfZ7WlGWOyGYEFO4L7D4LK7Tpl2wRjg6giB2aNy6GKah8haLIFTsqPnYx/jE+MLdVG3Ebig5RCBQq3MTiCeK6wGTPH9KGN+0p8kkbbCmje99tZ47H75q0KuO/wGyCnwO2vbNP59drIE/E6TNrmToJsPFsPpeOsv4GwuUdJ+cic9v5juxmfxwr4vXFzX/AdNNBGE1FZhx9rCiRM2tRnOarGOUr/kbmIrGGRKNtVqK9KUDXWDTW4Bqm2RSt2Ba0nSCBB4OrWuT6tYJ0/wG3C91sOaP0HzLeIiAgmxSDrQcuNvlXzWW4IKQNjnPsaILhChYmQxDUkJ8QGNZEVA20g6njfF3bv9xYz+QqTn2ICmmYi0KAL0oA8BInYs11L5fe53/jPGwazjHX2WkUN8x/X7znIAhNNEdwWws+4ZJCvqf2TH/8cME+RFPK7c6uppKKGrYkIEuF+nNS5dcDcxnNdtHJ3UB+Q03um+39L9svlYzixm24qVlISY+i1rzY7+o2jxY4nxUY73geEEmzXBbhe+N8mX4JRRISy2bBfO76sMqg5uhic2HagjM1t2GVord90Wnfm+yPZDjJ7qBJEVfsfL+rvt/loLvz0ZxsCeyX1aEPXDOsSFBzEfUGgRwy0Ow0mNPfG3h48eGg8eCS6hwaDL0DQHpMj1tj4wMF/88ZTaOb8VcryWQi43P6r49lCOpDqmPPrkekenGDG/NW0bHuZMTNB1/wTWn0cIlHOSaCfthYEOGogdh4cH1gy7RRuMlpEx51nO4nXJWd5iGgRH0jWrdpZSA9N8G0+4VTiv+t2F7Hs+1AaJYFoROk3svqQLepWdkZGTFSkdhPbGJsU1aaNZ++huee0d1DWrm6YitJjEGX83ELZWGEc6AIZZ/VOpwcn5NAveSVsc8o3ItC6xMaSPxuRWJU3NccK3FQWyMAckJvwqsqZ8ZxAIoDAE+ceswMT+lLntCTH5wutT12jOszlJE0DZDmT/sKBx7H55/aaOWwbRm6nVBtxE4mPzS3fyMtBScz9TqkJ7NjIJkXmJjawyCDGWi8TZwDuU51gw+XGkyDUNueVsA25CfJ1mCpbbEEGvA4CXTV3cV+g541kAhC3IJZQ3QCJrVCfVXNEKPP2uNRE9h4kGZBRyu0iCHRZwkT8HQAkDTK5IRtGw3zZsRiftsa64nocauM6v01RrCeREREseITxLFdYyL/PrseQMY1j3K+QY+HVXnKGpop4M63fGMvc1xCz/t3CREiiImY6Ammae/WHi/oH2WzT8XB9dbXmRtIIrlz+0jI2n3GfRNuM406qz6yGTTAhKTaaZr63OjBg2KMNXXRSJ2qqwLieM6Ev08lXNbKe9u4qmjM+hzq08jUABlolUoD9RE+ZaYpnavI1bfYBEKst+FxzU7HixgY1xM8IJ0D8I5EDkMfZ9DF96P1Vu/zEcijBdt3+hK/l798+nPVq0gXfW8TFGJujJ8b4fN5XNE1+c3cW0qyxh2x5dV0dPfPZoXWfA2OpltQ2DeuuGDTUScQdq9VgHjx4CD88Et1DWIDNY//M1ix7TC5b9ekT1mgbJMJ5vXdElq/EtT5rPRxdzz00fyzdmEeRcYnaMmQTqYlSUtUmDA4YNJKvHtqF/RMzK6BfjA2d27HpNnMWjjvfuHNCatIZPSg2OpI1tBKz5DlA0u0tOtSgEk51346t6G9LzJn6TjI1ZaIRMk03nd6NEQFAeVVtgDyTTArosmNQvvmoYpOCDREIksaETI4gO1anW83Hk78keHwOI8iWSBsavI7xsnZXkS/TOSGabSY5AYDnDMJAJX2DRrJV1avo/rHZtG7PQRZ8BM7qlc4kifDbyLzF5vHxi/qzbElkRx+rJahOMqudQlXObJMoeuzC/o6CvZg3D7y3hq2NIIZlQv6+kVlsk6z7rkjQtU6MabTyY/wWyukx91QbcczrpyeewBrpiPYEn4ecxEML1/hfC6je6dGGRvbL8Gdqi+cKQsSJHAv/e9qoPtQxJYFG1pf8IyPcFJyQK3VsG2dTkAHPQDcm8DfK2SFbxa8bVQyQ8oBt9ErFick4oAIEVR0YL1U1dUy6zMl96dg6kQWi+LgHIYYMdNV3MI7zS6touqCHi7Vw2qgsJisAbW9oiNtkCpw0w8TzvfftlUqCHZnmJk3yq08t9zfvFNdilc9i8h8QvDFVgd12Zg/2/7xyArYG91KU3kBwSwXMXZDNOD8EcnEeoWblmwjJgZkpNOXtldp7VVxeTe2S1ceTnw8n5nCOvAJORdwhA1YM+MG/YhVBuKYWsf7Mam4LkXggy0tgXD3yfq6S7GvqgG9hamoPTX1kdIsVjKL9RFNH+M+XDc4MklmUfc29ReXMn4FsD96HnYfPiAxnSLjw5yFXW4jBLKcVKxi/GNPTRvdhiSCoHuDPXDWOw+lnmGCaV/hv59REGj+gI5MY5H4+xiYkqiANxe3IIZkh3/x3Qvyb7AvmAGyG6XptAS1UfOjWzUiKoIcv6EvHtT60j8NYUK3pKr9ABO/hALvaMl6fvX+sVoN58OAhvPBIdA9hAcgBLFwqqRYs7DZ9wm35pX6NSBuZ58GDU+icRu6wogLiljO605eCdj9IocsGd2ZNt1Rl0KGMTbcZLXDcQdaDZOLZdyDO3/1hB7101cmsYadMoEN2YuKLX/tfgzP58hK148rfxzWLG8PK6hp2b1TXJxON2R1a0aOLg7UNZVIA56bSfsW1ozwcv8W1X0FwAPg8iDI48DaZGU7OqEhrHWRyBJthZMWbgPvDmxniun9/Xm+6pbyaZcDg+azdXURVtbU05c1AbUiuuZ2ZlsSu9QQTYbBhP8uwRXYunsuw7mmMMMK4ETe0fPMImaJjGU5KcZ2QPqpyZptEEZ67ExIdvw05iZzjWvm0Zc+so6S4KLZmfrZuLwskqa7BlAGLQE44wX+LZ1qjAauKgOJNnHmwHOMe/QOwSb5nRBZ77Qtp7E8Z2ZvpnPtLv4Xngew2E+QMWcxzBDK5bRErdZZYKnVwLrFRoTcuR7aePCZkWabM1ET/eaEfB16DbQv382pq2JpXwrS3dXbRBtnGo4JBN2cgrYNmc/y3xMqf+95Z5X+N9QuxyBTYmmEiO15HsP/f2b7MUVMPgcsHd2bngjECfwPrncofMPkPJvkGHDu9ZTz9pPDNcTxOjndOSwwiwfCZq4Z28Z/XYxf0Y/I0TnoC6KAjJG2yTJDDK9xywJd1LNhvlZ/EZSQwL9fuLFLKTMC+9enQKiDgh39oVMnnKs+sRoLQ+Sd0ZHbuqU9/DpSXOL4Nq8r7atMBrY53UwTmEZc71IFr6quSnvB9uamj7BvyqqBteSW0vaCMSXfI8l+PCtUevzcEs/D7TipWTGuqKXmkMfqkiHBS7YJ71i09iQWUcF1isopcfYvxDf/02uJKRian1mfr6867oRn3pu+jogPnqetBAZ9X5gdgZ9z4BQiIohcL7Cl6Vg3r0YZu/cf3NHNsdsD90V1TQBAHQZXEGGrXMq5JchBbt26l/fsbFsTLzc0N2/l48NCc4ZHoHhoMLPAoJzWRdch8MUEsGT2cXc89NF+A0MhQbOxUDisc9vcmD2PZGyB2eAMyFUIdm24zWkAEQ39bdkyf+mQ9c1jhTHNdZzj3yATFsZ2QgJibaNg14LKUIGkC3AtkQ+NecJJbJhpNGZn8fRwTDiuys0F8iYQTADmd8upa8m1lieYszDVuklT3KVRyRiRHOMkSFWkm2LAp480Mu6a3CAoggJSZ8W5gWTcn95C1/seLB7BnigwvE9DUjpM+VB+cVJVUexU7djSkEWQoDbpUKK7wlRnL2rKc6C1X2BlbBmw4n7v8W5yAio6IoKkjswg9mPNKK6l1Qiw9ujhXmSEGmzGmX0ZANRqyWzNS4lmp+XnZGdrqDxNkghCUu0jEiJmkyF5EhiEkXr7fkh8QyMO9xnnd/95qeuj8ftYgmwqw1QhwcehkmUSyCM8LzTTxvZTEWFZFhEzsxiJjjkaAAJdttMouqsYlCEyMv/vnB8qVcBsPv5ETXFyOC9mv4m+p1iqMC2iM88a6IFBU67GtGaauYTCeOypMnPQQ4PNn0e3DWaWJbkyo/AcEE/JLD635SqkX6d4B/F7g+s/omc78JPHYIPgheYNMYDTx5FmbciZwKDZJFfhMjtdfA4A1k2vCy/Zb5yet21VEU0dnMUkReX6qpPBUNp2fK8biTMXajnuBbGaVvERTBV8PTDr5om2Wk54OyRiZfUOMX9gGkKgLV+5S3lscBz2IbMEs/vumipVQ1lTdXgFZ7yDtwwHTeUGXfuaYbGY/5WoLOVkF9w+VofCvQbJf+sLXvibKk05VBnFVwYGGZNzr9jc4hzW7iozfxV5GTN7RVcao/AJUy4Co59fLXju+DavWhMTspYMy/Znr2HOgAlm8JlMQ5+/XDaamht69s6iszBwAc4qqCrNd9nBkgx1t2rShzMzMsJ2TB/fwSHQPDQZzcAylV5PP7MEy1f5x/WCWvSeX9mGxguNz/WvfKjuke/Cgw6nd0+hrSROdb7TQ7Mipw4q/Z81f7XcCTVlFDRmbbpvYuCHe7xvVh5HqfCNpIwGRbfGHD9cpNy/QXT65SyrboKLUGvcD5BTkE5jskoWgR+n8hQM7MpJ8d1EF3XVuL5oeE0WPvu/LcMD30WAwJbGSKqtq2CbYySbJKTkDuQ00kNSRZaqAADLWdCX+2LQgEw0ZeciaU11/2+Q4bbYNzgmZlDgf2/hJbxFHf/p4vb9sVXefvYodM9xsmlXlyKE06FIhJSGWHvsgeJ7xvx8a3zfoO05Jg3BA/i1RigUkNyev8P+6Emt8H4Q7qlOQRdYhPpp2F5bRRc8tpT4ZyXT5oM7K5+GmcTL+RjUOgkoiacXP95ystowMPFBSyciUN286JaBxGSccQDqqNPFt2YZyHw2ngUT0OECVizwG3GTwNmXA7jmxiyryCs0ZVUFETsDfdtbxjDwR5bggHyFCt1ZhLKAiCNnHkOEJtWGhDgjKmiQO+DlzaRCMbd5zw4n/gHuEiiXcI90c4lIvcsUE98FP7tLan2ig9k2SHEkvNdQm2eQgRDugst86PwmABIYoO4fn8sXP+1zZdN8ex5nsVFMHXw9M40p+JmLwwbR2yTKLCDBi7muzlOvHlS2YJf6+zsd2u6aa9gqQjUE2M9YZp9CtMabz6pWRTFPePhSQkBNRQPKimo3vpVHJyQNzpjHdWFVuqnuPio5Cy/NDQHHRqt2sSrOorJpaJUQzqSyx6owDfAGyzp+9fCDb46GJ73WvfRPwOVwXUmL+c/OpbL3X7ZtsQZymCBDog6+dSckZ5iCYCbtWLqVV81+g6mqzgoCH0An0cAQ7EhISae3aXI9IP4LwSHQPDYbJwcGi36ZlfFBTUUSP594whJ7/fAP97pzetP1AqVET0oMHFaCt+uBHmx2XIDpxpN3olx+O0k+nxLu8kcRG2QTISOg2L3gd2ouPvL82QHpkWH0GDLKlTXM+NiqKps4LnPP47vTR2SybVSQ18Pqc8X39jZGcZv2ayBlsOlRkmYoc4SQLNE+h+UwUEbBhxoYRTZ26pCay54CsOWz+ZBSXm0tQEeAAkD1p0nGG7r3Thq1exY4ebjbNqnJkkAS654TXbY2rODBXTPNMNZdspAEydGlfcVjsi+m3xPFnG4s7Csr8hDtf4/96+UCmYY57DUkGZICCnOGbfl3j5GH1meM8W1TMHsX3ZNIKtqNlQgz9VmqEx78nlr7LpeNOqxXkPhq2QCI/RzEodixWk3C75/R9kbxCNqxJUumeET5yVByfMrHdEBtq8gV47wAdQNaqJA4wJpFdCi1t9MEQXz+lW5qjsQDyZ/P+ErpsUCaTSjqnTzt68uP1AcfjUi+migk3jULdEJluoZOD0GWNq0hPnZ80uGtqULBdlclr8u1s124bY00J/Fp1thmJBldJz0Qkam33CuD++bo9xY7mJ9ZaJHDIQSBu150EtN2OX5P/ANsD2RgkfzmZr6Y1BpVqOohrjJPKJ9n2qcb04apyE/dC8FN0vtRZvdMpJSmWXlyyKWCvAf8BfZbQu0Gco6hAmvXeaiaXhiAkl+iSgetBVbEuQArwAK7OP2uqAIGemtkr5O8X7doc1vPxEAhkoDc02IFntOyVWexYHol+5OCR6B4avEiasnEQNZ8lEegASKo6qmObicpqnxbZkeh67qFpQy5D1mUc8LHKyCcD2PsRxLIg7p/vc9Q4bGPTDRnTWBA3krhmUzCgosq8eUHzIlUGIPB/Z/e0lpCrvjt7wWrm1Iqbfbw+/d1VxpJo1SZJR87wbB1koX6v0FGVyRG+iWONq+b+QDee1o3uOPt45oDjWC1ioylNGFP47p6i4PNpEW8OWkB2B8BYeHBCX5Ytr9JxFgn6cGVDH4twu2mWg1AIgl104nFBzwmbQTw/p3Ma8h22LCw3ayoQHxPJNvHLfzngl2MIFaZsW/E8bOckAvPmpK6tWX8CubRfJrC4HAuCdtsOlDGCBBnfO/PLmN6xqHPMN9My8cJkOaSgnSorHBCl5dwSCiLZZyN/8L4YFBOzCGFbOrRKoIrqGlq/t5hJkTRXeRdu95y+L5JXtntcVlnrD77y8SlXNzTEhpq0fjmZo4Lc7wNVTNCYRgblvoMVQQQ68GX9Ogj5CtM4YH7GWz8Fzam7z+1NVw7pwnxp6AJntIpn99JUMQF5I647bQPucyj30WliAbe/CMZtzitlNuDDNXuCGqD7j2uQReO/iQrY2e+tdiQ7Z/LtbBUJckAVa0RTxKb9xZSa3Mo/p7htFjXlMYZF6QyZqLXdK1FmEXPfFnzBmIG0kK7nFmsa6iDpynZe8vh1IuXkpPrCtsbMHpcT8Lq4TiTGRjMiGQEDNP02VT5NH5UVENTTjWnscRDIRoBSDkiEq8pN3gt1ap3Asuahky/7vNhLyNKIgC+RpY4W3T6MCkoD93azxuVQRbV9DbaNLewhmlMA7GhEOPTVm6tsSUODHR6OPDwS3UODG5HB8UXUWFXuiMwaUyYRNheQQUDn8Y/uPI2VZzXHjaSHxoMtU1t06GwavHC6Ln5+qX+TPGVkFtPj5Bqhew+Ws02qvBE8nBrGTmFrFhRqIyxGho+LZZl4qkwdXkKu+y5vWCgCx7nl9O5BjU7h4CPrTrVJUpEzumwdOZgh3huRZME9gW61qF2Ncn+ZSEMjNjmzBkEHU+Zy66RDx+iclsSeAZx4jC9swpEJj00rxooTuQuvYie8m2adLXnswv6MsOFBOjwrN0Exp+ch2ilk3ZlK6UEuYXzj/7u2SWLjvjGkFLA+8/ecSq/wOYhmXTMdEFhcjgWa6u98v50FLl+9+mQmwcLtwEBkkw3zZUeKhCmA8zM16xWzwnGeURERDZLN4WTfrqJyY3YkdF15UAz3GA2h//jBWn+G5yOLc48JeRfYPad2USavbNVU1fX9I2A3+fjE/UVFEUYIiOZQbKjYyBTSAngu0NuHrVaROaZKOG5T4EMgexyQCXRZvsLU5FCvN72WSZJhLkHKKCa6kmmmm9Zj/B4/J9O4w+9+v9X9fdQlFuD+wE7o5C0gU/P6tYOMOuM6Ul/290xSk5CgYrrZFu1nm9wMxgaX5oE9dlqldLRh7FNf0hk5mQEZwHLVIJIgRAJdJmptlZyizCLmPshx3biCj4l5g/GgWkdgyZ0mXbmtMHUi5eSk+sK2xpTVj52IiAhauaOA+nZsRS/DhkkBAwSZRb80KAA3ug+dHBlBZ/dua5R9RF8RXUACdrSh1Y2qvdC2/DL6zcvL6IUrT2I9BJAAwIPjuD+milLIw6HKTG4ozNZgRUWomyQTNKn2qjkbB2WFeKYRdMUVVzT4WJ5siYejFR6J7iHkRRIEOhbefyzbQlcN7UK1VBdUMiluWJXHKqtimWHI9DzOhb6cBw+hOHROiSDWGOydlcxRw0belmF+ODWM3cCkqY6GOjpyA0ExU6k6joXNi3xf2Jy3NOjUZX4kxEayzdtTn/4c1Oj09J7pTFtRBDZgcvBOl3Vn0lFFlosuIKAjB6CF+cj5/ViZOOwgfjc2MpJmj8+h6fNWBWUuQ65mZ0EpI2F4oBD6rCP+/EUA8QgyUByjupJqr2LHjobIMonAOGkIsenkPGQ7pXvusryBqKuuq76xZYCagm1n9kxncwzj3Gl5P5+DIK5NMjaiJAuuCyQdKtNYQ8YIYuXduszDHuktWMM0Htzcc7DcUVY47h1krJxnG6orl1ijuvJqLRnxr2VbqWV8NF3/+rf07MSBzK7xbDsQ7yYb9XoTbGZmAsrlEZC+T1PRUVrhu498jIrkVV1dnVH66qtNefTT1gJmxzF/MI7jordQBEXQiL4ZTBIIWf9j+3VgVVBfOLChaFaN6pMvpDGOc5WlAdz0LMFnsTau2lFovF8mUseJ3rSYDPDrrLZ04+ndrRm1tkA/fhf6xDqb9MC4HKX9USUWfLsln7YcKKVnPt0QsHZznwr3D/MFWscmX03lZ8i/acsyLa6ooThLoMaJ3Mzk+mx5XENTl2fC9YFoBSkrBiZ5Ygnkx0xErS15Q/w8bMOwHm2oSxuf9r7c2PExyJ2UVxtlVXDfodffkHVOZQdwbTq/kO8VnMgh2dYY9NjhOuYPTcihvy1RZ5sjScMEVLi8+L9NAfsS2QfAXvv+d80VWw2tbtTZKBDp8HcX3zE8QLcd2uYmgHDH51WJMIBbH0+sUvlhSz4b6zo74yF0VJUeZCGbARPvofSuh2TX3MKTLfFwNMMj0T2EvEiKm8GvNx0IKPtDFhYi7FymRQdEoyG74BHoHhoDskPnlJwC4JghE/OBBWusGeaNqRfaUKiya/fUZ4mCZKhT6BE/MC6bRj21RHvMpLgYSoqNopEgKurLQnlmCTJHTNBlF6YmxtE0hSQDa+Sk2ORjA/bA+OyA75h0ik06qo+62FxxgCSbMboPCwTChn25MY/um7eD7h+bTVNGZFFJZTXbkMRFRdKGfcUUGRFBn6zdR2t3FTHSQdTCFEunT8pszbJy5yzMZdfOX590Rg9GHIBYEkuiPajhdtN8JM9Dbtonl9KDWISNkWVNAIx9jLWGSEvpyED8DmStePk3CElkb4LlhjwFyrSxGRXL+/kcvHxwZ+N94QSXaHvRuPfxi/obMw9B5CDTMyYqgsk+gARE9qcJmC/I0gUBD4kYp9mGkLzCpltFEIJo1Z3jwxP6MtIc9wT3BzrsTm1Uc0RmWhL98eIB/uxuVBEhSxpyRHiWGAv5pVXsb4xTTowgCQNrVISiT4WokX/zGd39c+zpiQPppf9tpN4dWrE1Ak2rIRGC49x6Zg+KjY5iv6lrNCcT6AD+nvrOKvrDxf2D+my4aRaO7xaUmiXlTCSWE21uaAwDPDNalC9SAeu2LdCP39XJe8AmFbFgU5IjMg3fR6BcF0TC/H/m05/pu60FxqCdikSXf9Mm5SNWHtqqQEQbieAabAOCOHwMNqfANmsuP7oPq8KzBYdUcBNc6pSWxAIZc8blsP1iaUUNm5/tkn3JBt9uPmD8LaxDvBcHkhFA/g/MTGHPBMdBoBVEPCeSMb4goSZXlcjAa7DjaCKqkt1jMjLD7A1l3TQnhn3QVU7YkJIYG7AvgR8u+wBzrx9srMy49YweDa5utNkozNuHJ+RQ2+R4ZkM6pSY6uj+qRBi3Pp5cpTJ7YS49M3Eg3XZmD3/lktz82UPD0KJtpidZ4qHZwiPRPYS8SIqbQbnsD/jH9YNp6aY8rdQLj+aP6tv+MJ25h2MNskMnbwRBhILgUJFTAAhSJxnmoUhHHM7mpDJAZqCkXA5+8U0xqkqQFW0q3cY5qiQUTFIUIOjxXbmJKDJ+yqprlHYC0G3yUxNjaXS/Dv7zT4qNDimY4WbTpyMpWcO4sdn+rDRc04ic9gGNj/gGbOa7q2jaqD4BxxRtKO7PB3cMZ9k7IAnxXGBLuVREc8h4Oxxw+1yP1HmoNp7ieHjzpiEBTTtVn22otJRMBuI4v68/zsdr9/q1WqHNCkAbd3dROR0oqQywFboGjzKgeYyNrGh7cY6wTabMww37SljwftIZ3VmmN+tlcFYPo2QISsjX1QevZOkBU7YhSLL2rXykqWiTa2vrjOdYWVNH943qwwhjlOmL+s3HqgYrCCJOQGNs5e4+SP/5fntQMLt7epI/cx2kGgIq8CWvHhoYrBXXa9xfVET+7pxelJoUQ5cO7qxswAfb2y05nrqlt1CeI5pR60gmrE2mZtVO126xOa3bChmbn5GSGEP3nJdFDyw4JKNkmhti9Z0p0M9/V+XnA6qMXB2ZZgsisflff64q0h5SaKhcSOvc2vqbbioPncjuyT1nMBZs8hlNFSCaTU0ZbZDvFeYFsq5V8wKEqgr4XqVDeylK+cEvFf9WyWbpbICI41ITGRmLbGjuh2HMgECX1xLd3LdJAYkVn6a1AZ8z7aV5TAm/g+rKae+uClqjcA0mxMVENngMm2wUngkqwRat3OWf407tk24f4NTHU1WpwJ7dOvd7uun0bsx3x3MW1xgPHjx4MMEj0T2EvEjaNoOIOK/ZWcgyA+DUq6L5/1y2hS458bhGP2cPxyZUDp24EURp4cXPf+1Kd1Ns/MMake4rZll14ZCOUJGzIHmQ3QxKKlHKqlFpszsh4HlTTt2mGM461y6XS2x5hgc2RCqA6J17wxCKoLVBcx7ZgH/+eH1Aoz+8ftWpXegXzfE4VJt8nMegrqk0o75E1aZ5b2si50QSA1CRlLLWM95H9q48ZoCbz+jBSh0fv7AfayooayojI7e8upaRhPx7fTKSWZYl/8yRkghqanCTKXqkzsNGjrlpbIdxAYkhnV6303EjHgea5IkxUSy49tVGXzAHmDYqiwZ2bs0yvZHli/d4pYmNwOK67k4bBnNAfxhzC8Q4n2vc5pDG5vzlk5+ZHIeKAH1gbDazH7J8x/Qx2fRx7m72923//CFgvtvsTF5JBSXXxrD7gyAtqkdCadDaXAGSR5WNjL9xd0CiI2MUARpUDsSgseC2Av+4Y9nMl53gH9tYX9FT4v4x2ayyihNnot3FZ/E3J5tUtv1gmXns8fdV38VayoNOHKoMZ132JNZWEHMmmAg5rNnIOhcJdLn6bomh+s60NsK/QRYrSDhZ+1/n3+hslm3fIBLhKv8E8g/zf9pJQ3u0CZJ4k3/TbeWhmzX1aFlXGguhynrIcyM+OpJmzl9NH+ceCsRCpx8NlyHJZ0oSwXEQyNRqpvdow/wnyP/AxiKQJvphOtks+G9zxuewimknPl92h2Q/Scs09Id1DfierfLLJAUkjkHT2oCxPG/SUJolzW9+HJ/auc/XRPUNfM/LBmUGzFfb2pOS4H4v4cZG8QbgX4Rgn2z7ANu56apUYGP+9NHPdHzblgEyM8Bd53gZ1B48eNDDI9E9uAZfJG1Nn+DU9OnQimrqauj35/WmW8qrWcYQj/LOXbaFJg7uTCUWyRcPHhpLjxhOvOn9JCmzWde4EtqjcMohLRKqdIQug5SV1r67iu45rzfLLtE1o3Mj4aBqyhlwnXFRdM2r3wRlgYkyIiDudERdQUkly2KCE6zKHvztOb38hDJ/XWyo6WZTB04EUg03DOtGHVonuNY310F3P0F0gFx0ovXMiRt5zOA1bPzm/7gjqIQUr3dJTWQ6z6qxxnWXSwQ5GA9NG0ZyjNmhKO24Hi41a4NMUDjGjek4KIGuozrWAE2stMC5XDjwOPZfrYb68W1Y0EzeHDu1TXzzK8412BSbzZkyopraJQfOb9jVvse1orvP6013oxkWmpjFx9Bn6/bQ+Ge+ZCQ4qkYgLSHaOpDx+JsTiTJAnCM4y6pTRmfTko37/USQrdHlsQDID+k0aHGvq+vq6L5//xQw3odJ4y6gb0b92C6rrGZyLZxAV41fjL8Hx+cwmTYQe+K9v28UpIr0aBEfpV0XEEQ6qUtrv7wZXw8xfhAIUGVPopJje34Zew3jYuRfvmABVJ20iImAx5w6oGjSJ1bfQWYMeuTy3DCtjbqqK96fQKWHbrJpNiLPRt7i+zqJN/k3xWuHVEVMdCST8dBVHh7rTQbRl+aGs3owkruwrJI27it2VQmpGivD6gOZP24rYGPX1vRdBAhc3TqC46IX1+UvLfNV/vVow/5GdSX+NlU84Pw27C2m177aHPDbJh+6e1t15rqTyi85Wxq2YcHKXQFjkCfs6LLNT+zcmn7cls98XblyFHvpyWcd77d5M+cHEtV8vq7aWeioObBbOTgRJokVyOzI1aviHL1nRG8qqahhVRC6ORpqcMdWpeIFtz148OAWHonuwTX4IgktOlMJdbuW8azsEhmUKMkVM4I4gYZF8m9Xn6zUHfXgoaGwaeaBDDG9D6dU3JTpsls+qt+MI3sOmeKhSEfYmoaJuroqHVE3Eg4IHpjmLpoYqbLAoJHJgYZ+usZ6yFjVbWAAXIssT2Ejl3Sb/LSkWCbVMKBTCj3yfi4jE5Cl2pBGnKaN0fR3VwVk0psy7eCYq8aMTheWZWJGRNDTl53AsoIe+2CdtgkUmkl6aB4wNa7DeJ7w168YgQjIG1t5XIdr3JiOM6pvBivJVvUvmLNwDZPVePyDtQFyDEDb5Djaf7CC/v71FiX5fJolYGAqf4f0h9nmVAXMbxDolw7KZHMTmWii/bvr3N70zGcb2frAtZll8gefw+vyRl88R9wfNLQc07+Dv7LH1iz4WIDYN0POFu/UOjEoWxFYUj/uFqrG3YY8qq0f26gCMK3VGFeQikHARSTR0fASBQMmaYGk2GjtuoDvjujbPmBd49mUqFhTrT2874V8LJO0iEq+AJni095ZSRMGqqs6+Vp+Zq90+tfyrY4D/bp1kK9TCA7o5G1wPCQWyA1l9xaVGwPdLWKjHEuwqHqcyHYU175iWwFdPiiT9Wm66LmlpENDmyo2dTx2YX9686f9jkluJ2MFzx450hhjrzhs+i5WFsgSjAiEoFcC5O1E2wviGX4n981sFQ94X/xtIBQZNJPfLo5RWd4GY1Ik0LEmIJMegQBch7w2IFiFas13f9qplKkqLK3S2jz+98ldUtlnI6UeE7B5mKusYXaIcnAidBIruupVbp+Q8b96ZxH9uDVfaYPdJsK4qVIx7T88ePDgQQWPRPcQErBIllZWKxsTYiHCYo6y6zvP7kkJMT79Y90GFwusJ03gobFg08wDaYMyQ5QqYwOXGBtNCbFRVFxRzTLFoF393dZ8mr1gjTG7BUT6vSOqtRkrDW3II+rqirDpCKs2m9j4ct1Z0VmFM33/2By69IWlRgcWjvYUTWM9lO+i8sQEaNHLsJFLuk0+ru2uc3vRHDSA1TQ5xjMxadm62RiJMi0q8IwWvuFXjRlblhQa2gI6hx6vV9bUBpXcdneg8+nh6LZTePYIUANiNhYqQ1g59Og+LFNLF6TDuHA7blTZhvJxRLIzKTaarh3WjRGRcjY2iMnf/bonK4WOjopkOtLVNXWsMu3Jj9bT0k0H2DzH3JQz1Ced2YMFDEDayIEwW/m7mwxXXHvvjGQl4QB7GEHr2LXiHHXEBLebeB/3AP89pVsaI3hA1vFMddik34/oTX/6aL0/i5A3aIXkHc9+b26ayibAJgOqbHFI5eh0yaGdrCJXxLHNn7PJxuIYPKjBgeeHwA98WkhNoIqSE/vQGj8uJYFl0GvXhQ376bphXYOqs3YXllGXtMSQyTcVVPIFs8bl0GaLJBoCY256RNjWQSQMiNUdImBjkO0vV4cgGxaN/FBBpktcQFYtYJv/qsxxk7+HcwqH7F5zxdyvt9CyHeUhkae2JJB7R/TWrku68S5WFoj24UpNfxCxOgnyY7pKSaxXYsNK/DZgmo+7inz3RT5HJ347GofLa60Y7BHXGJ3/Cr/6wWVbtJnosFeoIBBtnhygRCUpJFZhp+QeE9jfICjWELtks1HJ8ZXWPimozpw+OjtIlorLXeGcN+0rZve1ITIzcpUK7hWq6BBcb64NvpsycnNzG/T9Nm3aUGZmZtjOx4MHwCPRPYQMZJOKGQLYwKS3iKP46CiKi42gb3/JZ5sebCj/ecNg+nJjHsuCQfYXX9RbJ8ZQQkzkMV9G6aFxodPMY2WLb60IyMoYXl+afe2r3/jJIThfi24fTvuLfeSmDm7HsUhmgbiH0//uDzuYBjqyNovLQbBE056icoqN1JNENh1h1XllpiXRHy8ewAh4fB8yCshQr6utY9Ujpmw1naMNR/SywZ3p+y35xqzyFgqZHNgRZLfddFp3FriAdi20cJFprnp2uwrK6L/r91FGcjx1TE1g5Ad+m2+WeINPnkEvb/bx7OGIo7wbJAn0ZMuratmzwMbCJNegAyfOT6snBDGGsDGRwWVexA2OuMnDeYFgMwHnCZJCfA6bHxnl+Fw9NAyYk/65kxBNrRNjXQVqVMA4x9xSNRFlkiRvr2Rj2dTwDcE/t+NGlW0oHkcnjTFUk439S16pX1+Uk1//+W4b/b6+6aHoN0REEHVMSWA2g9tckAuwNyCaiytqWKYt7FJecaWftEYzUzErHf+vyyLmBBl/ZphfxkDWhv2MZHBCxs4Y04cuOKEj23zr7g0kO0ByjMxpzxrlcWIP4PafsYoKkqa5AWseJ8NSEmNp3e4ipmfO7SEa1kL3Wia9HOlpl1WxbEfceyeZqCL4c16xvZBeuupk+uMHayXJmDY0bXRWUFNsDryekRJPPywJrs5CcIVfN3/etjXGrS+BuYs1wyZnZtIPloNrNXV12uu1nSOOg4CamO3PkRi7id6/fTgLJqnIfMiZgUhH0BD6zmjOC8IeCQ8gc5Epi+PrMsd118jJy4cWrmFZ+9zHgv2GPF1zn3s2IMAZGZdoJU9Vax8nk3V+TUm52Y9CBUnV7tqAdVRVWeBkXuMcUpJitZWSIJ3FtQNj8FDXCjU27SuhhxbmBq2Ttn4lSCY7/69fKddaHuypqK5hduD/zj6ehvVow4LOSXGQd4mgT9ftobSWsdS+ZTwjkTH2ZXmqWWOz2f8X1NsYQCtnhX5Hw7oE+Mcc/rXIAD7nQ/F/bD0dIOVyyUmZdPlLX9MVQzqzwAuqYkW5K0jCwNcXpah48M2WGDB1VBZdlV/G7AlfW1ARcMWgTIqIjGD3776RWTSF+VtmP8rD4UFZIfy5CLriiisadJyEhERauzbXI9IV2Lp1K+3f3/DAUZtjMFDhkegeQgYvtcMCzRfsP328njX6G9QllWm+yRp2/7h+CD26ODfICXhgnM8J8ODhcIGVLUoEOiA3rQPg9IEkmW1p/OWmHFhF4GOOvH7dIJYV8unafQGvI9MMTijPmgn83eiQzgtOr8rxtWWr6RxtnlEDUsSUVS7K5OicfVzzI+frM9Ch7frRmt2sr8ID81crNSC5o51XXEFVNbXMucbmZUteCcvCx7nh2kCazFmwwngMOWNG3gyIm5kbhnVl34G+rSpDFllSJlISpGFtrXlbV1FVq80Y8tC42JpXElSJgfGK6g4Ep3RwkgHudBOrA4JBbseNKttQJAdsZeKyvFGn1EQ/QehrFhnBSGlsjhFEB3kO0gpN4UD8gWSeUq+tDnsAkgGl7Zjb8u/yvgGIMV39t2/8r6/dVcSah07X9KUAwXpv/TMDgeuEjFmzq8gvPacDAm+zF/uqYHT3BtJXuD9oSgcy3aQ7+/p1g6m5QqevrdM6l22wrdoAzZjTWsTS9cO6sWxyE+Rj8fGA8YmM9GDJmP00Z0GuVsoLr6MaSjVHZry7mq0NaLAorvemNSYUaRGs5Y8a5OlMJLGuqbnu/ORzdEPA4zVUqCAYyMm4dXuKqVVCNHsuaCgbFVHH/h99ZlT7iKc+WR9S5jjWf/RA4Ou/E/sdapPF5gS+7ujWPgQ89MRtGo3ul2E5vq+PhPwc8LwePr8vbckrZdWinVLNsjLI3OZVJaq5iFglKiUvfeFrV3MNY1G1TpqIYVwLGqOKkI+Bfz9ty6enJ55Af1vyCz358c8B9oFXbUASFXsAk2+OjHcOrZwVsz919MaNp9AHa3YHBPFwTKz7pgQPjP9Q/R+cJwIBU+cFfpfJ1g3tQi/8byPde14WOx8E2B55P/gZcnkgboexRsOW/P6t3IA1mEvgHCxHsC2W+QVyshQSo5DIh6D6lLeCr+f/XY9m5R6OJKpKD7LxOmDiPZTe1VzhrEPRrs207JVZjCg+1kheJwR6795ZVFbmq35tCBKOwUCFR6J7CBmi8yAu2GiA+Ohi9eIHfVA4ziJByBonzltFf7h4QIMz+Tx4cArIJqga+KgaRAIY56iqAAEjZjKI2epON3U6Ah9zBM6ePEfwOhqUYSMsZ6nCAcUG2JaF6Qa2bve67Bsxa1PMNuVloz3SW/gbk4Iow6a9f6cUrVwCHHVoNWJjJJ5PQWkV0xRHaasTcu9gRTVd/IJvgwai7YH3fKWivMGnyl7pCELcT2RQIqCC8n48fxCCaO4YqM/qC0ZAqxKbQLzPNySpLWLpscXmTd6Ha/Zos/mxAVi++YD2+XhoPID0UUkZYbxOfWcVTR+dRVFRkQFEC+Y7byIo2g5VE0FTZhvGKzK+VOXhAOwAtJ1N40be1OuyDWEz0DC5V0YynZvdTpuNLdtK/PYHq3ezLEBOwPHMbhwfx8EcwtwA6XnXmz+yChIO7kuY5jYkU9AH4r3bhgWRCSq96KqqGj+BzrPakB1sAuwVntG/bzrF+Dlk0uvkR/B7KBXHPZflsHS6s80VJn1tnca+bIMx90DIqe43xh10kjHuoP3b77hW2qxsrANiJqpIqtsqFG4+o7vyfYwn0/cw/+X13rTGiGNFJnABHalrk6/jEI+LYNa0dwJJJnbeTOs9MKFAdY6hEPCtNGQcr1xBkOzJTwIJdHEfAbsZCpGNMSQT6Py4eP2P0j5EvjbYYBDGyIjFdR0rpHpSXDTTs9etfagkwn1RE7e+901zl89H+TlgnN779kr//Udw1lTlCOkTjGdT9dC1xZVKv11Hhsta/PvqK1L5/BElH/lxTQ205bUWMkuPf7AuyH/n1zi6bwe2DvP+RwBLsYjQ78nNdiyPrj5YTj8hU3/iCfT7t1aw4CF8U+ixwyeGfy0HNPE6PnP3Wz85nj8y0LAW/sKkM3ow8lpuclxVL6FmOn/uc3D//cFFuUqtfZD1+Nwji4N7uzDe4d1VzI7oxrSHowct2mZSamavI30azQ4ILIBAH3ztTErO0MuU2lB0jAYqPBLdQ8gQS+34godFLToyQqt9p9Ki5Is6slE8Et3D4QKyWkxQZSqiVFyUKeCbRJBhbhpXmgh83RxhpPKIrIDX+IYTmzzMRf65UBtqOoUu+yag0Z+iD8K8SadSZzqUYYRNF0pZTfrgG/YW02tfbQ4gG0Fec0fa5mjLGzSQBf0zU+iTtfuYs65q2CofgwPXDFJ/6jsrWZk6z9iBFiU2BJDDETfU+C+a6C1asTNg8/iP6wdrnXRGxkZFUt+OrWhs/w5sYyZnbkJuCFrKplJ7D40DrFO68YI5vS2/jAW6sIl+eEJflmmNTaouA1XObAPpO/f6wcw+iRlgADaMyMwUj8XLwyF1ADvw3RYfea2qApk5NpvGPLXEUZY7zmfqqD5MfgWVZSbweS/qFvNxKTd6E23Srt1Fvg29MMe4L2Ga27A7kHdQ9Z8QA4CQfEIztpZx0QH3AvfznD7tjE0kWT+DzBRCQYiJ/MkvMa8jaISHxsdO5LCaM0zX3M6idc7teEarBLpmWFcWuZBtojjuIAOA4OXMMX1olqJKCXJpjyzKDVqTMWdtFQqYzzKJh/EBvzcUf0O1xvCxoiOnVXJz4vpoC4LjuCCQ+h7Xis7s1ZbJKFw2OJPdWzk5AM/lljN6BJH8/Bx1wREbAR+nIeP435BVMO0jMP/Dbb+XCPsQXBeC9dPmrfSPHzHTGtJabptvHu04tXsafb29LOh1jHcEZ4d0TWVVhirMXphLb086NeC+yE10500aSrMkrWuV1r34HGS7Yeudg+9gfNskVsTv8Lmia+4tnh/GQG0t0W1zfcFh8feR2QxJEKzbwJ6iCr/8mOyniWstpFBt9g/SQ5hHCKBf//q3fqIZfRDQjLldsi+JA9cDmcMkSTJRBuycb1xH0N+uPpkeWeyTr4KkzHebD6ib3lMEk7RyMn90aBHn64F2+UvLlO9zf8BJpZgT/92mxQ+/3Wsm6uFYBwh0L0jhHh6J7qFB4Fkv6/cU+x3MXYWBjWlk6BZHZIt68NBYkDO6QKyYoCodF19jTmVEBNP2hKa2G6I6FAKfk8eL7xjOyHw5g4NnfiMrBpuExmxWxwNo8uYZ2WUmyGWzyChFdq7tXsglsCCm+Xs2yBs0We9Y17BVvCaQ/zyrVSTQVaXL4ob6UMVBoJNu+81f6oM1LOttVBb9/rxe7D5BFgLPHAQKCD6dtICHxoOt/wAfk5gXU95eQSP7drBmoPKsNJ3cBcYZNqfPfLoh6Fh8biAgxb+nqwKBxIIp6CLLM8xZsJpJqtj0+SFvtHDyMHp/9e4AAl0kCNFcEXru3CYhIxQSS9C/RmXHQxNyGNHC759tbttkbXD+IBMWrNhJt53pa1TIgfPDHIKME5qIBpR512tf7yrw+TGT/vEdPTVxIFHEOiVxi7Jzm7wO+iI4kcNqzlBdMw9CJlkIH2TBojLh1rm+APZ/bj6Vdp5aFtAYTxx32w6U+e3nNNjPEb0D7CekHBCQQgUEPwbG8Ok9063NOfEbvLkf1gb8BqqGcI4mmKRoxDVGbIKpI6dVcnNOmj8COC4I9MtZ/5DIoCoslcQM7AYCeyAHca6iX5FXUsmqydBsW5Z+AKk2SUPAm8irLx2Q5DY7HOr3QMpxO4xrEtdunUSGm/t/NAOSQw9+tFlLIp/YubXW58BYgWSWDnj/l7wS/9yBXUTfDXnuys9JZTdW7SikO8/uSZPPrGN63Emx0QE+uE2nXF6L5P0s9rAqHxvA9aMSQvbpcM+mv7uKRvbNCAgk6CSbxLXW1sdEXAsLy6u0fifmFVajRSt2+X1cmz3C2ndLeXf/mEbyhigpIwKfLSoznyuuRVcpB+Ceb84z21jIU7aNjbKevxP/vbTCnGTi9WPz4MFDkyXRn3nmGXr88cdp9+7d1L9/f3rqqado0KBB2s8XFBTQ1KlT6e2336YDBw5Q586d6cknn6SRI0ce1vP2cAhYILHocQdTlsFwupmwabl68CADWoId2gZKJ6igIqcgsQHCRJURLmYvm17D8UCiuN04IWs0lDmCzQEkZXg2vAie+X1277bGxoPhAjYcD4zNpuLKakZa4JxB3hsbisZHBzjYaKba1aChKN4LsQQW8i7iezpgw3/lK8uDNmgiUWc7Bmxbr/a+rqQ4d06gY7P1qmVDzbKoFOPL9pv8fdZM8p1V7J5i8ylumlSSQx4aH2jAawI0W8XGiBmt1FlZeH7XDevm38iZ5C4QrJs9LpvufmuF8lgYc2JgTlcF0rVNkrZkXZZ9wtjt3aGVX1pFN6/xOkhESHKogDmGY6N5qCg7c89bPwUQEbDFTKu8qtbRHIHm9cZ9xVrbj/OHhBLPRlO9P/HFr5nfct+oLKqoqmFEKDIuJzz7FbuHPFD2l0/W093n9vIThSK5gu/r7g0y3VMV52cjeZpb4Lq4wtc4W4QYhLTpzpdUVAeM5+q6WmXzXZX9vE9jP0Gqi+sogtO25pw4Dua0KEmE6+Okk65iAWNb9h1EQKJJrqowZe7r5OZEiQgdkF198+nd2fx53KGMGSQWrnztW/roztPY3yAYkxMq/dIyugaOmB+wgyAsZWkZVOyYYNOpttlh7fcSLP1jEqJZkAH3/rJBgWXpJokJp/f/aEZ5dQ3dPyabkd2qABXuCWxgqM8M1Rr8/r03eShdIuiSq54T7EdCTJR/PV25o4CRvOidIBK9PHEBEno2nXJ5LZLBX39oUa7y+0bZJsX9Uc0nea21rQfiWpjeIo71HlP5nQgag0CHz4lqS9OaLdoj0XewBa8TWcNTPfD9Xz3xuf9vVZUMApYmgAtYtGq39fz7ZCRb/QTb+YbSe8KDBw8egCPKWr7xxhv029/+lp577jkaPHgwI8PPPfdcWrduHbVt2zbo85WVlfTrX/+avffWW29Rx44dacuWLZSSYnbAPTQ+sJBx58K04VZpUfJNhiXZzYOHIFz+0nKKjEs0ltPqyCnIZIC0gbqgTOZMOrMHXffaN8aS04ZkMiTFRrueI3gdciExlkyqw+kUJsZF09eb8vxNhDkxoiq1FWVQOEA6oGxbq+Es3Qt+r0GOgejAeyZHG5sKVeatSMLjGCa5hu+3FlD75Hjm/IP859eITZ1OC5lvqPnn5SZNKHPXX3Mb370VpFpE0kQ8XlJsNMuoFCU/PDRuQzjMQZ0MCF7/YPUe/2YZz3hMvwyt7E50lG/Rw7mB3MIGHMSNmM3JyQubbI8tMAe7IEqw2RoP4p5x0kjXKBhjFQ3B5i7bwv4WddD5+WKuicf222NNw7MZY7P98940t7HJ5mSmyvbj/DkhsLeoQvnMcI4/bs2nS0/uRFkZvkAZiPT3O7cO6vWChqC4Pvl88IywjmArH7iO+PovqErbTSRPc4EYuIaOcYdW8QHPU7y3tiCNuAbgbzxPE9Etr58q0lkkX/jaCuB5Qe4FRKpOdgK/zcc0dP3x9wv/28TGPkacLPUya1w2zVm4RnmfdD1LbNUKKrILWeFkCCzhmXB5EoxZk5Y/v1/i/dx6oDQgeIFzn3RG9yCJD/EZI5Ctkl2ykeAx0RHKOcursxBYxHy02XVxDUiKjWZ21jjWthZQ74xk5qfoms8216zWMU99Sc9dO0yZpGEDnhWetRNdcZNN5sdqERtNt6GfhnAsVCuh+aatEgD/0OQSWtdy42Yn8oa6SktcA6onTVCNEXE+qc7BtB7gN1G1tbOwnP0/gl+6Cg74xTxpQyd7o9rLiOPcSkrHRBmfG/pS2Ko0QJIPq/etZd8Y14pnrzt/fO/q+vPHMTGmzuqdztZnuRHqmp2FbJyZ9lqoSNZdjwcPHg5/o9P9+xvuF7dp0+awaLMfURL9iSeeoBtuuIGuueYa9jfI9IULF9Irr7xC9957b9Dn8Tqyz7/66iuKifGRIF26hC6E7yG8wGYZGQNJsdF0dlY7IgrMchle3y37wQWBmwm8jlL0KPPa7cGDFqZyWl1GFwgUbAjfuvkUurqw3J95c6CkkjqnJvib1sEhA0msa5AVCmmN0tPJZx2vdHDnjO/LykVFwMnDpgAb/PjoSms2aWOQhyrgfIb1aENd2iT5r4VnZ6KhHhx+bHrhqM56bw19vPYQgQ5gE//4h+vo7nORKRpcVj59TDaNf+bLoHvNtR/RbJXrx8u2BmXkYiBEvJedWif4gxVwtKePzjZqdUITmm3OEmLYGMOYwCbeBIwdfF5Vegunf8bobJoDvXNJKxuk5D+WbQkiIzE+dRIyw+v1OD2Yq0/CoV2LMY+5iCZaSzSbOw6MpzkLcrUl8K0TY1jzTshMQPpF1m4Wx4CdRI92lGXutPEgxtquQh8hIMpFiRIxyLJGAzJIvqh00DEuYRt4M2Fbhi2un0lxnNmDZRsq53a9XXh/1S52jrLt57YPFUKZqYmMwH30/bX019+cyOyF/MxmjPHpY4PwxvfF+yP2a9Bt6tFgsLyqlk7skurXdu/YOoFlF8cjW15R2m4KZjQHyIFrkBuT//lDwP0Ts3qdECaiTb5//mr6f9cNpmn1GcNOgt0iuSUSeuLays+9uqaW7jqnF907IpJpHGOcxURFMpkHjA3eIJtri6OBICRWxDkCION1V2EZXfXKctYQsKqmzjGp5yY7lQdWE2Ijad3ug7Q3MYaN/Y6tE4NkXPpntmb3NFEKwKqqtUz3E8DYhdSLyr7xprq6puamYCR+96M1u9m6DF+IfwbXCfL/2c82sAotm11XrQF87UWvB9muXCWQc4AcyLNXrTX9rFbbNSKLWH5ufA7h/jvRFQfe+X47s7lIrFAd6/73VgetE5ijtsQFLouG74syQ9ifdk5LDFiLTMC1zBmXw6T1WiXGsIA3+l+gmjKU+4exoZKQsZH2kCJDheenuXvZPTTJpco9ieQ1G88OVWPiWi1XyZiC13g2CDLj+aCJuiyDBt9V10h1V9Gh8545fzWrwrs1JpKe/mxDkC+LYw3tnhZ0/vC7fc3VY5hEWnrLOPpl70G657wsNp95XzZ8B0l9px+fzip37zmvNz358Xr6dO2+gHsLO/jI+7nacejBg4fDS6D37p3FGp02FAkJibR2bW6jE+lHjERHVvl3331HU6ZM8b8WGRlJZ599Ni1dulT5nfnz59Mpp5xCt956K7377ruUnp5OEydOpHvuuYeiosxZWB4aD3wjITo3cFSxcMGpgQMAxwIL3kXPfcW6gGORg/PNNSUfXpRLs8bmHNHr8NC0oSunNWV0wZEEAdIlLclPKKFJqHgMbD5XbCtQkli6LDIbcPzOqYk0ul+HAFIKzc0SoyPpofP7MQ1k6EIiYwsbTr7JNxEwj13Qj+mFNwZ5qEOntCTWJAwbDlzHzsIyNtdXbi9kGse4b9j4ygQ6BxzbK4d08WtlimXE2MCIzdPEe41rgSON7DuUINfU+vSeuWYrtBJBcMmOMRxmnPNjF/ZnY2P8gI60/UCp8vf5ZoNnmIHshIQLz+QzAZsN/FNpqOKaQcE/OCGHaVyisRtKnZds2O//Td44iW8wcE46TVY8a9jg168b7Pr5NUfoqk+caNc6CUBlpiXRHy8ewOYoenkgO0vWA1dp8IvAJq6ujljW671vH2peF9jIi+jG07qx0nVTlh9eR2DOaZa5rfEg7gGyxEDEmSRiUJKPDDCVDjpv4KjKEDcB/sC2A6VsnkLGA3MbhDjuNbJ+QfohsIaeADzIgOuFHVDZPsx5aJo/9cl6XxPmEb2puLyG2dWkuCj6zcvLmbTEnb/uFdAQGP+Q6Spev7yphw2H3ADkRVonpgcEJOAXyZmUoh3WBTOaA+RACe6VfP9A4pruLXSLsf6VV9YwO89tMsb30xMHskoymSQDwSU23FSRW75kjmzKK65kVSK472jSDGm4VgmxNF1q3Cs3LeUyLqKN+WpjXsC5Y0wgeATfF8GUV68ZxJ7t0w6CV06zUznxpQusYtw/cn4/Oq5+DmN+wPeWP6fTbIYsFdZE/rqcSSxXRA3MbB1EyMfFRGqvTxeMFO/36h1F7DOY17hnkLKY8a5aj1q267o1gBNpeFbieg+fBVr5fO1VBXd0BCPLjh/dhwVSeHZ89/Tg7PumABOJivGIqjy+9qn8U9GuFZRVUnx0FP20PVBXHHMQTatBaKuOBbsvViy6qQQQn7t8DD53nSaUYE2Nj42iP3y4zn8/EJS1NaRWVR+2axlHneuTTVTAfYN9wB4A8iqwIehZgHsBqTE0/kVyBXoZOCXw5TUbDe3luX/Xub3oz5+s979mCmhiLuI3oHs+dVQWVWFdZkHHOkZso1moLti/aV8JPbQwl30PzyWnYyv6VtHAFM8NNgFym9CWV+m+4/4+uDCXSa/968YhLNAmVsKqbBwSdbDPwF6ltPKQFj9w93m9WWANewb4BLj3th4XHjx4CC+QgQ4CffC1M1mj01BRtGszLXtlFjtesyXRcXE1NTXUrh0ylg8Bf69du1b5nU2bNtGnn35Kl19+OS1atIg2bNhAkyZNoqqqKpo5c6byOxUVFewfR1FRUZiv5NiGrjQbjiojgYZ29S/syMKBE49FGgscSCg0FquoiqALTuxE2/JLKSY60tjZ28OxCd08fuLi/pTaOsW/eVOV08KxMkFXbux/34UEghvgvEDYw2FuEYsMi+gAAt80D0wEjEzcHI7GV22T45ktwG+D2JBlD8TNj2qDgUwfVTYcJ6p199pEBuJ1EOVwjPk9wrPmpB7+u2drOV3+0lf0+rWDjA068V1cHysPrr8um9wECHc0R9OV3n6ydh9dPqSEkT78OzzzVtbM5lnzuGe4T9jIyaWrR7ucy+FcizEvvtuSr71POu1ap9nrGAt4tshyQjY2MldV41cH/qwxFxDEM2Vmoyni6h2FrFTbZoegCavLMndTnYLPgaTEBtVEGIjSNapGkKpaDVuGbW1tHQ3s3JqRB2lJepsma80iiKYizXDu2GSjT4Sso41rGHdCR/Z91dohn6tMSrx/x3DKK61kY6BrG5/kk5sgji2Y0VTnsRwoETXK+f2Tg5DyvUXWZmZqbNB4B7nCG+zKgVmMVfiY8pgEaYeAkJgJmppYSbuLyil3VxFFREQwia0/f/KzsQkwgukgkkBIgyDnz1cVYFp0+zBG2KAPgRzAcgKd34FrufXMHv51QxdYxbjHegViDsdCIEr1OZVmMzJBIYPAbRp+E9n2nHQykVUiIZ+SYL5WMRjJSNSEaFa9gQaVqASUgwyo6lD1GFElUegqXnDuCPy1TY5jVS98XYDWNrffCI5h7cD1i8EdSHlcMLAjzXx3tf+Z4HjI6MeYFBtKbn5kFDXFOawjUQPWGYt/yp8BssGxDuP+weYFJIvU++U4jnwsMXgpwkklgKnSKRTdejxX8T6I90dcF5m00Zk96La531sbzusgBm9HP7Uk4D3MBTTCzt1Z5Pc7ZV8aklkmmSvYLNhdrM9YX+FToloT54Xv45g8oImgEP6hkSgPbmBtltdi7svkl1YZ/R88O9z/q+p7IZgamOJz8IswZmBrsbb7kmSqqbTK16sECUOfrd/HbDcq4a4d1o3Z8Fe0Nm4t80lwr7gfwO3YNMGvF5+VBw8eDj+SM7pQamYvagpoUqG22tpapof+wgsvsMzzE088kXbs2MEak+pI9IcffphmzZp12M/1WIGt+REkFRCdVjnZwPrdBwPKMrnWZGNkzHpoutDN49+++RPTROfjCuSQKqPSlFnjJPsPZNCIvhlsIyluBEKFiazjzZFsUBEwbJMZxg1EKLYAmYEyocA3P1o5kh5tgrLhzs5qS93Tk1jDN+4843k6PX98FhmG2DiktYhTkoYgyfB70E63jRHZ1tk0Jw+UYnyYJV9wbiYyAyXEPIsGREOChbw4mnE412I0MjTdp5KKYMLUKfGpmrtYt1TZnGJGG2uaKVQ5vLF8K8uwRZM+E0BmIaPbRpKb7IJbaRuQoLgOEHXYuEfQusDSbYlUk4ENOgjHG4YFN75FtrBuow87gMDEmKeW+LN+kbnmpMEiNtm6z4HsEANUqu+rpBhwb3GunAjCBhxkZIdWCez39hdXsOSAz9fvo3W7imjWuBx2P8NN5DS1eSwHH1QBR1MQEvecj2t5vCPbVyQr5ecMn1OVvSjKOPga2yL54xAROmtMNt11Tm+68bTu9f0FIujTdXvo+c83sXOcPqoPXXZyJyZFgExKSBeasDmvlGlLN6QKzBQsB8kMggkSLqZGh3ysgQD70qEGOmQZ/rl8K703eRhbwUAej/jLFwFyTTpCPpIi2Dn/a/lWR76VikTVwVbFIgbCVJ81kf9j+3Vg76PCBVVF6JXAbTrvvcDHkfhMUGkwTapeaMpzWK4KgX411i/eF8YEMVALXwUJFbCdqvHJJfLIRaDVliWP8WZbT93o1qsaw4v3Z9qoPsyH4/MS6x4SMlBZbdNtN0G+foxL2BA0uMY9nTk6mx5bnEuXDu4cMJZ5QAeQ/ZMpI3rTla8sZ9cE2yXq3quqgOTmqzxJRhvMrq8+c9LXAqissVcVILlJVV0GCTwQ/GiiKq4FyLQ32TisDaJmu86O8WflVXZ68OAOubm5R+S7xxyJDtF3EOF79uwJeB1/t2/fXvmdjIwMpoUuSrdkZWXR7t27mTxMbGzwwgS5GDQvFSPunTp1Cuu1HMuwObXIAhUhEkVwyqCTKeKLRs6Y9dA0YZvHGFfY7CGrSZVRqSM7odHvZGPwewW5Fkp5aEOlJmxAaeWRanzFbYGq5JZvfpAJopQj2bCfaumQtip3kqdicxqCLI1T0pCXzDvJvpI3Zyp5ArFM9KUrT2Il4iYgC87UAA/l65D8uexFX5n5/NuG0l8+/VmbTejrRXF04nCuxciAfOyDQyXYHPzvh8b3DfqOE+ITUM1d/F2n0QbGBnb9nuKAzZ44rpLjzXMWQFYWh9vs5VDsDd/E45onvvg1uy5I0vAgALRVH128VhkwYI0fD1b4r09u7IfS/muG+jSk5XJxkHfwCfhxxcw1HXBOuJ8lleaGyzopAP59FeHHsoEn9KWt+aVMu5XbiUcW5yoDZ9BcR2DEDdnX1OBkHstSJCr7eqgha0QAUYVx8HC9Pr1qvOuyVEWbioxzXZAJjes27y9h8gjXILt8u6/C56UvNtHd/1kh6RH3oH4dU+jWud+zMfngolz/PLJlxfL3G7qu6+Y7e21vMa3bc9DRWMPaZALWLzwPUcasstqXDQqgSo4/T1HPXgae5c1ndGfrd7h9eFsVixgIU33WRP6jWmXaqCxWVcevH1mu7946lPU/EceR+ExM2fFNdQ7zygrusyEgyseBG59LJxVks4E6KSNdE2c366kb3XqbHccaVof/iUDgvpoF2NAY3Iluuwny9YvjFlXeCOzhebwqjWUe+Mbc+905vdgz4UH7P320nt66+VQqKquk2OgoaxWQ095SAM7hhmHd2BqIfZhOngnAucAngm9rArLldb5Lr4xkVmUjz2OZb5ARFRkRULFpsmPNuem3Bw/hRlkh5mIEXXHFFQ0+VlWFfU9ExzqJDsIbmeSffPIJjR8/3p9pjr9vu+025XeGDh1Kc+fOZZ+Dfjqwfv16Rq6rCHQgLi6O/fPQOHDS/Egl39A+OY5lVqo24U09U8tD+OFkHsNxg8RCu+TgjEpVUzw4c3AoifQ6hUC4swobK0sRDic2veFufOVUBoLbAhW5wEkUaA3qnFY4xPeO6M10alMSY+muf/8UsqY1HG+VnAcyRkfmtA/YDPOSeXGMoGcoMnGg57n3YDnLgkdGlgxx8/H3awax/56b3Y6GdW/jL03X6dqCLMJmCfZRtIOc7MPmAzrpOF9kbWHTiUatpkyboxmHcy1GlpPpPqmyoJwSn6ZsZ10WLJ4xf4YysWfKzOYZXFzWJBSEYm/ETby8wcY5ndwllZVQ8xJwDlzH7HE5TB9Vl7WP718/rBs7BrfH0LNGBrpIoDsFvot7bHt+OtKTf19nT/B8nv1sI7tO2BMdCYfjQ692Z2E504g1NW1syg0IdfMYdndf+aEmqpBdQQPQj3L3+tdgkJSw8dvzy5jc1codBax3zpSoCCouq6KWCTHUMj6ajhMaYrr1OU3ybL4M9J8YycX90lO7pTFyBXIAaLrJnxd/xqP6ZrDP4fPiOLbJeYmZl07W9VCagWOe7ilyRixD790EkOyy3BE/b9xPUVrGpk0NMuv5zzeGPRnGpBMvB8JUnzWT/3l0x9k9WbYunj+eN7J+UXFSXFXtLypz03OnKa/FnPzEM4dEEhpaIpFANTaZzyVUdpiq65zYQJ2U0QlSE2eMw25oXN0q3h/QQK8tVDH2zkgOknJDtZCbvhMqW2PqQYBzQqVSQwOo8vXL45avJyqyHu8hYI9gg5htDuBe8GCI03kEm4n5DIkl05qWGBfNvsflmTBW5N5CAL676HZfdalNDlHnu+jmsS2wiUQHt/6FBw8e7KgqRTC/jgZMvIfSu/YO6Ri7Vi6lVfNfoOpqc8D/aMIRlXNBJPyqq66ik046iQYNGkRPPvkklZSU0DXXXMPev/LKK6ljx46s9Ay45ZZb6Omnn6Y77riDJk+eTD///DM99NBDdPvttx/JyzimwcuddQTAyh2FWvmGORNy6Pfn9aSnP93oKkvBgwcd5HHDnWCVZikwYUBH6zFtmyRIQ4gbYJCtcADRVKlFfPCGA59RBZZMuu5OgN//alOetUTeDdzIQPBNq4pc4CTKi1eam3FWVddR347JDZKl4XrYurLtId0Cy4jlknlsEvH8mP75z/vZdYFkQ/NZWdqBP7uCkgrqmJpA099dFXDdv+qdTrPH59BURfM0bLie/Hh90AYTGwG+ga2uraX9JZXsHEBk2LIwPfiArDATUHYdSpajzRZgLHx052ls04k5jmwq/FeXTcqacs9bxaRR5MxsrJHXDOtCt839QWmnnJJupnPGueF3Md/k46hIDDmrzFQCrssi45IP94/tQ5XVdYycKiytYpVpOJ68QeeZa0r5l+PbsHkBqYrvt+RrbR/vKSBjVN/21DktkT0vNBdF4AvyDKK8hFjSr9u84z4iqMCbDpsyMUNtRn204663VtCy7WV+e4nnecNp3VhGJBrklVfX0IIVu/3NpvG5f1w/hB6obwonN7CDXnZDiVRd/x6nmt68Mgi2PzIyUJrLJuclSx1hjPF5BrsQExnB5FgQpIHPAAmIhSt3u9ZQxvjV9S0Q74fTRqUyuD8irpMV1WYiiusfu00IsNk0U38aVBVuziuhFlgvNTbMRv4jWI5rRJC1U+tEVqVw/l+/Cpi78jOxrRtNCW/dcgrVRSewe49+VXe9+RO7Xpu+N3oL6LLx5eo6pzaQj7cdBWVMGokTsrwqhGOJb7pdAAEAAElEQVT+racGSH6IdkUmuWFXuIyo3EQSFQgyVHPG1IMA9DmCgiY4DaDy64eNQHIMl4PjewXIiJmgGuu6oBiH3HtoS14Ja/Ip2zdVdQEC/d3qm+kieeShRblKW4OKFgTZC0or/BJrKvtZWFZJukvUzWOb3A/OT6xSgu/jwYOH8KFF28yQ9czRELSp4YiS6Jdccgnt27ePZsyYwSRZBgwYQIsXL/Y3G926das/4xxAudkHH3xAd955J/Xr148R7CDU77nnniN4Fcc2sNgi82z6vMDGHCAAUJq9emeh3+GQiUMQCGf2aktZ7VsFOUZNOVPLw5GDPG5C3XCLMG2SMKaTE2K1zXYue3EZcxrFDQcy5UwbeFnX3enGE1Iu52W3p5E5GbSrsIyVInNiHhk8s+p1lRtLBoJvWiFpoHKOcR9s9xv3BmiIHAK+ayrbnjFvNT16YeBGWCQ5Re1HcUP2w9YC+uvlA+nWM3rQU5/9HPDskHWJ65Z/D81Drx9expoaXiNVQfBNCLJXRbsJCRiUUM9dtoU1QON6rLi3zWnD3phwU/YfTluBTfkDC9Y4CjqJ2XsIfomENOZBVCTRsl8OKOeNm+CW7l5wIvGB91Yrm2qJpBkIB4xbaAWLm2dTCbgpAx7XDMLqkffXWjfoPHNtxrurlBt+bNgxX3ngDAgMRqTR9DHQkA1sWD+6b3u6+7zeTKpL9E9O6ZZG2w6UskZqIOOgry9v3mVfBqT7ut1F9N3WAmMmZkObUR/NWLoxj9qmpWiJ8Tnj+zKdbP5ccR/kz3EyCsQNMhpVWtmhNvouKK1i/Togt8CfF2y66XnhOaNpLCqAChWZmGL1EuYZ1h4585ID2skgZGUfAZnPAzNTaProbDbfuWyUUxmYjq0T6ZHz+/mDvrr7YWpUaupvINpKvk7Cdjkh5N0kBDi1aXLQG9rb6HszUtBsN9kwE6D9fqWQjS/bI9UzMa0bTQ0X/nUp6zHE5+zzvzmRpin8GvE+AKgsMUEkPZ3YQFlbfc2uIm3jblRYiOMGWfM6uwJ5QFT2iX24uGxTRVUNdaoP3Im/D93z77bmM1lI/L6pmoFVuVXXNrgHk//aEmNZgAC+pbhGn9U7nVXImKAb66qgmKpCDvNRJtD5NQJi8od8XU5sdMv4WJr40nJlhTDmG3o+uL02HtiE/JLKFvr6Lxz6vMmO4XUPHjx4OKobi0K6RSff8t///jfotVNOOYW+/vrrw3BmHpwCUeUpI7Po93V1VF5Z6yfA3v5uG910Rg/K6dCKrjylC3Vtk8Q27AEZ6ehofkZ3uun0bvSnj35u1plaHhoXGEvI6grHhluEaZPEOtgrmkrJjqa48ULWi0zw+hpatWZZMSDDN+4rdlTOzRukwclnxPzH64MIpHmThtL7q3fR4ZCBgGMOTWBkz9w/JpuVQmPjAVKQz2knRKVbEhQ6tyghLSqvpuT4aBo3oAMjbFTAs8KGWpfhJ163TPQgc+WZz4I1ydu2jNPqYOaXVmk3XeIGE5vWu87tRZe+8DULeojZjHzT+vhF/T2n30H2YiiEuFNbYTouyBynQScxw1lVKYPMs5M7p9LFJ3YKLp13EdzS3QtbUy1+HH6sHfmlrNmeishQ3VNrIKysmumo3jeyN0VC5bY+Ix3/xW9zaReeuabb8ItVK7JsF7L2OqUm0IHiCrrljO5sfoEog3wH3rv7rZ/8BLoqsMkzXLnkEpenc5LFzIHjTx2ZxaoJZH3u5gZuL0FOy1JaSzfuZw3tLn7e57+3TY7TSi6B8II91zWctBFAqnVympToYXpevh4Xvuf8xIfrjN/jwRHY5rv//ZNWuguBMpOPAE1u3D9RUsVpNvdxqYn0tIP7obpvkM+BzBlel6vidIFvHPeh8/uy+Yo1F8fAGvzWd9voghM7+dctp8kwKpuG+9+vUwrTr99dWMZ+k/tEIpmvanaosmGwE+/8uENfqdejTUDTQR1hKPbHwH8RZIONkIN8TRFPTzyBouOT/GMAGea6OSreBxsguTJv0qnWeaoLpgzTzFXMO1QNfOFUsqe+8b0Ifn2j+2bQr2KimByLKpiDQG4E1dHeg+Zr3lccnGGNsYy9AoJlPkmcQ9USJojVMyKQXIGqRP1Y1leWqIJiyt8uq3LUiFi3l7LZaPw/7IvqWaEnEvZyPgmZk1igJCYqgkkKxURFMlkWVfUNxgaST/CMbzm9OxvHfO+h6yth8vk8NC+Eo3El+jlmZmaG5Xw8NH0ccRLdQ9MHFqKf9xZTWUUNZaYl0oa9B6lDSiLdeU5vmjXfF0HHhur1pZuDGwr+vJ8RUyiBA4nenDO1PDQe4Ewim2raOytp1rgcY+aSE0feqaMFp1hsGKhzNMXNMHTbZQJdJmVEpxuOoU2HUqfVi7mHDJpbz+rhWlc51GxwW+ND3b18rN5p5bqWOgkHmbDbmlcS1GQIDjYyIi9/6WvlRs+Wyc4hEz1tNGS5SmObw5b9hiaNc68fzP57oKSCjVWejQOIZBQkglCSjAwhz+nXZy/iXjghxFUEvMlW2OQEkA2pgooMs80vPG9Ii2RIwR63wS3dOUML2tRUSz4OJCdgk5B1KFa5YCOsWrOdVE0kxkbSnqIKenlJoO0CoQWb+MbyrQHNn21yNbCVOCeQXgMzW1NiTBTtP1hBX27M8zcU43YVgb7rhnVjwUts0HUBBZBj+A7sPOYldL11VS46/V9kJ4L4aO6AvQSBrgsyzBmXwwgS6KQXl5slQUDOmuC0wa6OiNI9L559/vq1gxiRdI1GK12uLgDh7zbTW/QRQAjdMyJYCsJpNrd8P3DdKpkm+XOwofN/3BmQCIBnhaz7LqmJynusW3Phe11drynuJhmGS7DxtQ5EpirpRs5Md2MLcR90EjywN/ePy6ZLnl/qSI4E6/D9qOCp/23ur00dlUVllTVNtpIW0mE8Ex1jAL1dTMDYrLPIaGD8Q7Pc1VyVninmBsSU/nXjELb+gBxF0ObMnum0q6g84LM2yR7V+7wxJqpFIL0n2wqMJUj1jchprw3scUAKcLIQzEXQtnObRFYBKTcXt8k1idUzYnALcwS/oZOTmjk2m8Y+/WXQ8XRzUuUHFVvsDgJnqD4z7aVMNlrnl2B9wFySeyLxyp3b5n5Pp3RLpQcn9KVpSGCSPgNZNR6A5+eHa9Pp+Td0f+jh2Gp6mZCQSGvX5npEugcGj0T3EBZgsx8TVcUyFxat3MU2HS98ke9f3LGhNZXAITNs4e3D6DhBU9WDBxueuLg/tU5pFVBCXVGtlhppyLjSOVpwzJw67HwzLJNnckaoSKqbnG5Rh9LcMGs/y8LEue8+WE4pCYGav+GUxGjIvUTZKs8q4/cAGSditolMgmIjJW/mAXxHldmnO3e5fBibeWxWZKKnREP8pLfQN+myaTq3io+hzvVkBSP26s9Xl/GKTQbkY9Bgi2tvQ68XjRmPJZgysvE6xpitXFknH6BrTGgav9DjNTWt0vVrMAVfuLxRQ4NbqnOG5qjtOLjHGJMgSu6XSsqH12fn4TwLy6to2y+BmuI2DWZk5nZoFc/8heDg336WkY6qFputEu+jKUv8mYkDqY7qGGEv2lVGOozOpuc/36Q8Ps4f5BiuBTbhjZuG0H2CHICNcAOaKqnmFrCPRimt+avZM502qobJ+ZiAiqJwwES0ys/Lafa5rrpANc8QEB7/zJda2yD6CKrAgmrs2LTDnUqjHAowBFfSgfzjch0iTGsuZCfuH5tNr3212VUyDLK5xXmrS7qRM8yd2kKcM0hIPAN8HwGCg+XVfokXrNEPL8xl90clxSMTrxVVgdnPvJkj7nG4m6keKXxZ3yjbBD42Tf0BIPfp9H6YJcDy6OqDFf5mmbjXp/dMD1pHbUkLqvcx7zNS4hlBr6so5FnspoAB770hVqjAV7v3bRDzzirHTGsut0MIMslyUqIcCsY9gtvfCv17AOj8y9DZCsg/yk3v5Wdv8pOcQGUvkYEuE+iAHLyMjFhD00dlsV4mKplEAFW9YrBLZwcbuj/00PybXnLN7mWvzKL9+/d7JLoHBo9E99AgcGceG3J05169s4g1gZkxNpvOzW7HNgWIWNs6YuP9lnHR3kLmwRV+++ZP/swZjlAaWjmBytFKjjcTUbz8H44fNnEowRRJWpXGohOZBZ6lAmATnxRrNuUFZVX0zH83sKxLSDKYGreFUyPaTdac6MiLGwRs5HRlmSj5N0kCqDL7sNERyUlT+XByQlTAd3V69dDM1W2s1uwsZBtJnaazmGksbgh14wBZnNg0YHN2/3vrA8578yOj6FiBkyxEbPJUdsCtJIoTW9DCUtrupl8DxtLegxVsIxyu4JZ8zshSNYHZqX/+QP07pTC7JQb5+MacyU61iKOPcvf47ZnYGBKbVfk+i40XcZ9VDREBfAdVO6KGqQrifTQRuNCQVRH2X9YH3FQZ5BzILuWbfRAcJkCui2e/hdrQuakC9tEmp1BQWsmai2JcmcgoaNKHA8gaNkEkSE3jh7/Pr01XXaCaZyb/VyT1WsQfWm94djMqNTH/OFmOY0HHX0cMubFtoUi22dbcqaP6OCKSxUAArnVvUblfo940hsTzcmILedY8fB+MN/z30cWBvRg4yqp9QSD5t8VnhPksS/Oozq05API2TioCz+qVTui7e9/ILGazMVajoyJo5fZCJsXlFE6qszh0EncyyS2uV0BKYmyA/w3g/TkL1tBlQn8a3e/rAgY4B6x7qEo8u3dbf3DdzRzjvqi85nLwv3nzUpUMHIDgHuYgpATRr0xXzWGyFQh4gqQW9eN1PnRDoLKXToKe8IPRtFqVJCM+r1B9PA/NDw1peunBgwoeie4hZKjIJzQ8ef26QUwnWtwcQ67ABJSKh2vT5MGDm4ZWDYGNCFu1s1CZGSlqPMpSIE42kJzk4o0v9xdXGM8Tm0DugOLYcuM2XWbbnPE57LNLgprEOc8ucgLVRoNvEPBv8R3DfRss1PQKsg62kv+SikDyAueOMlCehWIuH46gGWP70K96p7MGoQCaPaqIH2g1qpqp8vLS4vJKRyWj4niyjYMteaXazcaxgIY0nw2FPLLBbdCJlzOrSObJZx2vlVIIV3DLdhyu747sO1FmyqYHLjaGxDwDEYhGnapsMVvpPTJFbRDLwk1zBrZOS9hvyGNNRlExJzaO5ICt9W/2LcEH9IHgUlJZGclMporrN4sJB2h+Fh0ZwWS2msNm/tTuacw+2pBXL92hawTLgzB4XraMa9v7IFBRsWOCSJCaJI7krHWn1QU2H4FrF+O69xZV+OcZsqWf+XRDUDXapDN7sHunI4bcSpy4taG2NRcZ3q0yHPRyUdg9bkNsdoGfl82GYd7yvgdcZgh9Z5w+Y/kZ4ZiQyhjz1BLruTUHwA6iweOs91YbZdFgO+UmlNzXkm2bac46qc4SgXMqqagOkAXhJDdcRaxhTvpX8Hl/taKKSP59VQZ457REbRW1rVqVjxfRFxXXXF3zUpUmuOwDQIJGJU3jxFbgdUiXyb/D7XNSbJRSLqqhcBNIQQW7bv6rehw012CXBw8ejgw8Et1DSNCRT8jMgU6ZTDIhc0O36MOhQRaDE4kJDx5UELNNQEpj87RlfwnLQmsBwrKRiAqdrh/Ptly1o1CZ2cbnwY2ndWNa2CKcbCDr6h1INIJCIzeeZaXKrhI3gfzYYuM2XTknMp0fWLCGBmS2ZtcikmDQWUdZfrjuqc1xxkZELOPlmTS2kn9ky7x/x3A/cY2/xTJOc/nwftpXVEHTR2cT0WpGpG85UKokyxEEvOH1b5WltdhwYSPqpGRUHE+2cYDqgmMZDZEb4uNNtBu8qd7KHQUs+9PtBtHWpEr1fYxFNARE1jmX5kmKjaaUxBjXWqJu+4k41XcPJVNXtC+QhdBli9lK73E/3JSFrzcQ3Lb5hFJ+2BiZYMHfIGPaJ/t0fW2kKDbuqPZ5+5ZTmb3Bd3SkIWzJw4tyg/p4NEU8fmE/2ltRzXTRTcDaxe+vTEZBBxt65KZ1idt+2/tcdsS0NuLzPdJb+Jse2iSO+BhyE6yy+Qi4B5xwrK2tY+cCSSSm96uQgIA8jCpbmhNDbojxUGyobc21va/bO4g2BHbYyXnZbCHuBT8uJz+fu+JE47FFO8FtYVFZpV+6B5UopsqC5iTd5At01vjl41QJAJhnMoHur0qQkjVsc9ZpwElcHxC0RKXQ/519PN03KoutNwhO4nfLK2tYQ2HTevXT1nzmSwMmqRbx9+UMcCR56NZdp3NM9EVtaxXGNYhs2AidD2DK6HZqK4orqunxC/szX5M/+5SEGGbD5Ya+TjTencBNIAXPTZeIMG10Fk149qtjItjlwYOHIwOPRPcQEnTkky4T7FB2QERQAyNsJA6UVNKWvBLmEDWXzCwPhwem7EiMrcteXMZkEcLh4DnR9UM5P5oLYUN+XnZ7evLjn5XfwyZj2ug+9MOW/ADH3UYscad7wcqddE6f9gFZVkENs6SmZuKxkVFmKudEpvPHuXvZPxXCmcnhxnEWM2lQvaILzuF1TsjoYNtEYPPw3Ocb2di5u6yKERgXPbc0iCxHQ6oTMtW2Dxrm0Hl0Ssry8YTsdqf35FhEQzKyMd50DX1fvuok1tBOzOCybRB5dh20fWePz2GZYsiQc9KkKhQ9znA1w3Ki7y6OM1Omt5zFyTNW5eckBi7SW8Zp5QJgEzm5oYOc1YgNvg5OtXJFggUl9ZzoHNQl1f+sbDI1uHfo8QDCLTWpiqa9E0yI8t8Bydscystx7pWRkfTeip00vEeaUluYZwfivnIiWBxPIJB5BrpJkgQSDjbJEi47YlobQThhPEJjmMmKxEVbx4jbYJVqniXGRrNmthgfCLa0ltYpRoBJ48Wmuw/g2E5IOz5vamprHTfw5rCtubaKUptGPZr94nedZNrabCH6NIjAvMSzNgGBHB5UOWRTA6XvGkvm7mgDbBruF6ohcI9VGtg2eR8eTHUqM2QLOHHw9Vu3VuM3ffNIfW4452mj+tD5J3RkEqSAtvEsKkDO6EHXvfaNozEvrkvwQXXjBd+Nj4kM8kVtaxW0zSGXZvIBnATTbLYC2v8+vfjAPgoygR5OmRSngRR8hnMF6E+xoyBQG31XQbkx2BUfG8WuxVQpgbXZg4ejGbm5uUf0+8c6PBLdQ0jQLdC6CDrPAvnH9YPp6qFdAha7fy3bQnec3YuRDtBW/W5zfqMRnh6aF1668iRKT0thjcBs2ZGNSVSoibAkRhbYSp9nL8xlTe+g2QvHH043yAbVJlrcpK3aXkhDuqax/9c1GerQKoEueO4rf0almMmDjDHThtaW6RzOTA63GUii5jUyclSSM1wSwES6IYPcBNxD/BYynXpnJLPvIyAjE4m8/B5ZUOI1gECHnIXcKMlGyvKxpC1VPb4NrdtTxAhfZH7y3hPHEhqSkY3xhuciZ1UzW/HZBmtDO3EcJcVG03db81l1Bt+0hSsry4RwNcMy6bvzTPB/3TCE/ddGaovrv5iRimxOlJZzCQ8euNA1EOakien3xKxGTsyPzGmvJQWRMakjd2Ubg+d/b30/BU6Ki/YOz1W1cRebmqFnxWUvfs3mqI0Qxb1o6uXl0LSujoqnId3S6Nzs9iyIfNvcH/zyY7DJd53bi90T3CNTA1abJAmIOdP7aLrNpYB0a2PH+rkpEkLQStaRtxhX3dokscA3mjirCBi386xresMlDURwIs1E8oK0c9vAWwRmJAKFM+aBvNxvXXPdXhuCC2t3FbF+JtcUVVBERIRfYmlgZgr7Dfm8dLZQlRWPazUFAVi1Woa+EUO4KoGOdsAm3nbm8fTZur3+OaW6Npu8D3/fqcyQKikFDTLlhq+qqiiM536dUmjz/hLaXVhGNeZ4CVtDMJfW7CryJ7LItgKBWfiZVVU19O+bTmHXA18L68l/vttG947IChjzcrY99w3r6uobZgv3F/Ix99c3WxYJbZuuO8DtT0My4GErTEFsVJDj2sTfCIcUnknSx0kgRTXX5Go32HJTVcGCFbtoxbaCAD9NfnbHUo8hD00LZYUY1xF0xRVXhOV4VRXmKjwPahxbu24PYYNugTZF0OEAgYwSFzu+MF7ywlI6MTOFSSc8//mmZpGZ5aHxcf3r39LfbjzNmG3CN+tHQgfPaYZ1HdWxpnfY2Pk3tmTe2EICAGQCh6rJ0HuTh/oJdDGTh2fPwGm0nZsO2NyECpUT7TQDiYOTWsjIQeku7gU2ONg4y5l9ulJilCmbNhGcWOO/pXPwQaxDw1rODIKs0D1v/WTUpQxFtuORCX2ptLqWZs4PlM461pz+UDOy8T4IGVFv2Gk/AmQYm/R8Md8ampVl03pubOAeIgB0yaBMekUgKkAIm8BthmhfcK9AnkO6auaYPjRr/uogiQXeQDgyMoK9BtLsX8u30u/P6+1rXqrQwhYJdE7M80xCyPHImYSndEujU7u3CWrwq7Mx2w6UBYwFlUyDqakZbxJpK83n7zf18nIEMpfvOFQ9gzHw75tPoY37SpgONYina1/9xk+EyfdFDBDbiFYbcQdpnoxWCca1ETJfcoNOMRN1iTR+bj2zB416aokxUOZk3oqfAWGLdRTNGMXvuNWG5ufDbZ9u3QABPXP+amUD71vO6MEqraIjIhhpqCLDeZNOZPfjO0iIATq2TmASNE4kGW3Xlt4ijlV//f4/h2wzgl/zJg2l91fvCuohowK/xyWV1TT3hsH01cY8f58DBLpBXtYp+pfgdVSVmY7JnxuqIfDcGlIJdLQB8oDR8UlsfIEkxr3AfozPKS5pFYq8D8YW1g8umyb3nsB9lOcPqgLwe5gj73duHTCe5f4Fqsoy23oF4FrlDHT+fYyJB8f3pYqqGjbuVZrv8D85VNn2LGD46jdMX/yOs49n0m1y0BXXLAa/xPPhlTRypa0tUO+kUg/39v6x2WxNlOcCXxPRJDVcvWicSPrYqnshjSjPNVV1jKiNrwrQ83vP/TRAVSnhwcPRiKrSg4w5GDDxHkrv6kv4CAW7Vi6lVfNfoOpqs0/lQQ2PRPcQEnQLNBwDU5YH9J8X3T7ML1UgOhIgmmYvWO3PHG7qmVkeGh9v3jSEWraMZw40xpCsjd62ZTwlJ0TT8785kWKiIhm5cjhhy7AGcL4vL/lFSyxhw4FNm+w4cofTNN+SYqNZ9QdK6Pk8EzPGsAnUAXNTlxGPc4dTGwp0TjQCBHBmUeIOWSeUEe87WMH+H/dCbvYnklq4FtMGXldKjOxhZAkBOmkGAGS4U+KW/3dXQRmTqdIFeEzZXbbfKgeB/vYKbRn1sYRQM7JVpb6c2IMduen0bnRmr7b+z8J+1NTV0oML1xn1fHmGNTLisM5Bz98NEe5kk3k4cN/IrKDNtRPNWNiX+8fmUG1NLd3z9kr/dUDWqt9xKUHzQWwgDNIDxPSwekJr/DNfsvfl6xez4eSMRDGTEMhMTaS2LeP8955LJaHSBtVvcga5iqhUyTTYZC14k0hraX5qAj17+UBteXlTwdebDlBkXKL/b9wXNJhHI8Z3f9wZZL/l+4sGrAAkGGD7YZdVTV6dEHdATHSE8flgjqqaWfPxA6kHkIg8E1YMAAByoMzJvJWrJzg5Js4n3o/EVIUEIk6EHGDXrRtYW2V5Nnn+Xfnat/TJb0+ndlIyNteY5+cqN0p/4uIByiAC1ip/gDshmpHopmtD9Z5sX2AzZtX3fimyVMipnoPYyL20qoZVhuEZ3zCsG7VKjKHoqAjKL6livgb+qY4JW4hqNPiWsB+tE2OYbenetnlKPuwsLKc5C3MDxrxqT+ZE3gf3b7YkuwLfcu4NQ+j6175hx4WPZdLZlsdzfumhaik8y7N6pVN0VCTLDMd4w3OEv29ar1buKKS+HVvRi1eexPS/7z0vi2nA7yuuYP4t5hkqIxBsc6L5rsvSxj28751VbH7x3j4icE0IXInBL26HUPGEvhm26rhQKyZAMmNeqXr54Lzl4LEtCGZKrnEq6WOq7lUB91+uSMW5/3PZFlY1U1JRQ1sPlCorxnhyBOAR6B6aGlq0zaTUzF4hf79o1+awns+xBo9E9xASdAv0mp2FNGc8Gp4Eyyvg9ctfWsYi37oMLjhZvEN6U8/M8tD4uPj5r+n07Ey2QcJYxJjUaaPfNvd7OrFza+ZAHi4yCvNkzoS+zNlWkbQolUWGpJwlJ25ssaFVaVECuA6dnMmMMdl01SvLadwJHWlETns67fj0oCxtUzknSqpRfl9LgVmd/Nx9TdjUTm0oTvQ99U40gga2TF+32qOmzQ3IkQ/uGE7b8ssYsSY72nJjQSfELa7zv+v3MfLOBF12lwjVb+3aVeQR6A2EajOIZ49NOeSVIHvw6OK1QRnNkIFZ9ssB/8ZLrnrR9WhwQoS72WQ6BcgvkcSyZYxyEurqU7sEEd4mzVhk2uF3zunTji59YSn95dITgq5Dl+XJgQ373OsHszJyeaMrXr+YDSdXD8hZx7CfsgQPJLMwxxes2GltIqeTaVBt3EXbO/HFr62BB3z2g9V7/OeL33r9usHUXID7gmcur29yQ0/YclR4yCSabPf5d7GGGYnYbQVM7gq+JuQS5OeDIM+BkkAiWh4/yMBEU22Q+nLFCodIwNjmrfwZXZNefAfnzMeWigCDjYFGvyqIq8vmBRDQM4EHEbkUjlPta6yPCEj97t+rg2Qsnvn05wA78qve6YzYQoDF1NBYBrevpsadOvuJ5w9ZGOjP19U/Y9iyAZel0B8kKUCulc/tNI4JAv3SQZlBNh1j6ZHz+9FxqYeCR00Z/1i2lZZtL9PaQ2hQyzDZQbweH10vHxQUGNnPqi0xRp765Gc2hmzrntjMFAkIfK2du2wLDeiUEjSfzuqdTjNGZ9MDCw5VP/FnfM3QLqxH10tLNin9W1RCzRyTzWS5nGi+N1SGCVAFCxAIMCVimJLNnFTq4ZlC1kRVgafys22JQQg4gkhX+TnhkILRgVekInEF9gsyPEh8QDAbPYkg2aMKyAIIyFhaJXjw4IenQ+6BwyPRPYQMLJKz0bm+ooqVPvPMoic/XsecEGgaQqsXZc1YyB5dnMsIPaflzc2py72HxgN3xrHxEaUHdFmi2GSBCIPertPs0FDlFVD+fP97q6l/pxS6+9xejDQVSVpg8FW+jHQdbMEkOI8PT+hLBeVVAfMNJA7OGdc8YUBHyu7QSvl9lKnL8gdwhq8f1o2+3LhPm6WCskq3sDnR2LBMe3eVMdMXDr9Iajl5NqbNDZxqONHQyEVDRWyI+mQk09MTBzJdTcgC3Dr3e39jQafXaSPQxc+63TjY5Aw82KHaDGJsgwzeVVhGC1fuCs6I/Hk/y6jDxv/SF3zaziIwR0zkmI0ID/cmc1teCbOPGNM4N2TboZHxsB5tqJNQhq4ioS4blBn0vpipe895vZk965yayEr1Jzzr672AbDucp6qngi0rG0G+8/78hfX6xQCIzZ+A/VTp1L56zck0+azj2d8ywcL8mrJKZjdNMg2y7UVWKypQuO01BR54tr0oI6MiJpo6kAUogpOlBWWV1LLeXgMq8lNeuzmJjPGsy7IUidicjBSmjSv6ojifnfll1LaV2T5z/9OpfIFt3sqfMUlHfZS7l6aMzHJU8STClg3vVCaG90Jwuubg+YBoFsk+vPbUpz8H2cFP1u4jotXsnCDvqGtorIMpeG6yn3i9qraWIuoi2ByHT6ay0/gcxtUD47JpX3El65sCW6jyLUGiIjv/6WYiPYm175FPtmilPWAPVTBJ6rHmnppngvt3S3k188ed2H0O/A6qK3G+eIbwUVXP8lM21oj5r8joRsNvjLXoyAia99MOWv7LAeV+ITIigh5Cg/CaWsea70BDZJg4eLCA+7X5pQ2TT7ElfJgy1sXqIDfSi5DeEf0cfi2ohDFVGDU0cQ7jbW9RGUsUkAMnqoAshypo6MGDDE+H3IMMj0T30CAcKK2kT9bu9Zdgvnr1yXRcqm9zDmIdWaVfbvRpvPk22J2sx4SjMbyZdbn30Lhgm5kRWdqMEVEbHQ79tgOlrBrCSXZoqPIKYvkznHlsmlWlnCgvNsFJMAnO7VQps0s8V91cgmOLTGy56RrIxGtf+4aVuaJ6hIOXzqKhKzLRVXrFJtgICWiY6jZcuI/TR/WhG4Z19f+e02dj29y0qM/4kdsY4m/e29CNg4/rlBtWyYDOK4DyYdhPN8EZJ3IGHsxQbR6xTqF5GLLcdLYERNG9ERHKDRnmjhNddd0zts0PEI9uGj1uLwgOBmA8dmmTRHExUdRWykgXSSgd4c0zdbk9Q98FkOkACMv0lnFMngRSB/hb3CybsrIxb+NiIq26uQAyy5CxDqK+kyULFFlxKp3aq//2Dc0am00Pjs9hf+MfZLMOSb84q7IRbS+uF3NZrFLggQcQPr/9dU+WcQ3dZzwX1Ya+uQEZgagGwLODZAMyTi987iuW2XtCfRNABDBBakI7X74fGCsgwOSAhi7LkveowPO4+R/f+eXdMKZq62JYZjyyTFEhZtMMdtqgzwnRLic62oI/kC3plt7C8drqpIrFSQNv/Fds6MsJMLwiE2DcHzg3u12QzTPZQRDpd5dVMXkUVUNjHSAHaboftucAOxUfHUWTzujOMk9Ndhpa/rxiFpJ42vXgCPTaacy5OrpfB2XSBOaUaU+mk9SzPRMQmJDGMdlB2fcCcY0x+MZNQ5hMCm/OrAJ878sHd6a46CjqU59IgjF9cudU+tNHP2uf6cGKanYPeG8LJ76YaX45kWHiEP1aax+SmCjX/qMM2ZbiWFg3C0orafWuooDmvhgHOGcEmjfsK1ZKwIh+jspH1xHa4UicS0mIpXsl/XpVQFZVdabzTTx4ADwdcg8yvJ24hwYBGwyeaYWFNCMlnn5Ykh+0SPEF00Ys4XWQj1igm4NT6uHwAQSsCFEfHeMO5AgndfgG1pYd2hB5Bbn8WUcgwTnVaUrC8UaWp42sVhGCuH5k+KCBok+XuTLoGNjgqJqucWAzzc9ZJ1OBc0Q2ppOSZhshAYLJBBAgYnaL02dja7KEbLNN+4ppgUQ4QrdzysjedNtZ3V05+LhOlJXqslBxT9EYds7CNf5sKTfa1yYdUg/OkRQbxdYa2A6MLch8+Mghs2uETTzmgbgh45sxVDGYYArG2OZHRVWtY91syCs8/dkG7WZyzrgcI+FhIryH1+vJcu3vxBi1bQjQIq6XUFA1+8K4nzM+h5ZtyqPUFocyhDu0imfSOqgEwfexuZc35bDpurmA48ZGR/o1qMX1gJP0kPji5IoOpmoX0fbq5vsJmSksYPGbl5ez60CQQWdzmxO4JjLINdxDyDqAKFeNFVOmIDJIVc9Il2UproXi/ESm5BvLt7JsdVM2u0hs2dYOZLXaNNxVa4cuSMXHabxLcgxZnghEQIZJDkJxUovrLqtILdwbyGLgv5xENxFgonyeyuZZgwSKDF8bCYlrEu2fPC9TE2P9/XFUQPDqTx+vZ80an7viROP958FA/KZKJ11Ec5GexH09vWeSdU64gZPsbFsgMViXO5p9hwdvbWMNkLO9sS448UXx2ybNdwRyMU/gs5myumFzUAmx+P+GU2mFL2DLz0nM9IYvyqo66r9vkwNDMFaUA3PaO0W1pnHZSFzPXW/+FNAPSbTPsAn/d/bxxsbavFGskwojfu5OE+dM6zGem5NkKlXvI9Xa7cGDDE+H3ENYSPSSkhJ68803acOGDZSRkUGXXXYZpaWZpQk8NC9g0UNkGovQv24cQnMWrDFGgFWd0MWN+fQx2fTTtgKWmeDBgxuIjraO8OWOYHREhKPs0IbIK8ibRN24Rx8BaLTOQuMlqRnWVad28TfXwyYSJcbYsOP8E+OiWWNQ0ZHk2SQlFXgtlumOinquspNtbRIUG8VkG0BioGnTHz8I1Ij2lz+/vYJtsjq2NhPpNkICmVBOn7GbZ2NrsoSy8qcUhCOTClqUywg+lIg6Ba5z+eYDjDwTGx3yrB0Qj99uPhBAoLvRvtbpkHpwDlWTvz9+tJ6NAVv2F7LTxA0ZX7t+2V9CHVL0euOAKRhj6lEA2wWtcDx7J2QGKlxMm0lVBYxoD0wBoElnHk+REXU0ql8GPfHhOrrwxE7Kcvol0mYZdgwkJuZceVWtP4MYmeVb8kpo3k87g37rtjN7sCav3232aa2iKaB4f8TzXBJ0nj0YAYb7quuXMeGEjsbNOTbltmoXMZMPtveh8X2ZFACyLPFPbmZmk7VpijilWyot2+FrGA+IDaxFe42gh2qs6DIFQ8lQFJ8H7j/mN4hh/PvDRf2V2ez8c5GREVRWVeMna1lfk/E5Wu37C577yl95oNNw5+SQuPapyLGG9FMAzQvSXReY4EQvjoH5hyA/5J0wznFf9hSUs0AF5ifukY0AE+XzRGLKjXSTDN06PbTeFxrx5y9Y0AsBQJwzfBuR6IPtRDBDbgLLjwHilJ9/VU0w8aq7/8hEN6E5SU+aKjxkWQ8n65BtTcM8GNe/g6OqEDmJgDe3t421jooKBpDYJiTFRrOKGYwJ7G1VvRV47wsEkbjPJt8/Xn0DiSnRJmD+qNYW3CuM9a825gUEnp3KgYk9GHREsyo4xmXMcL7sPWFeqewzGo+bgHFj8tFFu+EmSLP9QClNeRvnl6e0jzb5Hfg46MUBW7Bo1e4AWy366rZECg8ePHhwZSX69OlDS5YsodTUVNq2bRuddtpplJ+fTz179qSNGzfS7Nmz6euvv6auXYMdKg/NE9zpxaKLki9dAxQsmJPO6MF07ERdVbwGRwgLPZypxxevZRF7LwvdgxvAoUyIifRvSnW6xPgb9DmyD5xkEjnVQ3WySRTHPW+QdbB+3KMR3+/O6UUzRvfxSYFU1QY114MzOm3eKrbh6N+pNU1/88egbE7MRWST8Kw/2RGWSVpbefcHa3xN77CRQOmsbn7jPLbklbIsmlD1F3nDNKebKbfPxtRkCYEMU/OonQXlrkh0HPOMnumsqRt0YQMy93u0oelj+rDgSEO0r7EJRAVAcb2urC0g4uEQZIJIthe2LGwEQYCW9bIimKs82PXw+X21pIEt2wrPHM0QkYmm06VFw0MnQLab2/dFeyDbK3Z+CTGsYe51r31DJ2a2pvEndKALTuzE1n7T/Jk2qg87b1VjM2DL/hL68yfB+sn8b8h5XHxiJxY0lO9rgE77iCwm1eWXpHr1G0a6/eHC/rSzsIxdB0r7xSxdkCPQNFYRGniWi1bsstpRXVY0SE1Vtp5pfDVVPDihL1VHxQdpIsv22iTzoSJk3TaRdqoFLH4Ozx69S1SBEgSSH1iwhjUZxRwU5QseWrSGfnNKZ6qqqfNXOGANw7iYXC+BIZJD4tqnqsoItZ8C7Nn9ks2QiS9O9Oqyy3Ft63YV+f1vk5Y1k9gZ1cdoL20ZtBgfKvB1GtIXWw+U+o/FfSGcEyQi31+JeRkc0AdQgScmD/Dr21VYbjw/3f3HvsVU7dLcpCfluROqpCE/FvwUJFrIQU48k38u20KXndyJzZN7HGbA8ySCLzfsD5Ah0q3X8N3kACn+mcj9H7fl+wlj9D9588ZTqKSqWtl3SJW0wXXN5WbJAD6PdVS1tuCzkBYUA88yuYvfR0NqVdUOjg05ujkLc7X2TBUcw99T562ku8/t7Yj4RhDL5qvbGhnDJkHqy9R3RMSO/FK65+0VRvtokzqEzwYZKdg3eR0Sq3JtiRQePHjw4IpEX7t2rV/DZ8qUKdShQwf68ccfqVWrVlRcXEwTJkygqVOn0ty5cxvrfD0chYATNWNMHyooMZNaMZERbOPAFytsMNFRvU3LWEJiMNO8FPSOPXhwAp4RsuNAmZ8cN23U4chfO6ybo0wiJ3qobiQ3uJOG13GuIsEye8EaWnT7cEagTxR0yEXAebzz7J5BTXNkR9JplraO1B5en20KsgyAA8+JQx1Q1uqE/DWR2YCTEnvTszGVw8ubQ2xy4EwjIy/Ua9OVlmakJLBzQVYq5EJA1MCBj4qI8MvohFoertvUvn6dOWPOgw/y/JDthb5ayhcAweYZSEuKY2MXm/oze6WzufvNlgN0zdAuQc16nWZbgVTTNfPFmHGa9WjLtBPf52O4uKKKkWgg8TmRjvvCCY8rX/HJkWBc989MYZmrhaVVLHvXBEjlgITUAfPDlDUPYD59v+WA8jP8PAd1TQ3qOwH5EGifv7hkk1+WCvbhlG5pNKx7G5Z1jMbCMukAQAJMJjncBLt0NoqPLzSwk+dwUwXkapKT1VJGGF8JMVFMHkOUVVPZQFGaoSEyEk5hkwUDIftx7l72TwbG0r3nZdGsBauDJM6wlqOiUjx3lfYwGjIiOIS/sWaF0k+B2TPD/Ln1jB7MTpmyyyMpgm49q4dzLWuh4aHKXuI1ZIXjuOIckisUVMA14pp0chH4Lq5XJ9GE4MWH/3caWyePS01gDcv3FVdQp9aH+jSozlnnN/oDHor52tjj80ijIZKGHJD6e+T8frTlQCmr+OBrGuSDJg7uzAKZqH4w+YWqZqZ43kO6pdGDi3L9vr+crY3gXl1tXRCZ/eustjR7XDbL+OaNt3E8sZm8mNG9ds/BoLUF4w/jCeMGckokyS6a/HDT2iIHE2VyF+uVSQ4MMjcme2YiySefaQ6+c/sMGSvMY/R90s2J5Hhzj4M0QULGyThEoo7OT+DBA5PUoRi8c9If4ldZ7RydmwcPHo5NhFyvsnTpUnruuecYgQ60aNGCZs2aRZdeemk4z89DE0FMZKSyPFJEcmIM/fvmU5izUV1Tx5xdEAOvXTOIerZz3kDJgweON24aTKV1cYzUAvmDUn+U/ndolcA2cHD0oHOMsVlUVs0ILmyIQOo4ySSyyY/YGi2pJDfEMlAR2AxOn7eSLhvc2XjNkHPROZLfbslnG0Y0q+R6niqdVpGklUvacW8gRYL/Qo4Ev4VNgg3YGDnVBjVlCdpIdtOzcVMO76p5k+babBlauusEcW+CiSg1bWo9OINMEMmaqsFVI9HUIi6G9hSV+bPP+Pznz1fMZOXkDt8Io8nmoYaVZN1YrthWELRJxjGRGQ1y3olWcrvkOG2mHV7H+6oxzHspTB2VxezBwfLqABJfNcds8wcyLA3phcBtl63EWiUDh+cwsz5L19TXQSyh57Bp7apsghhUQ2UOnhkCpOJxuawNiCNOoIqyCc0JtsZygEiEdmuTRB/deRrLdMRccBO4DAW2gDMCqDrgvGcrAto4HgJRnIQToVoT2tXHHjCvTYBUkOraEfwyAQ17bdnlIPSuHtqFPStfRqetGXeU1l7y55jRKp7+cHF/Jh2jq1DQwUTi84x/nWQfEnK6t2vBrnsaSD7J/+JjT6600V0zv763bj6FZoyOZP0mbCRvc0EokoaqMQofHBn9fJ5zn5KvK1yz38395I2x/3hRf7avnDk6m/UQQlIE1mxkoMdHRwYR6Bg7Oce1Ys1l5YoGJJBcM6xrkP2XJWOc+Jq2MWyC6n1O7jrxx0OxZ0BinLmRKu4DAhAxUZHM5xH7MECOsXNaIgt4N3T/JAPjw3buCB60N+y75OAdfJyr8ssCGqdiz8Or/u46J3Tdaw8ePDR/uCbRYWyA8vJypoMuomPHjrRvX6DGq4fmDzhM0F5GZhocEFVGDFv8t+TTnoMV9M1mZOp19RN7WLSbuyPqoXFwyfPLKDIuMcDJze7QipVZi+PwrN7p9H9n96RTu/uyD6HBiwwSsXw5FPkR27hFtgwyzfgmEo49SAVOxIngWVDQOTQBzrvudTj10+YFbhpVOq0ySStu7HF+z32+kV743yb/BjMpNpqWbNxvLJmFc4/NqxPYSBAnpfiqZ+O0HF4mok3lwEM112bL0Hq8niBTXWNDNhemTa0HZ5DJEpWmqpj9BU1caJqq5j/GAWQCLhuUydY1vhkTN9YoWXa6xumaBCMo+MynG4w9DuTj8BJ5Wfv0MeHc5fdx3fgNHBu6pxc/Hxzsk+eYbf4guAciXVf6n+Iwax4Z76bfUTUAFLNLdfZBLqHnsGntynZUpzUr6zTzRnPY0MdH+9YBRrhE+J5bcwEbX2/p9XUR8MZ6rSKiQHiAGPM1xT5kPxsiLaGCLeMa8gc6mCrenMpyiTAR17AB6HMiE4J8LJkaaqYkxDq6VhBh/LxtmZqoTBPnomgv8T2+1iLNyglp7uZeYF6aJPtA7iFABfk7Vca6KLmDc+b23FQdhvcQ2Dm+XUtqrsB83Vde7CpAIwcSdfNz5thsbfWJ6jhuYPIX5cAR95P3FpXTdIUEEsZLrdDDS1zjxKC0E1/TNoZNkNdEVMGhxweqQ/HbWl/8+DbsXHVVGiZ7xqH389uwhrtM8mXDfhZ0lit0AuZ+A/dPIjAmnfQS4cEYcd8lB+906/TC24fRt5t9yX22ZrcePHjw4JpE/9WvfkXR0dFUVFRE69ato5ycHP97W7Zs8RqLHoPwlZLup++25tN7tw2jGfP1eq7QVQY5R/QLW+B/3JpPLS1Zah482MCJTpVjC2cSJaOPLg5sigmnCVqNPGtCB6eZ0TrAcePOGzYpDy/KDSLQRdgIKR1Mm0r+Pt8wmkha1fWCYDI1GkRTRfQzgByTDeEkQfB5kNVikMIJqSET0aZrg+1C1qh8bbYMLWzeRFkeOUM91M2FjQjxYIdMENnmHKoykG0NMhfZbXz+27Js+UbMLUEgz0H8po8QcldSj+M8bbBdtjE8K/pQnwkTcWibP7gX73durT1PZOmbsubxPoDKIlXZPv+dmKgII5noVo/bNC4wfnA+vCoAWec6rVmknrx/+3BWhi8+A9X42fzIKGouQHm9SbIATavlddk/rt9ewSSARGIWWf33opmkJnCJxngHSitdZafbm2tHa8lkG9zOexNxjeqQ6RobgKx3WQecQ1zvbdfKSSqcN4gopdRbfdUGxi3eB2S/KhwSJ6Z7AQL/1G5p2rmM8QGfQGwarao+eW/yMDY3ecUD/DNTcBtZrs0Zd721gpZtL3MVoBEDiabEAki2qJoGq44TTsj+EveTYeu/dNDDiwMJNw/XZzjjepwE0Ixj+GCFcax1aZPE+q0g+xrzcuWOQlq+OY+toZAEvGBgR5r57uog/xHPCw1RdVUaF594nDE49tm6vWwtlaXGkMl91dAuTB8eY0Hl54jXrmreHMr+iQO265O1e43BA9wjzGV53yVCN0bxN+4n9hPgMRoS1PHgwcOxAVfs5cyZMwP+hoSLiPfee4+GDx8enjPz0GTAnRQspHnFFUY9Vzi/3JGCkwJN9PJqnz56Q8tyPRybELvUw1mTHVtT9iEcYieajk6blNlgIk+Pa51g1WOGEwsnV6X554QgGl6f4cevRZcRrtIOh86oXLKN+b2nqJx+2lbgqCGwaZOF1+eMz2EZOE7vtUxCQcLGBO4YyxsrVfOm0kqfjAUIdNW12chsufRUJjx1mwsABLwuS99rIEphn4eqJn8iOcubBIq2wqQvDIiEQSgEgTgHWTZdiNrcJttl1T0uq6LJZx0fcF2qMvOA5p7n9WZl1fLaj/MEcSDaGxDPkEbA+AcBisxAk+YwNsgPLcpV+hjQ1/11VruA+y7aVd25i5Df57rOIC1kIhFZgSPqqxPwmyOy2xsDEpDhEnXhdeOnuQDXh3FgAjJ7TQ1pxQbguIfQxDXd4w37iv062rbALF/7Cssq6Z83DKYvN+YFZcriGCmJMVoy2Uaqup33Jv9gYGaKkiTn1w5pApkck+ePEx1g8bxVaxSq+CCRgtdkfwBrN8h3kFcNldwx9WsZ0i2V2RITEFS3+X+z5q8Oag4crszZpoilG/P8lZ22AA2X/RLlxWpr6/RyQT/vp1tO7670URuzOavsL3E/GQ2mbbaJ9/Di5HSGMB+YBroBpkAUjndmz3Q6vWe6dqzx5B7T+6IMI54HKrWqa2vp6YkD6YX/bVQm1KBJMtbaadJaKwa8h3ZP80uNcYlHNE8XCXOVnyNee7j3TxgfCGTotO+njOhNe4oq2Dg0wZY4gGt2qtPuwYOHYxsNItFlPP744w09Hw9NEKKTEh+rb4zE5YC4nhu067Ao/+3qk+mSF75ucFmuh2MP828bSumpKSzLBc6diiQJd8l1Q2EiT6E12CsjmWWB3HRad5oyIotpScKJxfWBzMMGEprqs6HBrCEgVICcAvQLZ723mm0IIHzgNCNc3FzK2VxwyOUGaqE4sHh9w95ieu2rzY5sgIqEciq/oCKixXL0xXcMp4SYSGOzY6dZfabxJm8unGTpm4gQD86ha/JXIJB/nAQGgS6TKKaxjA3edfXNi8NBENjI7lCzppw0Tm4XG0Wj+3XwE2WdUtXzks8f2Fu5ARvH1gOlAc0CxQAoAFJm2qgsKqtvoCpnrOH/p43qQ1PnrQzKsOMEwNu3nEpn924bYFf5fHFbQo/n3iU1kY0TZJFDu720ooZioyNZMBPEBeYmSLo+Geqmmrpn1NxlmUzVVhy2knl5PeeBSZ1UAQIVTqo0VHZW1MrGeYnEaatEUq7Z5dW12goK27zXkcw6/wCyNiZgztgyPnUksTh/5PNWEWCzxuVQRbXvGGLACvcLBHq4qs34vUBFg2iTL3p+KeulZAKq0kLx/8KVOdtc8G19Y2aeFY25tmJ7AZNGfOqTQHkxa2+ZmEhroCfckP0lblOsa0FiDLtm+fn754PDvja28WR6z/Zd/BdrktiPRawW+XrTgSAbC/mVKwZ3phM7t6bfn9eLJbbJvg6XGkOvBgTwz//rV46rt8RrDydwrbA7COqIQXRUB2Kuo+l57/YtmQ93JHwpDx48HHvwdDQ8NBhY1MWNhE4XHZsUfBb6sUBVdS1b4BMEjTY3Hd89eOiW3oKSkxNZ1gQcTTTUlOG2ORwyq/1aegm+5kShaHqaoMvMmDa6D8uOFzd9mDdzxvelorJKRhBFR0WwRr4j+3ZgBBTPxkxr4ZM80AEZn/y4Z2Xto0UrdrmShwjH5tKpJqsTG6AioWzyC5wcsGmSoyGa7bqcZvU5ddJtGutOdCY9uIO6yV88yzDF+ELmMwukKMY5MlhNwDwNF0HghOwOBU60+XHuI3PaHwo2xMVov8P1WJ0C2cZ1QjYb12I3zX3cd2yibxjWjVolxrD7nF9SxfTQcZzK6pqAjG8A8wVzy2YfkIEG/XrZvm3NK6Gp84Jl6l666mT6yyfrtWSCSfYAsiPNGTW1tUw/V+cPYqzYtPBlogt/mxpKju3XIUB6QkWS6uwsxiKSPN69dSgLYqsIaHlMQu/70RAyl0NpSJ0cX2kdX04yPnXEtC5YaDqGyhdwuo65wZyFuUHH+yh3D6vOU1XoYCwggxb3NJTmwOGqPGzq4HMNxGVA883j29CQrmlMwtMNoM1/uAMUsr/EbYppLYDPDZnR3u31gVE3fW1M48k21kzvm6RJVD0+OEqraujJj3/29z2CNNJZvdoqfR0nPvvhqiqA3Zk+qg+rOOL7Hkju8Aoi2HBkkvNGzYfTl/LgwcOxB49E99BgYMF9YFw2zZi3mmVnPVBfli2XxYPwe/Lj9azBI5xf3vDxaMgO9tC0wR1Nlaalm+ZwIEumvLMyqFQQEihoEtpQmEqcsbFGmbTs1GMeoVkoMix4mbTcXAxAo1SVzIuK1IXGcCjyEA3dXDrN3nZiA1TOvU4KRyY1wlG2rS03r88C4tm1Tp10W5mpE51JD+GBk3EOyR8T0lvEhS0Y3JBGtDb7w5uPmuaBfD90cwd2EpUuKugCSzIBbZv7LeJi2DwfcFkK/eHDdUHENrRiZaCZ2si+GZSRHE9j+mXQnAW5AfZPzKKVG30i0w+BTVVpfCStYw3VP127z3EAjxOoV5/ahZorsI7OXrCGvttawOwxaBb5OfEKJjeBSPyNagVd74/ZC4J1l2EfxXGPpA1TNRQIdDfl/G6Dy6GSzOGyAeJ8dhIstB2jIeuYE+iOBwJw3qShNGvB6iDZu2mjs2hPYQWTh9tRYJYU8kgzPdw2YnZiA8MRoHArFSTOUZw3a/aslU2E9ndXVt2K5BwT+X2kpX9s1XC6wC73s3n1GP4heKyye24qLg/HtSP4LFazuc0kD6cd9eDBw7ENj0T3EBbAqTmxS2vmwFbW1rJMsGs0uui3n9WTaTtDw3TayCx6a+kaqi7cQxEx8RSZkMyygbySKg+hQOXYYuzpyGU405AV2rivmBJiooIIdADfA4nCSexQYco+gxbz5v0lWnkWnMOBkkp2DB0J4Nd1lhoCiaXaHKFkZ4UDbrK3beegk2ThOq3IWIEMjkxq8EqD4opqVqZcVVPH9M9DyYoyacaqpApMTrocFKirq6PasiKqqypnthEyI7JWuqfd6By4n3l5eVRcXMz6uaAJOuZKqID+qKkZKZpOhmszGY4Nu8n+mLJK3UhO8JJrLvXgNLAk2yNkkeqA3zERqTPmraI/SLYa58llB7gUyNVDu/j9kx7pLZjGrOoeoaRftXYAIOJxHKcBPJFAhbSWbvw0ZcC+iuuoqJsNoPz+573Ffgkw1biWZX441u4qotH9MrTa4Fg/8T0RWC/FoLPTvhlu4IYYDJVkbgzSLlwZ16KdECV1wnF/dZmwWF9/ySthVSmQzsK8RjUKMlMnPPsVe583jw9Vcqex1o6mAreNmLkNlJtSws6hhwSeCaSRGoJQpYL4OIeW+cwxfWjK3K/o5r8upt8M70XXXHkie55tk+Pok9y9/r2qLeBzOKR/TAEDt1nipmC2bl7KleYiEHBA1eZbN5/C7DqSc0K5djfVvw3NJD8agh8ePHhoHvBIdA9hQcv4WFYehn9v3DjEqIt+sKKKbv3bF7Tv+w/p7SmLqGD3Dv978WntKWHAGKqr6E9EgSXZHjw4gejYgoxJioti2Ykz3l0d3G3+1C40/pkvmcO8cPIwY5MzOHmhkui2hppj+3dgmuUmFJRW0WUvfq0lATiB/K8bh7AsRxwPEi5iACuU7PxwwqbJiteRUY/NW1WtL7ihyzLSEfK4zhXbCugGhZa5WGnAybRTuqX57keIe2KbZqxTJ51vDmrLi6l41SdU9uN7VJ632//+BQu6UFG3X1OLnF9RZHwLr3+EQxQUFNBrr71Gf332KVq3fqP/9V49u9MtkybTVVddRSkpvj4dbgCSXNXkio9lNCYLJxqyYXeS/SoHZEKRnNCdJ+4VmnDqNLChsysCwS/8vmps4zdPMDRZ/EJhq0WyQex9wDFv0qmUUhqjvEdyg2AdUSE3J8brXdskUQdBGkokUHWke1NHaUU1u3407uNa5bzcHjYXhAuaZELjOzmhktl3Pl6gOw8iBeMaVYvieMG8mjg4kwpLnRNHGK/fby0IqW9GY6EhmrzhIO0a2vBThmwnbLrYbu+viTSDXcFchs+A5pbK5qHvrWZEOhIh3JJmjbV2HK2AzvnX282Z+yaSlttAzPGrTy2nyppaVpGFHhKQ8dycV8KCz6E2nm2IVBDG6Z1//5I+evdNKv9pAZXt38Vev/8poswuXWjAeRNpbcsTqCIywVXApzGlf2xrsI1QBrEtQpVQY5uXrNJ8bDZrRCr7OcjYv/C5pfTWLaeyyiOcl5MgifjssSZ8tyWfSTZxe2+q/g1HJrnX98CDBw/hgEeiewgLxIUNGqUmfPnfT2jTX66huqoKOn8Q0UUXE7VOIsovIfr38j309n9fojNOnEtv/vs/dO655x62a/DQfKBybJ8WiHVVt3ls3k2wvd+QhppTRmZRdY05O7xFfJSVBMC17DtYwcoddRtLnvmh06pt7JJG7sDuPVjBGg0CIPqxCeJN+kSSy0mzUyebYzFDUqer65SYtm0AQ3HS8X6Pig30+XP3HrKNlx+yjW8t30L/+ewlOrjk75Q6dgr9j070+kdY8MEHH9DFF11ApaWldMHJRLNvP3Q//7N8E931uztpxvSpIa01kEB4eFFuQJMrXnX1xvKtrBQ83Ah1w+42+7WhusbyeWLugThVZXRjw4xMTw5IvJVV1bDKnN2FZew48vwqLq/yB9vExpKcrJVttZPsNd09ctOMVCToQTKM7ptBqVntmHa2isyXSfcuaQ1M0zzCAOkj6yfjPsDWcvuOOSO+z20ugjhYr6599Rt/gHPSGT38VQmYVyt3FNJJnVON58CfF44LacGRf/ki4H2nsjuNRTrrxiK/Zoxl3AfdbzWEtAtXw0+TnXB7f20wkWbwIfCeKWP6o9y9zL9yux435tpxtOLxC/tRZWS8/x5V1Zp9UpVtRMPKRat2+4OEf/rY1zOCA1nND47PoUcXr6Wu6S3YswPBvjcxhjJTE6lj68SwV3FgnP5m1gv0v78KvtVEcd+5hd5+4WGKiIljvlVCtxOPuNSPkzXYVtmJfQ6CWlhbkCX+857ioIQacV7qbF1eSYXSz+HHOlhW5dg3UNkgvkbw45mqf8OVSe71PfDgwUND4ZHoHsICvrBhcSwqq9I2/Ole/jNNn3QXnZNTSy/fUEftpSSOiwbX0e4CoutfKqPRo0fRggULm42D6uHIgjtNW/aXsMY0fTKS6emJA/3kCyepdUiOj2607DMQRmt2FRkbHe0tqmD/v2pnIT00IYc5lzKBhAxNXqqpy3TEb2S0SqBrhnUlkspuD1dJI38WyJbnzjBIMZVEg63Z6cPn92WkGewOMm9axkczaQYZyE7lx9ZpfTrNaHJCRLh10r/+4jP6/Onf0a9zaukVg2289sUKWvyfWZR+wUxGpHv9I/QkCNaQc/vW0UvXh3+t4dIlGC9yIOZoKwu22R8QlaJUUHREBMsOC5euMbKTf39eb7qlvJr9FrdZa3YW0sTBnSmqXhoBBPo952XRA5LOsTi/sNFPTYpjRKPcWJJvxGGrRUIgNcmevYbMaBVgT3UBR/wmZEnk98WMP5APsNWwG7huVOrhHlfV1NKt//g+4BqgS9tUgft9HxpAKiR2AMyJVyw2lxPMPBhxUmZrdv9BtGG9BsmGgIxunQRB16l1IruPeKbIfJUJI6d9M/y2/q0VQfr5DakAUhFfDQ3qOkFjNPxUkZpu7q8TmEizM3um0+k90yl3V5HxGPAN0ITe6W+//e4CuuTC8XRO3zp6uRHWjqMVuD/JyYcqkjDXtFKIPdqwIIYIPJOZY7NpzFNLjHrqIEixHoBIF8c7fuuR8/vRcamJYa3iePu9RfTZX35L5/Wrc+xb4Xkebn1suXfDSV1as6BE346tgnx9fA6Bx8cu6EebD5SyitvicsgXRlNxRRVVVdfRTf/vO7/9g41BDwEcT/ZdcQz0/lD5tQhEtoiPMVaXJ9ZX0dp8A50NEv1y/jum6l/0OIGkG6rEWsRGsf40KfXyYB48ePBwuOCR6B7CAiyOZZU1dMevjqeWCdH0wPhs2llQHrBh/mHDdnr391MZSfTub+soWsNZwsGZd2ctjf9TJMsE2bJ1e7MqmfRw5MCad85bGbDRBwEy79ahVFldQ7/qnU6frN0X9D04962TGrehJhzjZyYOpFF9MwIIcmxkTu7Smi594WvmCMOh/tuSX4JIm1euPpnSWsTSopW72OfkTEc4mtD+Bilx69zvaWj3NJYti272R6qkUczYrqgOllng+HZLPpOzkbNk4ETLTf/wrB6c0Jc6S6WgYnaqKXPNtBHAs0DA47JBmYwk4xsaHRHhNIsRZeOwdSB8591pto3zf1tHY58g+mj+w5Rx86te/wgFAu9nbaOtNU2lLNhmf5Cxdv5fvwogI8XMMBluxxzyzB9bvDaAjMFv3HVuL7ru1W+Y3Zt/21BmB+csWE0/bC0IyjT/fP0+GpnTntmBmVJpOcD/nj4qi/Ul4DrYsIU3ntaN7jmvN107tILSWsQxW7OvuIJlkR9Xn/mInhiQypKz2vFfVQNDTpT/5pXlzPZefbCCnWun1AT6YPUe/70rr6qmLXklSjv1+nWD6MqXl9O2/LIm39QMWsOmJnf3juitla3hNlfU38Vzy0iJpx+WBAZLzu7dljWMRCN7kdzG87h/bDZ1Tz9EArYsqVRWLMBWXzooU9s3w0/4vLWCvtuarx2LAHqVlFbVUGlFDdPzxbFs2swyKdyQoK5ThLvhJ8DlGHD+4v1Zsb2ABnVNpakjs6iyurbBdtFmZyFbZ4KbjOLcLbto4mUX+/Ypdx7b+xT4oZDVgO1aEuRj5bBnvfiO4QFa1ngWsHsmHwvHmhIRwSSfoGfP7S17/Z2VrGpUNVZM6xjGIZIoEFDhCRXwuRKpgm6//gpGoMN3cuJbfbrgEbrv8RsO6zouJ2fgel656mR65jOfTKpo556eeALVUR0LfEMCC81SsebwNQvPZ/b4HFYtV1rpk+dBgs37q3fRjNF9mGa93JBe7Bsh2oWp81aytVMXTPEl+JQ78g3cNkJVVf/qklhA9iNoCsKf+9nhriLy4MGDBxEeie6hwRAXNZ5R89qXgSQfshY67v2GysvKWCaAzpHhwPsvXldLmXeU0uuvv063335741+Ih2YNfxaEnBmzIY/pZoK8nja6DxGtCSDSuT5fQ5qKmprziI1+4BiDBA8gm3qk0ZBuqYzkwcb/5SXqhnoorD2xSyp9s/lAAAHGNzIo6+Rd7bnTiWtql0xHFDxjG5mlKnCbIgc/3r9jOM1ZuEbZCHbqOyvpsQv7B5AZYiWBrbGqqrGhLyvxJ6VUAe61TESonH2MARA9yLvFBod/FrqrKBtHxrQT24jsuE63V1Dxqk+pZfwo8xeOQbi9n6GuNUfjJk11Tqayb9g3SFuJwJjFxlzMDAuVlML5gPSWN+BsXtQRXTO0CyNfQFJjE/3d1gJlVi7mGvoXIBCoa8AMW4AMNSYZIvgjONYL/9vE/v+RxbmB8gI92tCtZ3ana1/71h8wkMvLMZdN5ezb88to0j++Z98FES+ed1pSHN2raVg9fd4qeubygfSHD9YdddULboHGxyaUVKj18EXyBZmVs8flMOIG93vOgmD7/vHavVRLdayh681ndGe9B/AMQMTJQoKxUZHKigWQ2JBcUvXN4ECWLQh0/VhMpT1FFfSXT38OGk9zJuQEBXFNpDDIyFCCuodLi10HEJW6+4MAE66rTwcuZtQwyJVdsCu8esZJpYkT4JhX3vs4VVeUu96nPPHMizThN9cfNetAuABdashq+Bs/xkezhJLa2jr63b9/CiIzURmI/9p8rC0HSv02U7S3XxjGu24dY4Tz1ScHSUlhbeu+939UXlbq+HnCt8q8o5w+fPff1Psw7TtVGdpYe5/6LNC2HPL1I2hk3/Y05Z1V/tfFe8jXFqxFY57+MqAyanTfDkH9TzCPTOQ2AoXTR2fT7AWrg4Ips8f3pfdX7WTPAMBaLla1NaQRqlz9a6qm4WsG7BDGCAKtDyxYQx/n7vV/zusj5MGDh3DCI9E9NAjyoqbPqNlHRa8/TRcO8kX8nSCjNdH5JxM9+8xfaPLkyax7ugcP8vjbV15MhWWVrKQQGRZoNiUSlG6yIOB4gsy4+9zqgA1DfHSk1jF0AnyWkwOqbEaeMa4iyLEpQNbdK9ecTNsOlGk32/jc1UO7+rNWRAIMzmOP9BasgZ4tK+xIEYO6LCOdTUF2q6kRLIhw0VnGc+TZNDadY74hsAVg5DLUgrJKo7OPv7HRg7OP5qdw6DNaxbPGZdBddWMbJ5xM9MnqhZSW9BdnXzpGAH3tUO6n07UGzxZZtwDIYZW+85HapOmytGDTVJIICOqgubKq0ZgqM4wfz03GNMhIHemNTGJkKD9Qn30ec1qkdr4zgvzdVazazYSD5dW0cKWvIa94LJ1cFM4BpKxoL8V5/ePWfEprGWssZxftifj/sDfFlTVGOzU1KrJZ9DWAfIAJkBkwv++z/5DHGd2vA+V0TNbe80/X7mNZrJe/tIytodyeghQX5ynvgSECf2N2W5tKllUZx+LSjQdo4cqdyvE07Z2V9KgQxNWtqfz3dQFkjoZWG+H3dZUWHKHoP0OOTXd/cI+fuHhAo/gTyqzdq09mPgFkqHhmPAB5H6dAP5lVH/2TLhgULPlhXItPInr8T0/Qa0VZbO2AjXz9usHUXOBLtjiURIJnqstcvn/+apZ0wvvd6CDaSdmPEse7OH4QtOGZ8eI6hsDpM5/+HJwg8/N+Wvj6XxrNFwgXVHsTjF/MUV3vDwQRRcj3kK8tSJ7hAd+TOrdWrt02chu/+3Hubrp+eDeaOqoP860hHwOJyYue+4p6tW9J/7pxCJuHcrKLm0ao8topV/86zWTH2MAYGZDZOoBED2dljwcPHjx4JLqHBgGLGpxWvtCnt4xTbnxqy4qoYPcOuuBid8e/4OQ6evOpjXTgwAFKS0sL34l7aBa4660VtGy7r1xRJKWRiQi9YpHMcpIFAcezvKqWemckB2zY5A1DKGQZHEyQAzybUS77N5W/YmO+r6iCEmOiHGVyiA4lJ9GgE96ZkoKyuMSNbSiNx8K1SdZlGenuC5oZyRBLy1HSu3Ffsf98sAmcM74vc/JNzc/wOrIbQ3HeK6pq/ffD9nlcExz6+3/didat38gal7nBRYPq6K1lOyj/wAFKScpw9+VmjLy8vJDup5O1hs8P6Ip+t/lA0KYdYxfv68rRGxOmLK176jeOsiRCTW0tjX/2K6VkiwqyrrGTuQ8y0gRfFrEv+xzzzmgHkXE2Mst4vJb1+qzAwPrMNMB0XFXAgGe143uQpAAZAUJFJiDFSiLx/0ECwN5AAsoEPItWwnrTVLFs8wG9VnmPNrS7UK9lLgZmMH6c6FyLa92tZ/SgywdlBow9lQ0W14edheVUXl2rXa/SEmPp3Ox2TItdlJzgz71tcpxS3gD4QgjiOllTnTS+NcE0D5008gtVSghScLoAEeY0jq3KVm5IoFFl5/A7aEg7a2w2PTAum2bMW+VYW168d/v376fyvN104eXuzunCQXX072W7qbb8IEUlJCsz4psTTP4Nb+SKbGcn1ZcqG8zHu2rs/jqrLct2h5+OpAX4XCmJsTTl7ZVh33f+d8UmyuzQrtETScS9CbdRWMd0VR54vbq2zrqOwUcWq0/lwCEf+7akEkj0fLUxj4b2SKfHP1jLgpgi9m/Io7W7iui9n3ZqfSJkhtfU1TkaE7rqXzeZ7LDN2AuKwL3tV9/IFj1QmlvViAcPHo5BEv2ZZ56hxx9/nHbv3k39+/enp556igYNGmT93r/+9S+67LLLaNy4cTRv3rzDcq4eAnGwvJLm3jCE/viBr0EMMl1UqKvybSTRDd0N+OcPHjzokegegrB0Yx5Fxh3KNOIbOmSmyRkHTrMg5CyYcDTjwmYAGcgTB2f69cwReEIGGt+U28pfQUZBw9fJNfCNCG+wFtQsTSEzAid39ntrXF2rLOUE5//UbmkUGx3JskjcOKi6BmI6tJTuhZPmbMhShmPdoXUCjR/Qkcn4yOQC3pdJdCfO+9B6WQw4/k6dfVzntv4tGmQbfzf3a3r6pvO8EtV6FBcXN8paI9oCZEOLOqUi8D6yrw/3xsyJ5jGIDZFc27y/3Eigo5EjbIhKh9hpwA1NwExIjPPZDcxb2G2eQaoD5qZuI47X0ZCNHRcNx4Sgo82+yu/jWuOiIulVSZpOJCBPzExhDZpvm/sDI4pnjctm2awgX5GlB3uDjboJoWQAH434+9eb6Zmrh7H/l6ut0GxwZ34Z09Z98uP1ASTMcAW5g/Fj07kW17qY6MigZtKyDXbTvBNje+b8wCoTmXi2jSfMGTQxlzMz5TUViDaMaRvBbZqHmHu2Rn7I4A9VSsi0zuHY0y3XHspv6uwcngkkQub/uMPxb8r37sGz2zZo7aiD/nRC0w+I2WDzb3gj10cV/pxYfSkD83ju9YNZZenPew6yXjhyg2uQ9Jh7j1/Un+6v99/+ecOQRtl3/ua5zym6VTuljQhnhQXfm4g26pw+7ejPklQUwP+GLVVBtEvwkXXVp+LYx17ElFQCctsnI7OO+memBJHoAJ63tuLs5/1sXbzyleXs+rAuyv1REPzKK66k0X0z2N5BJZ/pJpNdvheHo3mzBw8eji0ccRL9jTfeoN/+9rf03HPP0eDBg+nJJ59kXbHXrVtHbdv6HBoVNm/eTHfddRcNHz78sJ6vBwpwIpABMHXeoSZfuoh2RIxvQcwvcfcb/PMtW7Zs4Nl6OFYgZvqK2oomXWAxC0IkNUJtxiU62C3iotlm4MdtBawEfUTfDCa7gkySsf06MJ1BOJ+2bBC8D5LWaXYPJG1k7UOTzMi0d1YxBxmas06uVTxWuBxUVQMxaDOrMgkTYiJZI9isDq3Y39BFfeLDdcbmbPjMzPmrWTbKmp2F1L9TCl03FLq4MRQdFUH5JVVMRxdl6m6cd5QZ840hGt+5cfZro+MaZBu/2VnulagKaNGiRaOsNaItqK6pc62pH06oNvDFFc41j/ncxfg3ZQdjLhworQwiCdwEFyEjYdqg432eJQ5JlzduUhMiIomuImd4ph1sBP4fcxyZbxxO7CuA70MjfUR2RpDGrth/AuXrq3cWMbmIZycOpG+35tPop5b4gxI4B9yHkvpGb7qmbLAdzQFllbUBjaxF7fjtB0rp6le/Yc/77nN705VDurBmnLj2zmmJQQQ40LZlHMs67ZWRHCRnANstrnUqqRjZBjtt3mmS7sJzR5NaBNBs4ykpNpo27CvWEkvwCfJLq5hEEYhCrJ9Y68TzU2WPirDNQ1RSmCqi0FjVpAtvg2mdC7V5d0MIXDe/qbp3G/JrGrR2RMQeG0Sc08oJlfb/gpW7tA2royIiaOJLy7SBKzGbGDrdvMG7zoY2dN+ZmNSCbqyvskZlDAJ7sEs4l99bAshuSHa+N8F1cRuF6iddlQd/XwVul7C2tIiNoixFlZM89lFhg/vMj82BwDBr/v3aN/6KWFlGhsPmE2G/g/vG14hJZ/Rg4wHPjhP8XdsYD+F4Dyffi8PVvNmDBw/HFo44if7EE0/QDTfcQNdccw37G2T6woUL6ZVXXqF7771X+Z2amhq6/PLLadasWfTFF19QQUGg4fRweFBQWkU7CsoDFiWdTEJkQjKltO9Iby3fSRcNNi+2Iv7zTQT16tmNUlNTw3ruHpo3eAZCSUVVgDM7bVQf1ixs9oI1AeX4nAAFQQ0yFd+BQ2XLuJGPD4cQxBO0WOUMZ2h2Prp4bcDc4KTwzWf0YAQvnFY4qjoHEc7ue5OH0az5q43ZPTx7jZ8byl6TYqOZZqhuU21ykFW6rCKpGE4HVdVADNcD0kEk6nu2bUEvXHkS05nH35Bb0BEWYiYuNjrQsp44uDP957ttLOMHOsogPuHUL9+8n15esilADsjkvOOZlVf5NgcYUzzrx6mz3ymjHfXq2Z3+s3yTK9v47+URFJ/WjiLjW4at+VxzALLIQ72fXbt20a41ASXXcZbsakv2dUMAQnLK24EkH28UjN9VkRMYjwiqoeSa93q4+tQuTL8WWcJBm+fj29CkM3vQiL98EUAKc5LATXCxuq6ObjuzR9BvYB7cdubxFCUUfeC3Psndy5opq+YyzoH3u4BNQWNHzFs8D2Sdg2DnFS2b95ewoCP3R2wSTngf9+/piSewaqHe7ZMNWu55dPXBCiYhwBqTntWdES1/uKg/syGQcDmzZ3q9LSN6cEJf1uxYbsqG15tLBtyp3dPo6+3BPTtwbzl8934tqziA1jyu/ziNZjXuHUhgrKXiMXHf0OTu8pe+9h8/NjIyQLoLkG2wU4LVNLbx3H8/ojdrUru3qFw7TvH67qLyoGx1MQgcExVJuwrLWCALJLoYgOBVICDsTDbdNg9tUkpYtyBps4vbhYRo1hjQaRN10zpnQ6g67yYCl99v8T6LwRf4a6Z7968V+ZTZpQu9tXxLyGvxsQBTg0/MWQSDUGUJ8hhB0uraWqqsqaNWCZH00zafzI8MzOulUoNrWedbl6zx8IQcpe/M953/cbnvxPNMaNOenrn2NHr1q81BiSFYG+UMedHXReDUjSwi5jgkarCnzu6QTL/9dS82F5//zYnMTqh6GOwrrtCuY1xKTFcFJY99kdyG/UESCQIGONafP1nPzttWgWPziZBMxP0T3E/8Q5WbnOgTSrWqqrphmORnN1ZQz4MHD8cujiiJXllZSd999x1NmTLF/1pkZCSdffbZtHTpUu33HnjgAZalft111zES3YSKigr2j6OoyKyz6ME5Sip9xJMIXUQbDkTnWyfTo/dPod0Fzpq87Monevsboj8+cbvXVPQYh9t5jAwEOGzJCbFBeuYgiBbePoy27C9lmYq86c4JmSmsyd6IP3/BGvDAWTNlCaqOzyVaVCWYIGrl10WH8s0bh9C00X1ozoI1AZsB0UHE55FbgVLW/BIfcZ8UG8027HDaub7pYxf0UzryIJqN99lQoi7LDoikYmM6qNxx/nz9vgCi/pyc9gGNWm3l9fmllYyQxyYGZBcyme45L0vb7BVEOz7HSX3Reeeb9FO6pbHsqbKqGvb3ul1F/tJ7kJrIMvzC4OxjLKKPxC2TJtNdv7vTlW185xui5DPH+m1jQ5vPNTYO11qM+xHq/ZzywM20aV+JMntMJm9MhCwvlw43Qbojv5TueXuFMliFsfbWzafQ5rzSgAZkGKv/uvEUuldqsohN5ktXnUzXv/YNjTuhY0D2MMi7S174OmDTLpIEtuCiOBYxP6BfO6pvRsBvgGgGiQdp18y0BGaboDNdUl5D5+W0px+25NPshbkBJH6AHntZFc1asDromh6e4CMPUhJjGCFxXnZ7WrG9gJ74yEcGqLLtQIog2w5zGPcMZPdlgzsbr5HbG9jqW87o7tee5ecKXW+OzmlJ9NiF/dk58wobrC1NkUDXzWPoUT/40WYruYF7j2D2ZSd3oo4SgS4GpBFURnWUPNbxbNCI9tJBmWytxfF/3ldMN/39uwCiSrbZTuRX2PVYxjZkeqaNyqKTuqYyCYNaxXiaPqYPTXzxazZeOXQEoJhtK74Ogsm2ZtrOVSWlJBLMVTV1LPgAvWNO0nE94sw0ZxoYU0dl0VX5ZQH9AtAzomPrhEaRMTIRuHjupvt84cDjjPeurKqWKnqeS29/8kKD1uKjHaa12EkGtYrM5M1dn/l0Q4A+OaoF7zi7JxVXVFNeSQVrJD2yb2FAIovTBte6ZA2sE69cdTJrNy8GtXDc7pNvp4dm3Ov6eY6+6RpGoKvWWuwbxEbU4nsgwqdJfp8TWcR73w5OvIFtu23u92xvImfkt5LmD6515phsqqr1rbWJ0ZFa+6Ea+3wvAkCWddI/vve/B9vJr1cnKQlJKpNPBIVE+RpC8Vl5dQP2PDsKypj/vHJ7YcBxcS8eHJ9Djy1eG3ANJhzt/rMHDx6OPhxREh1NXJBV3q5du4DX8ffatYeMn4glS5bQyy+/TD/++KOj33j44YdZxrqH8AMknVzSyiPaz0w8gaaNzKKq2jqCXwmZhLry9vSnRx6ga18so/m/raNoQ+C6uobohpcjKTExga688srGvxgPRzXczGOejYGMmOnzUI6vkC6Zt4omn3U8tU70OYRwyjiZjjHMHV6Q1bpMK9XxTWSyTeIhMjKC4qIi6MEJOcw5xNzB+aFMsqismjmxm/cVs8yUu6RmXXAa37jpFMIWDpmagBw8kKHK1mqfHKfMZlXpsoqkYmM7qHCcEdgQN2fyvZZtkXx9yK7J3X2QuqQmUvt68gobFJ3mJLIlRfKfO+95JZUElYj75wc2L+PkAy/1RaYSPg+CLTIigmpq61imFR9jnPDD8a+66iqaMX0qXf9SGc27s9ZqG697KYIiYuKoRc5ZTUZb+XCuxaHcz+i4eOo8ZAT96onP/e+JpJxI3ny2bq8xu/qj3D303Wbf8w9XdhPIjS15pdoSb8z1q08t929+OTmHrHPoO6vISEhJ3T82O4AABt6bPNQYEHPTCBHzDtJLKCuPjopkwSzYNDR2/GztXhaoQsbsKxI5gmzeBZOH0bYDpez+i1m5IOCRoSxfE5oZbi8oo2ffCbTLONbc64fQVgQhzuvNSuHr6rV7V+4opOWb89izEhuj2+Q6YC95Q3WQZyCQOImI+4QgHDKtyyprWMIB/CUQEL3atWzSGW+6ecyzUPEs0RQPFV1oJgqilgcn/P0/qmqooyQzIOtT+yqL9FIkIOMA2FOuLS4TVaKcRAUmuoMxaxvbbZPj6bjWCfTXzzbQvSOyaM64HCZNU1pRQy0Toik+OpIufG4p+02x+kFHAMrZtm7WTNu5JsVGB/gvToh82IX73llJf7x4gDEjXddbZf6tQ2nhql20eNVuJammylZuaO8UTuDm7ixiAQ7dfYY8Ex8bunsXm3Um0eev0XUvVdK7DtaO61+OpOi4wLVYrL5oSnN4V0EZzfko11EGtSzVggoG+NWYs9z3OimzNWWkxNcnhgTadiSyoPFlUlwMI6XHP/Oltj8H9y91/jVrLPvaN/TOpFOpsqaWSip8UlH4l0i96clHHnDtW911641UERnPJBjFoDR+S9WImgO23o0EpE6SSWUX+P/jmSCDm/crwRqLClhoyeN+yvrnDdUW59fLkuHSEoP2RPBlEbCbfObxAecu+0TLfzkQcD0N8VnnLPSNU1wr5v6LV57E9lhcQgxBGgQVfntOL7bO4xmaEB8b5a9A9uDBg4cmIefiBmj49Zvf/IZefPFFatPGIp5VD2S5Q3NdjLh36tSpEc/y2AE2hMgOlR1lOBnYjGIz9fRnGwLeG3T9g/TR03fR2Cdq6eXr6yijtToTAAT6BysjaOHCtyklxUH6gIdmDd085iXkcvbGG8u30ph+GQGkqwiMyTvP7snIHJlA4oCTWFxerSwfhBM5MDMl6PhyI5ubTu9GZ/by9XZANuZ/bjmVvt60n+kD5nRoFVBqXF1TyxrqcCdOJok46SpLxQD4GxIvfIO4cW+x0pHnm3poD6s209gEg7zAPdFlgHKIpKKNcAoHwYtMJhEycS8SFjqyAPfw/rE5/mwrnVwD3zTIRAa/ByxAoSAlsYmE5j2/95P/+QM7j7nLtlCfeu12kIawndiM8ExM2Lg3//0fGj16FI3/UyS9eF2t1jZik7d4RQSlX3gfRca3cNR87mjA4VyL3d5PrDVPvPw6PfH5joD3ZVKO24LnP99E/TqmaLOr8T7mTzhLhH2yTGZiDXaFE7sscBQbxeaejnjHmL2nnozkwBxCZpcq0w7AnOjaJkkbXBTHopJo69GGfnduLxYQRLUG5CRA2snn+EU96YV7Lkt+oApHdU3snAWfQwykbcsvZUTPh2v2sIqRORP60t3//ingGsTG6Cb5F9jJrmmJ9Lclm5RkJMYI5KI27SumpyQfiDfSbIpZ6KZ5fNdbK2iZYi3mVV5iFiKIU1XWuUia2wKz2w74pGNEKR7+rNfvLWbHFMlZZIg6ad6J/5r6jnywejf9tLWABbtBqMvA2ovrkiszTQF2FSnnZM00yangdVRjiP6LUyIfdgFzTEeim3qrzHxvNQtAq6pSddnKDe2dwglcSPWhp8J976yykpi6e4c19bRbHqEPnvotjX0iwrhPAYH+4YoIunr2U3Tp+DMC+gA0xTk8Y/7qgDlsy6AWpfeYz1lPoHPfC/hhSb7Gtq+mpwV/1dTgmvuXWimR+rmP99HAEn0q2iXzoGsC/fVvc+k3l0ywPk/fvpPowedepeeX7gqpsTCCpSaYZBFNdkEksrF+IFiHFup19Qk4mOud2yT57eqm/SXaAJVbbXEO/G6Gom9RXEwkLd+Ux6pPRvftYPSJ+PWINtdtk1bxnqEiSZbJ5MA54FxRMcRlIXXXvGDFLtZk2Wsy6sGDhyZBooMIj4qKoj179gS8jr/bt28f9PmNGzeyhqJjxozxv1Zb61vIoqOjWTPS7t27B3wnLi6O/fMQfiAzDBqr2ChFUkTABgjE4MPvBy9sv8QfT8Nu+wP998X7qNPt5TThZKKLBtWxbuho5gINdEi4IAMdBPo555xzBK7Mw9EG3Tx+/MJ+VBkZ79PFjfVp4uIfiEo4kSbgO3sPBusKioCTiIwP2WmE86c6vtic7pmJAyk+JjLIwcMGHVms17z6jX/jAHL37Kx2LMsZEJv1cmBjuy2/zFGWi67Mm29sR/ctV26m2bHr6mjR7cMY6cCvVeXQiqSiiXAKF8ErZ8/IxH0AYZHZWnl9uIfIIEcwwlYKDwdcRWRgzJieAcqSVVqTIFGQGYUNv+qeoqH2ggUL6eKLLqDMO0rp/JOJLjg52DZGxcZT+oVTKKHrQEfN544WHO612On9TEhIpFf/OZceXhmr3MiL80okb6Cv2zk1kTXe5PqkyK5GhlRDypV1wHg1Batgc45v24L+39JADdd/3WBu1FlcXqMkPnl2rwwmRaLRJhXHopZo27Cf6qiOHjnftyGHD2Ei+RHIDL4Xwa/JRKUpkIaKERCE8jWI99fYbO2cXjR7YWB2pfg53APoXS9cuUtpY5tyIzPdPF66MY8i4xKtmZQIYCBrUqyUUmWdO2kEy8cr7qeusfWc8Tn0wII1TLLESfNO/Hf2uBytzBcn0UDaqp6hSFCJ9j8p1rzdEkk51ZqpI5ps8xCa/GI2vlMiXzfHnBJ/ss4y1r70FnH+bOVw9k7hBC6wPT+QBNbJupnu3Ywxp9NZe4vpo//MoU63VwTtU95a7ls74hPi6cHn/0bP/pxEH0nJGLARTX0Ou5Hk4/6UGKjBc9eNty8cBDQAvN4jvQXNm3SqMpvY1tQegeT3C9pRm/Nn0kfzH9Y+z3e+9e07//7GXFqY39YaaFLZJxa4sjSKNski2uwC5hDmCOaWXGkq2rqPc/cG3QeRGHajLc6BHg28AbTctwjzD39f8+q39I/rBzOpRA7ZJ8L1iPZJFWi3BdVCkZJ0cs04x6a8Nnvw4OEYItFjY2PpxBNPpE8++YTGjx/vJ8Xx92233Rb0+d69e9PKlYGZn9OmTWMZ6n/+85+9DPPDDCwyyCRDthgaEqK8dsuBUuZcVNXUMiKLR6TFcrhf6Hj656c/0jVT/0gLfpxPby3b7T8mmohCAx3l+K1atTqi1+fh6Acry01WN6ZJjj/kyOngNINadhp1x4c0AEiW/pkpRhIFRLVILoAsqqO1dP+YbOMG1ZaJykk7mXAWs/RQ7jogszXtKCxnGekycQhiqKaW2GdsECVOJpzQkTUqlJ3hcBG88kZLJu7FTfuI7PZax5oRc8iGtGT6YTMkExlw+LceKDV+LyY6kpFCst3D+WEjaGqkBOJ3y9bt9Prrr9Ozz/yF3nxqY5BtHH/RZVQVlRAQ0PEc/tDvJ9aaTYW1VPrdV9rjiGS4TN5AukGHcErsYLx+snavNlg1fVQWW4vF5pVAUry5jLlVYgzLwOYZlKZMO5Hck7NB5bFosmM4R8yjlvHRRrIOUL0PiRqVHBXkr7gclS7rlleM4NxVGa08C1kmAYG0pDim64ss3U/X7rNKjeiCA8dKIzM5k/LWM3owLXRZ/1c11myVAKh2hI/Jn5GusTWqHLCWgVhy2rwT42h0vw7sOSLjXZ4bpmcokzVca/jUbmmOfBHVmmkjmkzzkJ8T/kE+RYQ8h3AvUMmC9QpzTAenxJ+os4y1D5UyOomehswJ8XwQoLGd26JVu1nPAvnecVmMsuoaiuw0gDJufpWKV30atE/J7NKZBlw8gcZdPJEik1rS0LrgbOvmBIwTBJ+w3umyhbk/JZKaTmX+bMEgkLcxBZHKymfT3MecmT0um82bhG4nap8nmsIOuOgy+vsjv6eYhBZ0nyDpprJnsD9yAg4/V9wrJ1Va8n1zskfB+gRALlCluS7aOvF1FTGsGvvf1jc4Vsk5wjbogDGBZ43vgUDXVfcCqGLj56ILtNuCam6kJFliUn3TaX7NuwrLWRKUG7vuwYMHD0ednAtKyrCJPemkk2jQoEH05JNPUklJCV1zzTXsfehhd+zYkWm4xcfHU05OTsD3udSH/LqHwwMsStD93Ly/mOlCQo8VTsT824Yxh12nuxiT2JKSTxpLLU8cQ7XlB2lgRjzNOv9E6n98pybTnMfD0Q2nJYuhZlCrjo+hO+nM7qxZHkoYtfrFG/Loaql8G5+FbnZxVXWDSX/x3JzooMpOs5sMWpFUfNqymW8I5I0WzxSFteDEIa4DJZliUz8VcH5o9qcbH8hWhdyKSrvyaiHTXAU0UrxS2ESI99kJqYo17fbbb6fJkyfTgQMHWJC4ZcuWlJqayrQd3ZS9ejDfT77WJFegMFoP3XOzZdCJ9sNtybLqt5DFi6wpQJZ6yjmuFU1RyBigESLel8l1/j3o4IpNxDjkjDoVuacKLjol2hAQBBFhIusA1fuQ6kCgCtItAXJUPdr455qbDDXxGnCNfGPPSUDMYfTQQBYrJJpQ6WTL7vcamfkg3gesX5A1k0kT1bpmalKPSoJZ762mj+rJItOzxrjnc0YkdU3NO/Ea1pDcXUXKuWF7hipiu0V8oD65CJByIPRxPvKa6ZRocmJLRPLJ5BdgbmGOOTmOCqrniXvgpiGxG4jnA78OdkBF1uPa0JcE40W+d2KgAtfvs5kUsE+pqyyjIb060vmn9GZSPr6M3f3KcdpcwMfJA++tDqi8EYM4GKMg2XHfQMZyuJH5MwWD+BxAnxn5XpvmPp7lQUEGEFI98vP8w8TBdM+CX2hfRAQ99PEW+r+zfbreJjxWT5YP6pKq9HVt1SGh7FO4P2ELTnNbJ8IU8BNfw7N7v3NrR+ctzz+efW6rSu3QKt5RoN1EZruRksTzufj5pQHjFQR6KHbdgwcPHo4qEv2SSy6hffv20YwZM2j37t00YMAAWrx4sb/Z6NatWyky0mwkPRxZoCwaes6Qf+CZAbMUjczEcji+8IHEOKNvV7oKkjAJsR6B7iFsgPP1kEJDHE2NrhJKFk0bdWQx6LQFVdkz0DlHFsZzV5xoJVFU72OTj5JNHUwbRJG0E8+tX6cUVw3NGpJBq9rMN5Q8FCFvtHA8NECD5IO4mUGmiQkJsVE07Z2VrPwVWanipgGEBuReuF45B3f4+3dK0TdMG5XFbBsye8UsdKJfWDM1J7I20JBEpisycHF9rVPbU1pyPO3IL2WNJUE+4tjISgapOmtcjqfh6ABYW9LS0ti/hpDhIpzIKZia8KGpJ28GzMkC3VzBf/Gs0bBSrPKCpMz7q3drZQzwu/+4fghrIioS6bw/wKUvBGfS/6p3OgsiLb5jeP04jGZZcKZGg6EQbZDU6pSaaCT50SdC9d1nJa1xUSqG6+OaYCJAEQwEwc9lwpJio6mytpbGPe1rfmfbuIP4L600Z9gf7Y2AwwXxXuGZoPmdDBXxwisBYDdRoVVSUR1AVmEuVFT75l0oa62NLME4wG+G8gwDbXg0I9Axd1T+iJhtq0IoRBPsCMYv1grIWYAc45VV3M6Z9NHRCBtzQAe3mspOJd1CnRPi+WC9RYNJyFro5HgQBBPvHe4XspwRIL9sUCbLRue2FnYJa0dUQjIN79uNHhifzezB1HdW+pMPVBUOTRFyjyFbpjfWvYfP7xtQWQIincOtzJ8uGCTOAX6vbxjWjVVRoXGxCWgyKoM/T0pIpuxux9HkX0X7G0LfNzLLeDxR1oSDBYfqt66y7JstoYT7ELJ/II5X0Z+wyVSGYus4dOcNmKoQ8Jnlmw+wczYFP2UyPtSgmlMpSez1UB0sBx3dNEb34MGDh6OWRAcg3aKSbwH++9//Gr/76quvNtJZeXAKEAT3/mclk7DAYmZroISSXizEr183iJXNRkdEMoe/VYKXUekhvOPy/vdWM9ITmyM4lyCokQlx0fNL/RsgOFZw7lC6jQxCjElseh9elEsLV+426vTJTmdVbR07LuSMnGi6ysD5mTaoa3YWsqZ8tRSs64oNemFpFe0oKGPNjbBpfvyi/ix70k1DM92GVyT4WtSXPReUVVKLeD0xHoreoQ2qjVa75MDPoFmhiZirq/M1JNq0r4QeGJfNNmIySSODO/zmhmk/0xdCNrCYhT5jdB9r8GBrXklQQ1kQmjPGZLNNu3g9fJOFjT5IAS8jPXQ4JcNVsG2Y5UxSUUJh8/4SSkmMZRl2g7umsl4IprmC/+JZi78FUhLzWyQvROCzl7/0Nf3zxiGsOgakAuxMi9go+mV/KfVq35L2C+PqrN7p9Pvzsti90GUeOoGtQSM2v2P6Z7AGabPH59CMech03B+kXY735Q28qSkw5sgtZ/Rg1+p0o6wKXhzfrmXA59ftLvKvGbaNO5q8rdhRaCSQsMaYiInmAJHEwL34ZssBGtuvQ5Dc1b+Wb2VjCxDv10mdW9MZPdOVBLM476D1bYJuLbaRJZirunVEt06qbDiOgYrNxxavDfBHeINp1fXxMYlAPtYWURbMRDSxNfctzN1AQg6VFAi48UoLWwYvb46qCurp7CXm+61n9qBrX/1Ga0N1vs2vs9o6nhOq+frg+Bx23/GsdhWUBwQaZdkGPh74vcsvraIFK3YGPLMROe1o5thsVjlRVlnNiDcE9HggUQzi8AoHW0DkaMessdn04EebA54PZIhMFT0I7Is2XrSNbghVE0SyFfcaxx1wWQr94cN1Qf6rjOjICK0d5o2CUTXN/TT0VDIF1Lmsic23dVIdgnGM+V1TW8sChWVsfa6mxLgooroI2llYRv+fvfMAk6s41nZvlHaVc0JZAmWiJRDCRAMKRNvYwP0JJpnkSE4iRxsHwDY2xph7wdjG5ByNydkoC4SQBEI5rTan+Z+3Z3vU09Pd58zuStpd9XcfXbwTzpzQXV39VdVX95y0l5QAVOMOm+GSCwQ23fhsiGF13mqOfba6VO5n3vx8Xep3TF+Az2OnpVTLK59lBJV26lYk+nbekoGu0BQyO0pKkmd7zoEjRU1tvawuGD+gi7xnK0oqZUJAY5ImAgICAlociR7QeiEJggaHff7KEunsV0R0J8dJoYP6PW8szmi4iGMVsioDmgqduNL1AdU4+/mhu4hLH5ktN8k4g/camTZsepFbeXXhmjStPJtOn6mRrDYSkPU+osWVreVrgHPCpMHi9L++LwlgtUEc0qNYOtabKmvEjU/PTyOXuNYfHzwyq4Zmts2NbcOgSNzj//SuJDtMgk1/Bqb26tJ1ZdIOxMlsjZPJbvsM2eRqU60/1+uOHi+zcnVN4zgEoXL4Ta1krodNwm3PLbA2GmS7fuY3h0XaRbIXTfIFjO7fRWpduioJIAuChmPTkU32mAnfhlnPonNJKNx4zDgZJDHHj83m2Jp6RRG7EOWP//fr1G8qgvqHD3yYNo4VuXTtU3OdmYcunVLbHLy+oUGjLfjzrw+/FHV1fcXP//GJlKL58SEjJQEHkaayZ5G3sjVQ+1GETUNaAM1s7KyNbMcu5uflyHMm4BgV6ONzHy1LJ4fuPGH3jIbqqY17Xb3Ye2h3SSoA08+hAubyR2aLlxb4G8C1JuwzvId4V8tiVfeCYMYho3qJ/7fPEFGXSEjdfv2Z8Dm13v3sWzvLzPPK6rpY808nfHzSXOZaC/g8BBsEmm1d4Zgzn5gr/QByXU3/gPljnpvLhjP+L2/QKzYJSc7DnFOu9dYmv2YGg0wCHajzQed92ri+snFqVLUWAXKSEMx5wXfpq8KzZM5eNn20lDBjPaeiBjx53hSrDXX5NhDoPPcL/vlJxu/Rd2mTFqx3zVdsxzeGdpe2hQzlT5ZttJK/eqa8DEKWV4srjSay4Nk5q2QlAevrIaN6i1H9OjtJPOwU/6g+QdZSNS5tbehnWQNtlSO+Pj0mca58JZKnCvNzk5U97ZI9LaKg1hS09PVAkp4dz/PxkeRvLForxwTVFa5MbzWfOC7juLFNs5UOO4HuKN+WOY4txJc3M/3Vuf307/+V54bME4ki9BGx2U9lF/YY1FXON9UXpLHEMBJv//50jQwYKLKe/cxdJ+whzn3wI6svwNjhd288erwoYx40VNXaek7ErQD02WfT/k8b3y8VnFRBs/P/9pE8xw+WrBe/fumzNHtjq0Jtzh5OAQEBbR+BRA9oEpIZYUmSDMfjlucWRGcG5OVkEOjg9QYHhDLSsIgFxMEnX24Q/XvnZjhYbGz0jC89Y4NxdsX00dJhckmdyBJekSMdsPOzaDqjnEJ+B4fzvANHWEkUXj/Vk62lE3pkkiMroGdS6ZvD/1xwgNhUWSuuf3q+dU6dvf9w7z2E6KHpl4u0cG0YTDkY06lW5KGLONSDZi6iPE4muy3zTn3m9uN2k2MBqamO7fNkBrpJoMchCE2H33wGD54+yZkZy+sXTR0lS8B9oPzfthGMquzB3gYNx6YjKljTWFkiPYvOVRrPhts1fhhvVJesLau2/iakM+MP7dcjd+0vrjO0a3WyQLdvkFHmOAZkufkaYpLJxZxSEjTANU8JZJEh+tXGSmnD1Ob2wXfRnt1ZZhISGOSe6JtcSVIeOyGpw2shKn4YYdN6dmwnXlmwSpw6ZaggRGgSFCdPHiKm/uZ1Sdw9M2tFBulokiE89+uempdGDpFhPXV8X9lUXd+4n/bX98Weg7qKPYeguS/E5dNGSxK2ooFUYOyYBLr+m/972iTRGnHomN7izIN7Zd6Lwd3kPYBkvPHZzDVK/Q2Bjs50dU1drKbWcStJIEt4djpYe845cISY+tvXU2u7ua7wzAnAv/X5uoxAE9cGkRzXhqs5x5jXG+Eqn0T3KeKutzZyTPnjvrUCW6L8cB+qLNr1NB4kO/auVxelBcbUvdPJcmUvk3J4W2yXSy/eJNABz5IgHEQp14x0yDOzvrYGGyH1+RxyesrnEIJGpprvNaKnuOCwXeS4TNOY1irKzGbFfIbKOxu4Hhepf38rncdmkPazVZuzqvLQkwyY99W19VI+jyAk89A130z4AklSbqhhDriy3XnWV8wYLVZuqhL//WqDtAPYYFdDSVUlrda1xjbN5nUC29g727UxL/BHr3iM6u1ubkklkSMePGOSwMzk5giZeOJLpmBPg/38zUufZtiIbIhhzm/p+vKMygzuPfuWs/YfJn714mfSFnAd3IvSqhpZUcezLq1KyhAOaMjGj/KfXBUtUfZZB8clKcoETZLpm2LeM9VLg0pdUwoycA8BAQFxEUj0gCZBEQRxMwNYHLsWFbobLn62VqwqqQoLWUAsnHjPeyK3XXGGgwVp4WtsizOturQ7S5oXrRU/PGB4RvaXj7DUnUIyNnA4Lz58lCRTKAsmY5wsy682Voi/n7W3lI/p1D5fOp7mllbPsoDId2VrIO1CUx/XnHpr8Tpvoy2yPUY7SAt+m3vk2jDocjBmgMFmG3RwTKRIZh4x1qoTS6afmQlnEt7Alnn3Hy0gh+zM8X96J0UQmgS6/h0pK+WwPT7tSrKXfKC547gB/swkst5siKP3GzQcGw/GOOX8ZCO65EuaIkuklyy7AiJRz3jJunLZCIsMKnTUsSVsXJFAuxIJmIbxDwnEZpqgTXlVnbQrJlmggB2zZYFFncvyDRXymDTw5fqxZ66sPOY156Oa+XFs/guwFWP6d3EGMcncJRBqVhKlbJpHKubp2SvEJ8s2iDH9uohvDOkufnrIzpLEB/r9IEvORTpKSYvNVeLL9eUpcg278z97DxZXTh8jsyNn3PGG/bs0eJsyTMpaQDjo2caQUiaBrv9ma8U1T84Xue2WWq+J584641qjeJ1ndNK978ks5uauJNElkMiChQDi2ehzwgykqvXLFmgCZCeb0JsY2sAYhOQ1fZKyqi0+hY+g09fbxmgM8xyULaH6xeUXMLeYYyYkOWchpcx7l63UBaRjnGtOztd1kZ/jmXE+fznlG+LsylqZLa2I09+8/Km484Q9xJDuxWka075gP1I8Nrgy/22+WmsEz5G54tvP2ao81Jw5ZrcBkkw1q4miEheiAklnfXNLENWsDCS4Nbh7B1FbnxzrBXm5onfHdiI/J0dWCvgaSpIp76r4yrZptu3a1LwguYdxTJWLb/9BgBZ7wVwd0qNDLPvJ/bjwsFHSPjWGGIYYR5LFRdazn7n7tcVyrhAI+HDZRvm/b31+YUayEEH0nboXR9oD3W7Htc9xnocvAQUi/ZKptVIqx9XPYuLQ7rHvW0BAwI6H0LEzoElQBAGLlVpAyQwg8w3HSwd/s6FetCZZfu6C2uwGBMSFcrBwvvl39eP2xrZskHC2cS5xxNAgjBqL6jsKUYSlcgohA/Yf2UtmIA/qVizJHDaByzZUiN+8/Jk44o43JbkLEYPTumR9uTx3F3mL06kDQo3MrIqaepmZ4wLzkYwc23xknroIYBxfNj/ZNDLSAww222Bil36dxaWPuAk4s4Rafx+nG9LbR4LxvsogN8/VBspluW4XIAwpG4WMp3ko/yVoSDZaFMh4iWpGaEOUtr5qGBeQPXjWz8xZKbMdXVIqbKpcJLGyOT7EGX9x+idA8nxv4iBx0b9miYNvf01uApPnveW82HRe9ugccetzC6WkARtwNpEmga7smM2uMJ6iwJxW18+m20WAsRmGxNAzOyFd0MCGVPXZBo6pCHebTUND1mXTZMXRonWy4g2ymww57oV5PyKbj1bVyrL27/zhbRmUVbrdtz2/IHI+65m+yl7Z5A92BEBsrSzxy4dgq5EFa4otY62EFCGTnf/qhJh6nbWSrEXbnNCfU7Z6vdgS9HezgfJJyMyMS9Dxu8g74GOY2ttxmvkqW0Pl2jkHDpeSRzqSDYfHNjTETodvvqogNEGi+StK5DwkE1TJdvjsZRzyX/9v1OcAMhk3P7dAnHDPu5I4VXOfIDpNicmO1u+ZL9h/2SOzZGNvE4xpl//R2qGIbLLHbfs5VWlEc3Mb0jL9IxrjmogKJCHVZSPtSTZhvbnpmXniyDvfFGf974eSjH1q9grx5cYKSdD6QEVEHMSZZ+a16YEBVcUSdzxTDRW1bjD3lE1DQsu0gXGBFIuPrEe6iWqp1SWVkkD3zRvs7BdrSsWbi9bKvi86dHvQGPsc53lk21z8y3Vl4uX5q5KVf6VV3u8GBAQEhEz0gCZBNQ/TFyszM4BN7LBeHWTTQzL+ZGbCQSOsTZKAbKoSEJAllIOFHq4vW4mSRLVRj3KGkTq54NBdUhtPNgxxNvmuLJaoLA+kD2wlj2a2Bu+RYX3JI8kMbldTQcAcq69PyLl42pRh0sFWWVl/f2+ZzNIzoTv8ZM34oBOAamOqk4c+RzaquZn6bVuZNc/Zt7HgO3yGe4aGMlUFlGWbepEmfLIuvrJRl/6y0mBVerEu0LTM1sSO77qa25FJSGO6ULmTPdQYZ4z5iCGykqJIgCjdZshXqi5UUzITPj1zNX7MzWrU3GmXl+sZNz1kw04CBEiaYEvQvu3QLimtENUQdExDcIvrZ9Ntm6NFBXmiR8dCccPT88RLWvUHjUsfOH1vuUktrYpPiulg/lbX1ckAFg2hv1xf4SzRJ2ucDMTGBC9o8kYz54fO5HyrRSKREN8a00f6NMhH+ECDatuGnUDcjgbIZaRsfOB99K8ba8viyi1RwYG9tsmqMG7Uc2L9IlBNoNf8rOkHKFtC5UTUPDbBZzdW1EoSnnU+yidhHTGzJ+NoDPP7zPevG7TQuVaIZcb2KZur0hqd8r9ta2ScILQt017NSZu95N5hKwhK2xol6vM0m2btpn007ROyVPo943V+1zU2aKCJ/6DL7ny1wR1wb+3QiWyzBwz3eUSvjjLLWG+wqqBXSUQlYdgqO6OCKhC5trXNReiqv9Hr9vUp4rhxEDXP1DzXr02/n706tstqPOv9SqI+G5XoE2UnoxJCCCx//4/vyPv1+xP3ED06tJPz5cRJgzPmLwEmnv8T/11u7eeg24PGNlL2PY+oe6bfJ4ICVAhTxabGx5Kbp3u/HxAQsGMjkOgBTQKLH42GzOxNlRmgSiSvpXO20ZjJtqjigBQ7uosHBEQBBwuCwwcyVcggWriqVPRqCAL5ZAHIQCQTZ/7Xm6T0SFMIy6gsDxxUMtSjSqBxOPUSWR8JB9H69JyVstGW0oh8f+l6SQQwd1U5te5U48jGOba+YeB/o3vZt3P71Lly7ks8m6g4mTi+MuvLp4+2fk995/qn5mU0Wr335L3ED/76QYZzrq7FR4y6Nnc4+4+ds6+4xmjIqOtRU9rsA9lGSNige6lvDiHxrpwxNqPZI8e++qixYkC3Yu9xA+xQm9rjJw5qlMyOwrqyKlGzsl50Ky50NhNj/mI7Xv9sjXUuMX4IhLHlc+mZE9jRx3+cLCtkCC43xhP2gCZ80+94w6k3il0gy901lpWUEuAYrjmqGjS/tXh96reQcGEsQ4DvMyw9u9GEKyue8y0uyJe/BaHvK9EnaIjsjQ1Rtm3O15ukZju9XtRnfv8/e0jSAIkan82trUtYN+wdCvO9v9lawbN8d3mF9ZqQBjl0TB/nWsv94jmVyCaGyWas2ZA/2cgtMRZ8Um/qOXFsAkxURJljGjutr5sEjyHQqbBQ1QqmPvPJ+w5J60ugY8WmCnH7CwvlvIpqtucL4vskx85raPJKBnpaMKq2XhLzuvQD99r2rKJIKRM2HXedBIvTQFX3Mbx+zsieMhvXZh9d9kmNESr6kK2zfUadD76Z7hfYMmLbEnRfxyZpRB+dwaJDZEPubCs64nyHKh/m4OWPbpEyA5OH9fD2jymvqRWnTRnqbAhNMDkOfPNM7z+iX5t+P5GNUeM6jm+tAsS+9UZ91mcjzPnGvMDG0ZCUgHFxu3wpL+kDFWSALPRz8/PELc/NdzY6ZdwwD3m/3rADCkhZNbaRsoJLWx174FpzzPvE9dukqgICAgJcCCR6QJNBxtW60krrYuXKDFCben1RZdE8/8CRkSV3AQEu4GDZGn7pYHwd9uvXU06kyuJ2OcPKgYP0oZu7r/lkFKKyPMqq0t936QCa5a6u5kps+GmkhWwM13HtU/PkdXzy5UZZigvNo5PxyqnefVBXSRa1y88Ts5dvbNh4uAk+/X9PHNI9rUEqcjEuRzZKOoL3TRuiZ5RBAGRjd+TnEkJcOX20uPTROdZr8enedy8ulOPFlsH47NwVYsaE/hkN6K55Yq7MrGFcvrt4Xaq5oE1Le1CPDuKXx+0ms3TJfBvYvUg8P3eVOPGed2R5unnseHlTATaoTW0UMeSS2VHYXFkrjrv7nRS5xjM0ASkFGUdJs22e0ogSnXOaUUI6s5HluHpmtUmaR503WeWDe3SQm0uOtbmiRnQuLhAfL90ofvBXv94oa7ptLHMu2AY9o5bxjM1wrfMJY51XGaIfL9soiVVflUW/Lu0z5rfKcsQO8L9t90G3ETX1CVmRAlGmN7YDzF3mJiXkNvs/Z/mmjOsii5DNucvm8t2rjhgjM+VVdi0ZwGrD3rW4QJx/0Ejr99TrrREXH76L+OVrXzoDL+MHdBHXHjVWrqEZjV73HSKlGFx66D6S3KfJr49p1dCP3geuTFXGsXpOfP5y41xTev2PzZFNfGnAJ7OWN9WLycN7yPF87gMfiaN2H5A2d4b26CBm3LklaGUC8k4Fb8kyV4SQ1AZuGMdgYIyAKesKvUAYo8jRQfDT5PDVhaullrF5DgT/+AyfXbBys5zP/LvmyLHiSkMWj3Hs66/iyrRXWuU6CRangapKYFDrsivYyFigiqGmvl4895P9ZD8IJSOjjmWzT6p3ytRxfcW4Afb+DLoWtO4XsH74iM3WjmzIb1flJfMWv+fvZ+4tfZ6auno5P75syOCn0oPKJzOJIyqQpKr6kNbTGzvnR5DgpVV1Yl1ptbMhNHJSur0wg3ZAf411aNm6MrG+fIvmvlqvTZJWv58EbBjXNNjmv8BlNwHHJZnC9lndx/c1ETXnmx5Y0qsrb/v2eG+w842Guc+cuuNVd1WtWvPV+mzaAT2o2dhGyjpcwZz9d+5lbTht3qfymro2OY8DAgK2HgJbGdBksBD17dReXDp1lBBiQdpiuI8nM4DNyMVTR4kpI3rKBZ0Na98u7WSH8YCAbKEcLMp0ozL9dJKFTNPLGLvTcsQXa8ucsgA4gIzlKPkGH6JIY5Xl4Wt4iTO83tAVNSWUigvzJXEEGac36NGvg4znqeP7RTrV3LMJA7qKvYf3SDUshBgnm4bNAI6rfr82ymzCLSA7F4fV5shSOu7bLPE+UDbEzChTfyOzoBNxPrsDAXDptNEpMtz2vG3ZLmwIIYDMDCZ+n2vr36VITNipiyzxVgT74x8vF385daKY+cScjI0PWcKQnAr6pg1SY96KEvHpqs2SSOB183q4P2doWv0B2UFtan1ECPcYmR1zjCr7wThjnv3r7MmiIC9HLF5TJipr60WfTu2cQS9baTwar5RIq/H34k+/KZ+3/psmWRx13tjCpevK5DxXn2HMQ+bboFdg8M+2+TQ39/wOEjVkstlkjmybZxUM4FqxTfec/A2RIxamzSs26xADNEqDkDx7/+HS3kD46VmOkI2vfZqe3e+rXIEw1+3hvsN7iEHdisR1R42VAUyyTbHBEAUq4/7XL32W2XyuqCDD5uq2hCDY8X96N+23uZ9dGjhQzPz08f3SvgdBGdGfuEWjpj4pr2MLvHCvOrXLl1n4ruCMSw/dRbYqkpyqiSi5JYLXekM/Gxg/V80Yk5Zp7Dour190+C7isf8uz8hSv+OEPcQJDUFrhdcuOEBeX1z5B0UIqYbH5jhGs5yhAplo80XMqjVfY/LCvBxx4cOfZK5PR48XB+3SW94Tqiq4nvYFuWJs/y6ymbnZRPDkye5MezXndRIsSvf6iuljpPRjeiLDlmDj2QeMkOtsh3astRvFtN++nlZZQ9BM2e0o6atLp46Wc89XJUjAHvujgLSLL5DW2tGUigilLw1ZjuQezwn7TjXn/adNFCf9+T0xqm8nGbS64J+fpI0DxhIBHIIiVz0+x0l+Qryba9nDP9wn0v/GR1NJNFH2QveNWTvuemVR2jrF+VxzVLLRtx7itpG06n4SGCM4vL60WgZNWU8umzZaUEBLNjQBL6qc9HGvgkd/fn1xmo3lenbqViQreAhA+pqImvPNFVia+eQ82ZCX6Hf6mtxDnDpliDjvweQc980ptebrto17iLwbzwh7wrxlrZWZ6o1spAwygh0d0+WuWHN9lRIK7GsCAgICskEg0QOaDBax6vqEXKCOmNBPOgRK3gWHwIfVJVVykT1sbB+p1ViyAzbdCmg8bj9uV9G9W1dJQBwoSYpCsaa0ypvdUVlTayVZcFJ9sgBqI+jKUo4DCKc4WR42rVE2bcymix+eJU61kKd6ye2T508Rz89dadUUVNfBhoGNb1w9SZz37939jnjwjL3F0XdtkZwxUVVTn2oWpOAr+fVl3SU1zHOd56gTWWyq0SmO09xtbVmVuNdyrbYNospgvMLSfFJ9n0ZLNz49X1z48KzUezznB06flEZipmUzPjpb3PqdXeW9sWVaQmSgYc+mT/8tdY6ujKOAeFCbWhcRwqbxnANHiER9Qt5rGkwyf8msY2zO+mqjOOP+LbJAyr4wNyDMdCmJqNJ4MpZ1AojfMcuTTW1813mrsZFsMpo+9rJptKXmrMpohURClkPPtIure6v/rh4MwB5AODJ/yQzk3g7u3kHU1tdLkuH3/7OneGn+KnH6/R9Iot4c85zjtHF9ZTCDrFnmj78KJSE1oAl0dS8ukI0ZL27oK6GgnqPrfhE4hARRz8J8lthxE69rWdFc8yl/eV+epy7/g/+D1Ma8aw8XrRGvLlgr5q7JDPYB7hUBURIk4mYGKkQ1JlSa/C4wdq9+cm4s6aYKba2M0mXGd7XZdQJCZvYk1QfZyj8AOaYt4xhykfV41pcbrZI1Opir2DHWRpP4vv7ocWLmk3Ot14HkEjJipqzTIaN6y4obmrJT4UIlAJrmT8z62tq7hGAyEo3mM45sJlpTJ+c2815pj2MDz33wI2lfv7fXQPl7eiWdPi6ufmJuSh4tyu4hpxNVwcj5juzdUfoDyAEyLu85eS/x/pL1smm8HhjSZWVaK1wSGXF8DzN4q491JPYePH2SKCzIyyDQAX8z7icO7S6TPJDsY16a5Kdt/OA/uyol9mtYV6PWKt1eKMisa0svI+4LiRXMReY7v/HMj/aTlVzm/eFv7hvVK7c+tyAt6UPdG7VGfLJsQ5rfroJH43bqKis92xXkiq5FekC5Q6TslXm/XCQ4v3vqfe/LdfKHlcNllQzfnb18k/zH+THOoyrGmfunTxkm56sKbP/yeYLl6df9o4jqK9VI2UZ8x5XxclVK6MBGm/0QAgICAnwIJHpAk4HT8cGS9eLxT76WGSGPnD051VzI1/AQkGny5CfL5YZELl51CfH5mlJnU6iAAB0/+8cnIrddMpuZzbkqt7/52QXWrLiH3l0mTth7kJVkiYIif3xNe6KgHGlzY4Lzfeq+W7I8bGCD8MR/v5YbBAgnlwwCr9Mkx3SQ1QYXiRAlM4CzrxptxsksYfMapSMP0QY5ZNtE2Oa0L+tOlWn7zlGRkvx75kdTpAQN2cE+dCsqEDNnjBXXPZXeq0HfIKrNMht4rmevod1lBhyyBKaci2w+aWzcuD981/aMAK9jO11yBNjS6ZsqxC59O8nmtpdMzZWSHGTzKN35gOYhCfSMYtC7czvx8vzVMmuZbGX0zJ+ZtcJahaBIZbP8WJeSiCqNV7ZFH39mBhUb4u/vNVCSE9gOFUAia49sUQgt5gmbW/4LKWvauCgJGL0xMChrkIBChkaRY5wT2W/6GIx7fbZggJq/bJLv/8FEcdMzRh8D7T6bzf10u0KDZLITkQdwV6GsE6eWVstg6U+/NVKuFWQnQ67q81mIL+T12u4X2XOuDHrGxJVHjLEGGVWWI4SELZDS2vGXt74Qd50yRWZkmmQt0mGqd4MeUEUPl3J+CExsLSX1pu8XRbYqTX4becuz5D1lW7NpNBc1pl1Q67NtPqsxSnZulPxDVKa2qijzNcJmDbvoX7NS89ckernfr2hNf3WM7t8lJX2j3196ziDLccNTaCFvOb+DGxoGQ76b2fnf3WOnjHOMIxei5ja2hvtB5j29RRShxr103aMX56+WFWf8LoGvKETpYbNXkRnKD89Ku27V9+F8I7jYFhCld24DCS1XWBIH9GSM0uo6UViXiBzf7CO5n7bxbRs/f/zPYnHnCQSWE06/rnP76sg18MLDdhH/s/dg2T8JO7JHA0nuOtefHrKztDUqwKX3DNHBPCKb3fQJOQZzknPv2K5AnLn/cHHx1NGyuo3XqW4rqagVh4/r6+294iOVzfvlCywxjvFdWSdf+fn+4vevLZK9Qdg3/erFz2Lt7amUSci0H3+CzjkHjGhUI+WoCqVsZTcJBJq9MkJj0YCAAB8CiR7QZOCIj+rfWZaBsdldrjUZ9TdD6SGz+X588M7iCkN70dUUKiDABuU43fbdXWVJJJsnMpHMMmiIapoK2cZjnCY/ccpY425MFEGr8H/vLLVqpqrfPmDnXqnNW15Ojty44aKa2T68DjGrwylxMKJniqCKytZCwkA5ppSTs1lw6TiSrZYtbFl3PFd+RzZ4eyQ6o4xsWRoX4mC7SpE5z+fnrZKbnmQG7FB5bbpUhNyMaJtlpZ3/u1cXpck76E3HbIAs8YGN6dq83IyNQJq0jqbdruxiINCbB2ouQrKoDDXmmqrg4DmgRX/pI4wFv/anek0R8bo8iq80Hrs0qHuxNdvKFngyiXXIH8razY3z+QePzNrG6Y2BzU2qGdzSiQLf9U0xtJJtjXK5z//7g4ni+mfmZ2aQa03JmE8uOa3Sylpxwj3vygChD/wW5zt1bD9rI2CIDDLuDhrVW5adm5mNXAuBLT2DPkVMllSK6lp3Wbh8Zk0IwrZk7LpTV2swasGKzVL+S4ca13EyCaPuFxmESC2QKWo2hOT1vLwtvx3VmJIAjIJ3zjr0vxWQU2O9GNGro6x2UID8ojozTnZvZKa2VlHmmhM6EW8jAf9x5t7O46uAtek7kK15/9tLMu4hpLvZ/BpAGF5pIRazkQsx5Wm4Luw1c47zsVXcASpbh/VKEnA+f0Bvju6qTutaXJjMnDaC5cnqgxxZdba+rDrjmbd2xMni1ZFMKHDL4mAbsIMQ1E0Z37bxwxggEQV/8aojkOiqzSD+feOO5//07BUpLf7zHvxIZoFPGZ5ZXaSDZAjlR0fOR0uWPHMMkjopF7MuUkLGtjdmXiBtZgsKq72Rft1RAUX1PlVhFx42Slz/9Ly0uRHlS5BMw31kPfA1fEW6xlU94NtvRVUoZSO7qXrWBE30gICAbJBdq/WAABsSydJWFW3WwQKOM2JqBLJonrzvUHH1k/OsGXOKFGVxCwiIA8YMmUkH/fI1ccQdb4hdB3aVGxvKEnFGcS4lUV1jJznUWGUzrUORwwtXlDSrhAal+2Ta8I8sJpxoc56o3+bcyABT4BqSTf66JcndE/eQ/+VvXqfBEg6oglPiYNFa+bor61IHJLO6dmgJ129L/dssiaIoh5iSblcTQR3qd1WWsX4PzPupskG5/2SXku2SRh5qTr0kSl/dssFR4H5y/5B3sCHO+drIEl8jtGAXmxc8c6QJyLpiLDAmFIHOxjip5+omBZT8kIIe6FHyKK7xyN+3fnuCGNmnk9wsMg/YeFKN5XrGHIuxutugbjJLyyTQ1TixyRq51mM1L2i8yTnE3aTq5+S6vpuPnSCO3X2AeOycyeK5H+8ng1w0ylX2g6Zz2Gias70ZcZ+ZTy45rbiNYiExWQ+oQrFlxv3ljSUyQ/2IO94UJ97zrmx6SSBAv4fnHzhC7NmQnciYYewgD9Wrc3tx+4ufyvlrgyJ0zPuk36/WCjI3/3TSXmJMv84pkgX5LySusKfmeI7KJFSfj7pf3FOIJtuzvOvVRWkZxr7xj7QZGbRKitA3pmceObahYsGO8upaOS42WOawCtwRNGNO8F/+NonXbKo7ouaEC508PVqUHTPXIuahbZ66XrfZi6j76/KzeDbItxx8+2vimN+9Jab99g1pL7HTeiPRuP7Afpo/4Bob6nwgZJ0a+YvWSgLd9cxbC5hz+NBRa5AP9BjygXHFc2nq+HY9U6olSThhTWWNZK0kk3vBihLx3hfrxcrNleL6Y5J6+S7fUPl1jH3+N1JIUVCfd52vbz6qOab7GUpCxiSXXT4glZxPzfo6tR5RLaXmBlKJjF/9fikS3AY9sETTbVu/gChfQt3HGeP7yV4KLvC5K2aMzth3RckGRdm2bGQ3fb5OQEBAgAshEz2gyUgYmStsjnFOcQjM5luArE8yk9ig8j5R/OaIJgcEqMxfXeIDp44xqTSEKduzQY3VZ3+0nySsGZdszBir/KMUu7nGIuOaEmtdg68gNzdZwjplmMwkL62qTSv3RsZA32D4JAHIqFMZqzT6bJ+fFynVEqdRoQLkHXqstmM2Jls/yiFGE5PrQZvcJSVj/q5eiszGludpNhBV0El/m0MdJXVDBrwN/J4rywZiDltoKyP3/V6wi80P24ZebWxPnDTY+12zOkLf/OvjylcaH1fbM5vNH5lg5thTNu6K6aNlCTqSDqashNp8ZrtJjVP6z8Yfu6E3yn3y/H1lED6qygRwnsg5RDWKdc057BuZb1PH9nUGRnQ5Dt1/UWXnBFywr3sO6ZbScYd0V42W/2fvIfK6zexYZZ+itIZbK7g27g3IycmJtFlxMwmj7hcVCLZnDTg+tlllYKrnyTjlebImmOO/qnaLFIBrTCOrRWDXJtWlE1CuYHKc7N6ojFk9E971O1FEJX6GSxZONUE31yLXPM2m30Jj5EJcQRdbRVCUP8BvERxl7uoNnc1GwcN6dpABcs4HQtIHdf1Nkfvb3rjg4Vni3a8qmlQR3Fmr5rCBcYXfw9hr6viOM35ocIp9oAqEZ4RfvW5zpbjh6HFSnkdVNJi+oV5V5suWVueqfz7b+Wjz97LxAZkbSnrJNTdUVQYNd/Gj12yuEkdO6C8D56YkmaooxdfmWuZ+vSnjHPS18eLDR8mqWtt9rKypk5JdLvC5FRsrxfVHjZP7rriyQXHkoOIiytcJCAgIsCGQ6AFNBhFuFk6Vkcfm8bFz9k2VSiuyTy3OJ937nnR81CLryxxrShPHgB0PtrGknFt9A+1yiMlioTx8axOUmyqqrfIqao7AQai+AgqQ/4rk9hHebIpV1ri6jo+WrveeD5uaQ0f3Ft/ZYycpnxJVat6UplM2ZKOPeksWv6u+wyaDbH+XnIZexm9zqKMIApcTTvXC9ceMk01EdaKCZ3TDMePlJtAmPdMYQmJHhquZVlzYCCu1iVUb4zg2R9/824JJNvKsKdqevs0f6/CT500RM5+Ykzb2yKCmwSPrsE0CoX1hXrIxsCdL1bVJjSIHbXYDAj1OBjnSIMynno4sb71R7KPnTJZa7i65qX0jyvP1+acHZF/86TdlZt66smop66SqFX710qdGU9otMllmE9bGag23dPzmpc/Eu8srnT0DTJuVTZDGd7+iyE2VganGnBrzJHHEIajMMc3cuOm5BeKCw0aJnJyFzkahTZV+U3Mlqhnpfo7f4TypsPIFnZnjrEO29Ym+B/zXFySM87pCUwIKcTXi4/oD6v48M2ellOvQG5XrDWGVBA3Z2XHkL5pD7m974u3P18keQ03Rl+7WodDbr2dgt6IUKW/zIc3xHXVPfeMHea2vNlZIiRZzLdipe7HMkCZr2wU19tWe9rqn53nnIp/3na8rMGbz97LxAZMyMX4JHXqlfLZqswx03vbcAvl51q8zvzlMXDR1l9Q6rEjwPQd3E9cdNU6sL6uiH7cVar7gK7nuI/Me/9rXR2lFSaWch0312RSynYdtVWItICBg6yKQ6AFNBoQdTsbfz9o7tbA+O3eFmD6+X0Zjx6QERdcU0cBm06ct2ZqzOgK2LczsFZtDytj823vLxA3HjBNXPBZNFm8toK/5yxfTiReg/sZ5Na+NZl7nHZjMhlRZ9fp31CblxmPGZzQe8mWCqDmsmvfEJXfIJEJ7kuz/joV5Uge2sQGIbBzixhBQLtL/oFG9xE8O2VksXlMqvlxfLjeAesa/QtQGmqZj5vmrpqiU6d/6nV1l1qM6X8gLtZG0nVu2DSB3ZDQ2i1uH7RkomxGnV4KNQItrS5qi7enb/GHrCMaZY49MQfpFuPovPDVrhcwWx458a3Rv2aDPRFPIIn3+UiVTV1cvOhcXyt/16VWjrc18ct0L/RmS2WZrLJ2q6mnvnz+u+QchO7RnB2mLo2Sy0Lz62xl7ywz1/g3ZrOb5tmbS3MTbi9enEXBmhrDy5VTAK1vS1XW/bDIe5nEYc6ypi9aUyvHQoTA/6yClOu/15dXi23sOFP9euFrsPay7uOjwTAKKYHxz+BKcNxman68tk9eJFBFZsWocM1+4LvN3lE2k2g0/gUbbZs+hLQ1PCzNshPQ1HvxI3Pbd3cTa0uS1Kbjsodkw2GUvGhvwjAq6sKYijxM3IMX7yH4wn4WlGS73h3tMY1bsM1WDvnWAqp5t5T9uS2Rb+YbvydpBA2x9LLDXI6FgYI/k/batBVU19bKCyhV8zBbYa2T44vrZJpSN4lxyc4Wci8qG2LKuybL3na/LD1VVH7bfjmMf42RSI+lCXyEk1BThznnTjBVMGdFT9gCZNq6v+PbuA+Tnp/32dVmBO29FiXdtppmsDTw/AhUE6ZDLMu0Qxzz/oJFiSPfirJ9xcyby+PYfAQEBAS4EEj2gyWABYtPw8vzVKRmXu19bLJ13dEKd2WAjeohLp42SGqI2tPasjoBth6TG/pBURoiJgd2LpHY3jilN/Ab16LBdMwFxwn36v7yPs6s766tKqqQTqoJTlD5SRllfL0RlLSWTBaJ7h8IMAr0pTbwaQ1x22cKjbDWHuDEEFBs2miuRVQbxX1yQJ7p2KBS3PLcg7VlQ7mpmzURJ3dCM0Tee+G0foWsGBghq+DJ39AaQOzKaksUd1fCXzGdfwIrnwya8pKJaHLVrfynLQ4UJ2d/Z2JKmaHtGzWtkl5QshY5rjhonZStcGYBsriFBmAvYoOYONqrvXv3kXPnsLjxsZ7Hg6xL5+7bA4PVHj0vKAET8pnqGlKv/2ajy0a8T0jNOYMQWvEKTmX4bUibMU3LPdUGwQuTsqPNUZUGqNUZfN3ykZFzfj/mPLYxzHMhvVd3F2poNgW9b79R8OfUv78vmw4wF9OAf/uE+MqjaXM+cwPR9b34hSS0CEvwOxJZsZLu5SnQrLvDaRFNOEf+nd6d2aeenr09k9qM3DuhdQP8AfS1y2UM0p68+cpysfLER0k2RrYqTLaonAsQFAW6CEzcePV6UVddKu4cfxf0BzPWo61brAM+hrc7zbCvfWAvPO2ikuHjqKFFamQxallXViXYW6TqzOgD/lcb0zeGT0zsoys+OIynDM0ayC/z1rSXOikbGn83/1mFLAiFT2zyPbOQVo+YGviKVmGaGu940mMoqfc09pcFeYGdcY5/zu/aosTJT3fRXOUeCKTOfmCtemr9avPX5ujSpJNZzqhIIpDX2GTdXRZdr/xEQEBDgQyDRA5oMtQDNfHyObBZa37DQKuf93ANGyGws5CjQISytqhG/O2EP8fWmCtGuIFc2pKLEzJUpExDgwu3H7Sq6de0i//eD7y51Zlc+P3dViuygkZdPWqEpshBxgS6j9/3KZGMyHZAObFRH9essHXWy0tA1xNlG5sCn2d6UrA3znpCp3VzEpY5tIXHAfT2hoYyf+wlhYG5S0IiEOEDVV90r2XjslG9IKYfXPfevqcSi/n025pcbOpc60TlxSPcd3j42JYvb1/DXJPlMrVw2gFs2zFsy69L/dzw0RduzsfNazTU0vF2asByvsqY+6zkZ14bqz+6uVz+Xm3RsuJ5Bzn0e3KNYDOhWHPvYah7Z5o8KtmK/uG82QuzcA0fIpmwmeA/ClnNWGb5RgKwn01XK4+zAc1Vpvevrho+UpOLAhO3Z8zf22k3wbMnS1udZNgRVlBY3BLoeSMG/aM5nrc9xU/PbNsdt/Vbwuz9atiEl8RRXa5hjoRmuZ7MrWTyq0K6aMUb2K1F2AdgIaSWp1hS/oTnlG+IE5Am26+dq9nfi2iDuW7sMUxxkUxHMc77Q8px1iRyfn9qc97K8KtkgXAWfzLlAgBMbceXjc5wyLfxv1oQ4620UgW5ep7JpKzdVyPPQpRTj+pxRcwN7+uL8VVb5VFclFRUEiYb3pVTroK4ZPpAK4nVvuJY7LX4CsmcQ6PJZWHo4NYetbK4xY9t/BAQEBPgQSPSAZgEL0BXTx4gv1paJiw4bJQqm5UoHpVP7fDH7q41i+aZKMX5AF7n4krHBxnjeyk3iy3UV4pwHP0otzui2kT1nZsoEBNjws398IkvIVUZFdW1CfLhsS8YWwLF9af4q+RkqJswNMk4TgR0kT658bE6aVnpjGitFgWwsmoj6QGYKm2C9OR1E+dVHjJUZonE2081BUtsyxx48fVKzE5fN6RD7iDY969eVRcr9ppT9kbMny4xkstbZMLz7xTpx5K79ZVNGnThoTjulnztlsNjEM6YMkxlVJtEpm6Xu4ORcU7K4bdCJXZPk07Vy1Ya5OYJuTSWHGht84n0IdJ8mLMcjWBD3mkx7gc2FbKMJI2NWv0fms6N5GdJKgM8O6Fog5ZXwI2Z/tUF0LioUVzw6O0371Wef8TNmTOiftukHD7y7VN4rV2Ckvj4h9WBNUmXmEWPEkXe+mTo/vn//DyZG3hMIReRzmnsdaWm4/wffEO2LO4kO7ZBXyRGvLFwlKxIHdCsSqzdXinYFeTKDH4KX+6fuIZq8l0wdlSaJgowAa7W6Z64M5h8dPDKD3NSrt5asLUvK6XQtSptnLgLftpZmq8W9Naons5nj+DKufit3nrC7SIiEJIhdNsu0R/r9JSEGEhICWf2+soHYEnW8wQ0SKc0Z8GxO+YbGri06EYh0TLaZ760R2Y5piFPm+SmTh2SQ1tu6KXqX4nznXOD12rp6aWsY25wv6NelSK4ByzdVyDmHHSGoqoJPzZXs4VorLzf8S5JjNpThY9SKzkX5MnCTIdfomRszjxwrvnf326mgWkFernjwjEkyM3yvQd2clVTKtpHBnrSV6ffQl0CyubJa5OYkm3BTAayPAT3RCQmfloS2JrEWEBCwdRFI9IBmA+WyFzz8ibjn5G+Iu175VJx1wAiZLTukZ0fZxOXNz9elFlHKxa4+cqx4Yd7KNMf0+Z/sJ0b26bS9LyWglUFt9P52xiSZSUVGh+k0k9UxtHsyo5FNJCQk2p+MSxpwvb9kfUZGhp4lBZpKmKlsLEgaV3NTzpVGSGRJq8ZsEApKXzuuA+8i+OKcM98ly2TZ+nKZkcOmSM1dSOVsiUs0E6M2AnHOPQpR5eJ6lp0qa7VlKiUSCXHtk3PFSwvWZJ1N1Vj4JAMu+OcnGVUWaNiywWnr5NzWyuKOIk5s5NwQsqIb7vXClSUyyJKTk5PaIOrEX1w0BznU2M1ftvfPNi8BryFlwz1SRClQBAZarBmyTw06sHpJ+a9e/CwjK5yAFrab4KHPPtsy0vffuVfafeW3OFZNXULOM1dghN9FiiUpRZAvG9QtWVcux4RuL/LzMhs3qvf3GdZD+j8QyhMGdpWVenq10LaqetpWOOne91Oa6Ngt+nfsPbS7eH7uytRzpQfFQ2fuLa+7sqYuZWtvfjZdUkt/tkhwuTKYf7j/cPm/eS7MP92O7zGom+jesTDtvuvzTCeGqYjsWmTPKub5+LJZ1ToSNV+b+rzjVs51KyoUtz6/0KoDnStyxLTxfcWlj85xBqJs9oj7S5+EEycOkj6Ivmbha1Edx72hsmV1cYGUjFHVI/p9bGrAc1s25LXZRn0c1NQnxOdrSlv9vNUxeXgP8c5XFU0KUGDx8F1tpDVzLuo5N6dd7NiuQPzlzfQG04C/qTTEtzIzpKVMl4Vc1s+7qWSrXpVh2pb1ZdViWK9klVs28keuucHx+LwZSGAPfsSEfvL3bRW8AMlIzo1s+LO+OVxcNnW0/HxVXb3YXFkrn1FuSU7auaoqrdteSO/5ZDaa5jhIKn66crPYVFkjeyyRRGfKtrW1dTIgIKDtIJDoAc0Gss7ZoP7+34vETw7ZRVz71FznIkq52DVPzJMb1TsLP081kUG7LSCgMWAMkWVx1eNzMzrVMw7zcnKkxq+uc6nGJZlwuiagDrRIN5TXZJR8ZpuljjPIJvP4iYNkY7MDd+kttxz6uZq6xDivz/5ov7SGnXEc+KZoj7rIXDV34zQ8Uo5veTXOfGGGrIJqgIo2fXOde5xycT3LjuvQCTx9g6FkH95avD5jg9Ec2VRxJXLM5nymXmdTJXRaO5q7xN8kTswN9is/31+UVdeJix+elRYA0+dHY57HtiSHGnv/bPNSEt0HjBA/+Ov7qXmi7sWc5ZuspeL8Fse57qix0h4TYLM25/xsrZSQgMRhw+7StvXNR9d9tZWeq+9j6+945bMM32XmjLHyc7d+Z4IkTxkXyn5ABOPTuOyJsutkaTZVG7o1QN07KgEO2Lm3GD+gq5j11Uax605dM3pQPHD6JO+zJfjqymCmCSFjUBE3mXa8h5QYVPc923mGnUYH/96TvyHqRUJmb6pgshrnA7q2l7IEvuNsjeftOuY1R40VHy+za/pjs07ZN5lxq2BbQ+LcJ+4NBDpyNjaC7uZjJ8jkmeYOeOrnIIl52NAmSqnFsY2uud2W5u1t35kgqnPbW595HDKTz1z9eLomvunH+J5zc88TMrpdtgV7/YMpwyKrS7IZn9lKmTn9z5E9xU3HjE/1DAE62T5/RYms0DIrtm17g8raeqdkC9J1pm+pwO8N7dFB3P/2koy5fYq2R+HvG44ZL2W1lAye7ff0MYANpS/Fjc/Mz9j/0Gh0cPdiGaxr6+tkQEBA60Yg0QOaDTSNWVNVJc4+YEQGgb4lE0bITCQy+MjmycvNEWftP0x88MUGSartiERQQPMAZ47xZMvuBmyGlq4rtxKVqpTcBpy+Kx9LlxHQN59o71KF4XOabc7g1HF9xFVHjhW1dQnZCI8gFIQSn1OEFJ8nGySbedEU7dEo/VelkejTk0WGRAUqcJRvfm6h1YEns/SXx+2WlpHelHOPUy5O+bXKsuM6kGaxEniL1krSxLXByFYmpCkSOeamTg+06Ne2I9rO5i7xjyKVyZSiKsC0MWawA9IOZJNBtTVKiaM29XHvn2teKqJbnyfqXvz0kJ2dgUm+9/maMvHM7BXiksPdAUyORYDzy/VbsiNt8M1HU382JTvRMbMRIZ/B1tt8l+uemitL0+94+TNpv8xqBfwegp03PzPfSSAgxxVl4+4/bZJoC1B2a21plezvAaE9aWj3NIIXoiaZre8G1UsuSI3v86eI975Y77Dj62SPHu57tvMsKpissllv/c6uTQ7uNraizXZMkghc65bZWFD/nrmGRN0nPk8GuouguxTZOe3amivgubWJNd1mIlGJb1dJQkNujqw8IUuZMaz3jmgrgWzOv3Pnjo2+59IH8zTyJODqes5bY55EVT9QDRNnjsQZn3HukRpb+AcknBF8RV7MFkBm/lDVhaZ4UwI49AFyBRL4nbP3H261FVdOH23dx+t66XyPPiFvLVonq4KO3WMnWYUC9Dlirgn43b97dZE12UkFXw8a1TsjWaGtzbeAgIDWjUCiBzQLcA7KaupE9w6FkhR0LtqL1olTNleldFjZWF1z1Dhx8KjeoqymdofX+A1oHFTmxppSNxkOXFIkSDK44NLOVg7dojWlqSagNqfWtjnAIT9r/xHi2ifSs+bZpPN9vcGfIoga07DPdr4+wjWO/qvSSLQ1PCIQNpNrani9d+d23kwgsgx1Ej3uudvuBVqwPqj7qLLsGCvYqsu00nbb9TZHoy11rtjHKx5N190HURI5SF8886P9GjLE8sXKksq0MtymkPqtHc2ZxR1FKrMhjZofPBc2mWbFS2OInmxKmXXJJLRgiwryxeVoiBvngCwU0isduU8dtmTnIt+ERBDnT7CA/zZGF1q9dv6BfnIUooJjnjK50vs5JFXiVL/47iHzJY70jo8E4vXLZ4zJeF9VK/DvyfP39ZJIEMZRNq4tQSejFKGtyBdFDBH49qFze/c2hXvPt2l8p0sG2e57NogTTOYaWMOYM8w91/w0n7cp38DYRFqOjFEqLlyyBr5j6kjOqfRscx2uuZTtGoJN8vlGrxu+RnMEPF3PhWrB1z5dI+c0Tdt9ttJnU21EaCrz9v8+SqtAMJswt9VAdjbkdhRpjWxSU5Igsr2/UdUP+lzQ52WHwmRVNWsFvYj0BsWNvUeygs2s5GqoeHzHUvGo5jHnxfdJOjtx0mBx2pRhaRrzPkKZ8yII5L0HBbkZwS3+3mNwNyn75JKyQk9dJ/fffNQt3aID27Zzn05ev5s+QNhEX0KUby/QFudhQEBAy0Mg0QOaDOV4/vzQncUvn18ozjlwpPfz1XXpG6uZj88Vp+2X1Ka74an5oVQrIDYePH2i6NerhyTNKhscPB9cG0gyQtgsqQzDxhIFNqfWtonGQTfL2l3yHRBE2WRfNUV7NOq7XCvz9O/vLZM6s5CKOnFJhg2ZMzoB5j+XWplFqHTSkX/xoayqxikrce1RY8VPvzVSNrOzaTzqRBsbmmuenCdOmDTI+Vs8p75d2ktijOtQlQKPfvSVtTltnE05mfm2jUEUSch9/84fXk/9zVh94PS9xYn3vCN/O1vt77aGONmlcTdbPlIerdeo58TcpaTdVbkSN4Mq7pxXG+WrHtvym5RUc642KRWklZTmqzoeROS1DeXYtt+KYxdMoCXuQ9SY33KcPNnU19VDgrlv+y3ui5ThMqqIfNI7tuvk2UPyERDcVF4jnjp/SqpiiDGio7zKb+8k6Zvj/0xrxe3H7Sq6d+ua1kDOfMZ6wIV5AvnCWPRVNtFc1pfBTCN6tKl9cGn+upBN0OgLrTkvY5HKNJra2saUmVHK3zT7/MsbX3hlDUxEzUcdOgkGuhYXZjQtB9muIRCUyNNl42s0NeBpey5c3+9P3EPaS3q4YIuY9/gVB+zcK0PD3WVTCV7YiFAz89YlsdZWA9nZkNtRpLXv/eZuEh5V/YAPRTUiiJJVsc3BbO4RlaZXGHKQcSoeqULlvO578wvnGuYKMKh+BapvhIJJikNq03cCeZiSii1zkootnzwZeuo0heY9ss5V41JFtK/cVCGrzPU+J4DfsfkLOroUF4jlG6Krz6J8pGx7MQUEBARkg0CiBzQJbFTJACFi3i4/Ty70F00d7f3OTt2K0rIocSToSL6mpCqUagVkhQkDu8ny02XrymT5o29DjkOsnGYT6KWTbcRmydTChTzxwSQKTKfW3BzgwPo0fvVN+jcbCCIpIeHIcrmtgczW9bV98G2W42TuqGxWnNE+ndPfx/E2CTAblCPfvjBXSjWQPfbx0g1i8vBk2axJTil0KSp0ykpc8dgcMWN8P2sGjF6Oq2cNuTL21OYBaQZ986L0H32Za75NuWvz4JPI4TffXpxZUou8BOTeX99akrX2946GbCUAXKR8nPkxeVgPb+VKnIy6uNl/XNdrC9eIp2Z/nTZ2fBmiun1Rx5s6vp/3t7LJ6FMgwdjXPFnZYv5rNufUP4fUVv8u7cWkA4dLwsG0zydPHiKueHS2rGhTz1Lel0/XiKdmpd8Xdf1AERdk4LtIIOYVwSqzrN0MYsUlIlUz1baIn/3jE9lYVBE8D767VJIYXxtEq7KBaoxCwPB5oN/j/bRmr1EZzKwLzXXf42Rv6nZcH/uvNwSpkCOgqa3ZzFoFDkx94Dc8sgbTxvXNsBdR85HfJWCbn0vmb4G47fkFzkaPqh9RtmsIn19Vkr3OeVNkq2xE67kHDpfP4KnZKzJsw9CeHWSlQ++GhsE+m3olVSYxAye26pu2GsjOhtz2kdY8DyoGIG1ta25zNwmPqn64/uhxUsfbNi8VGA/IDkbtR6PuUVl1dAWbDQO7FYkbPPJgag0zAwx6v4JPV21O+ZZRsjA0NFXo3L7aeV/4+/qn5osfHzJS/PE/i51EO31E9KQWKs9Z71VAzwVkk6LAOHLNZ5pJXzFjTEYzcuW/D7b0YgoICAjIFoFED2gSKGVFA43/1tcnZDQ6J5FcLG1lzSysc77aJCPYug7q8o0VsklKWy+NDGh+sFG/tMFZ8m3IyVRes7lKPPTesgySti6RSGnb4tCySWZjhsP38vzVTpKHcd67U/uMzC7dqTU3BziQzBcf+H1FEpC54cty+WJNqXjj83XyuGSGDe1R7DzfqM2ybxPEMUf06ujdUEBW6BkpOSJH3HTMOHHd0/NT98aX3TKkZwepO3zc3e9Yz50qlqjNCMfVM3vMcnE9a8hFXrs2D5AdlzdoubfPz00FEGkWq8pcGQeuTbkr+5bv2CRyuOeQhEr/3DyXS6eObpT2946E5tRajSIJIGR3NnS2G5NRFyf7D3BdjD9znEZlepnVM4wx329x3T4bOHv5pox78eL8VeLcA0fIxn+mrvQZ+w2jp7Ks8iirrJNZbWir/vKFhXLjrzbZVIL8e+FqccAuvcR3//COfFbnHDBC2k9lnxURWFWbfJa++2IjLsheVcQO1/mt0b3FLv06y3Og0fn1Dl1YFcRSUl5cV0F+jjerWtleX2Z1a4fSCr/2yHHSr6N5nc0GqjGo68rra2+vTu1SkkJRGczNrbftk0PRr0EPBgHOl0D+uAGdxacrN4vq2jopJXPvKXshGifPA1ufTbDL5gtHZdg+PXuFPK6rIgU/afr4SnH/DybKuTSw25YGoHHBOQ3uUeys4GsMMR8FG9F6yOg+sorG14eAjF70r302NY5P5vp7a1xrS0E25LaLtNb7uDw7uJt1zW3uJuEKPttBNSWvV9VuaSBuky8hk9zbz8Twe3VfEPtG5aMPtvWa9RabEWcNMwMMer8CfU+EbXI1+zZ9Ie6RLyGA4Djru49oZ41Uvriq0impqJZBT1/gvKSi1ptYwnfZszGm0I03q2pYvwmsu/x3xuhOjbB5AQEBAToCiR7QaHy1vjxFXiqw6B29e3+ZqUr5mvmecqT+ftbeMoKtL3w07mnrpZEBzQ/K9fRyQjZMl00dLfLyclIlgThk03/7hthjUFfx0Jn7iO//8e0UEYVDNqBbUUrb1gRONXrUZHaYG4OT9x0qvvfHt6Umq57ZpTu15uZAkQQ+DOvZIeXQkklCVpnNOefcKHdno6xvAvg8MDNvowjXKN1Sjp3WnM+QxCjMy007F3V/OR9FNrn0HZWtwNG2aTTy++jH+sA9wlGmIdgho3pby8X1rCFFXgP1+1wjG3PX5kFquZdXi/b5eRmZrnqGn03n3LUxMCVykMXBBvbvUiS+/Ye3nHIEbM7GDgjSVz75FrJKXZutbAO2rvmhyzi4qiiyyaiLm/3H/CaAYyLKvpjv+0h3fosGnJS1ozutZ5YzlpFvg6BS1WX6Ok8W2tPnT5E2GbIaLFhZIomNa55MJ6ch4x/+4WRJWpv247Cx/VJ/n3jPu5HBBdd90cE5sWZQaTR/RYm8Tsq9CX7JpoivLGqQX3L3dCCIhTTXqk0VYkTvjqKqplZm30Ee6N8zba/PxrYFcG9Wba4Ufbq0T6s65FkS9DbHoG3t5d53KMxP09R2Bm+bWW8bW+EicBRxbjZ41oPDal25/LE5GWNc9xPiBLvUXDd7Hlx/zHhJFP3Hpt/dcE42kl4/T12XuDE9GwZ0KxY3HztBzpdsfY3GwEa0+now8Xp1bb247qlZMjPVBwJp2dhM9fd+Db1g2mogO1tym/HDWkivID0ZRY1515rb3E3CzWMj91hTVy99q5r6evk3VS66TBvXcs/J3xC/NCo3VFWMa27Y/F7lC+LX0d/Ae37G+1zzzCPHis9WbZGpspH7+BuHjO6d8QzMfgUqSHnYWLdfq6+f/JceQ4URfkRxuzx/XwQag08bLY7atb9Mkks+w2QWOPczUyO+h7zuqpp6q2+ubBxB/2N/l/SLbfrrvnOSfSzKa0SndiFRLyAgoGkIJHpAo8CG49JHZlkzXNaWVElZDKLeZlavWugo0VYRarUp2a9dzzZfGhnQ/EAKxMxsZgN+ryOT+Oon5ohHz54snWlFsgLXRoFmVTirqvmeIoP08ayXV876cmOaU2tuDtRc8GVZ9OuSdO7JjLvuyczmo8pp5PeuN7KwOB8Ia8igq2aMkZns2WiPujJ3OK6vWaK0CZbsD/n5hJBkWl1CiGuemOO8Hr5bUVPnzByK0rZVG1tIvd0Gdct4n3MsKsiT2e4qIMFzIfsVW0V2y8jeHcXiNemyNCaQ47nhJXf2G88FORcTro1BhkTO6lJx3N1vy0xd3zX7mu7tyLDJt7iaXcUN2CpSns3ldUePk+SMa241NaMuTvafItpthLnPvpjZs65j6L+V/G++mDa+nzhl3yFpa/ppf31f7Dm4m3jwjEliXWl1ml0Ea0qrxcSh3SVJxVxjA2wS6ACbcMVjs+W8fWnBmi2vf7ZWfp45FUU6EtyihyTEtm9uQEgM7dFB3P/2krTNNlUzz2iyEFG/t3R9udTDZvN/3dHjxfL15aK0pkpcdPhocXl+jqhsCKia46M5m+G2VKBLfderi1LZ+knSeYgMWDz8w33kePBlIzKO0DuPC9s9RQqNOQrBFdV0Tq/+cNlpznemzGxOjgt9nOsZmQRnrPIQRnPVOMEuzlvJ1enHO3hUL3EDdqguIa+X9QxJE/2cbOPXlTnaWCnFnboXizubeSy7+lfYiNaoLF/e57NUyvpAb/m4NhOZKpqE42fyOvZJl5NqS2gMuU3gWiVN2OBac7eGXVS9MZBZMslYgh+DenSQ662vV9Hrnrnh8ntVRQ73CIlFZ4XniB5iQNf2MlGnlPFeXJDsD1RVKwoaZE2cmu0jekpfxCb3pPcrUEHKMf0M/UUDGyuqxdXsN5QdPOUb3s/rzcddqCDRY0gX67O+U2tojq1G0vHIO99MBgsGdU2rUCrIz5Wym0gb6jbO1qMgat0mEBmq3QMCApqKsAMPaBTkhsPibLKQ3fHqInHJ1FHOSDBAo/DQMX3EvK83iRMmDZaL4rRx/dp8aWRA84ON9q9e+jTNiSW70JWdBJHOxsokWaM2CjjLlGarLBAT/N65B4wQJ04clOGc6ZuD+kRC/O29ZTKLTX1Pd+zJ+FS/J4lAD1G7j6PcEgeTrNGXf7a/lUyOgpn1x7lcpJGSelYMpAhEBXCVS5O9WlOXENdYpBFMJ5jmfK6swyg5DbXR1YNwnDsBE7bQZsNHvsNzV075Q2dOktrqLo1KBTZFr0eU2XYozNw4KekCAhyUmbtIWHWdBBtd5fK8ThVCQDz5FldDuDgB22w01Zsjoy6b7D8bYa5IQLbg+tgxs2fV8djI2qD/FrYLssAG1V/ARpwoMptzQXudJm0+26zsonn8s/cfLgNsvsy8rsUFchPOPLvxmHFOTfYrpo+W2eLmeeCX6PM6bka/CgBw7mf974fyNWRhrj5yrKisqW+o3KlOI3Gbog3dGsC9keXz08eIB0+fJN5avE5c9PAsOTdYr5XMAOuhq2Lx2N0HxG4IbN7TFRsrxCsLVssMSF+zSVv1h01iZkiPYjGga1FqbSZYrgfj9OzHuD0JZPKIR/qQeTm6X2dx4cOfZIzVlxesEVW1SWkxKkXMTFj1DEz4zq2xUorNOZajbK1JtLaPIPJUjxil/e6yqfm5OU6fTM/ul5mw+w6RFTH681dyUm1xTmdLbjdF37y5xxJJL3e88pk1oQbNbOYP14JP5utVxLhZ0VBFo5+fT3qN38D+D+iW9AkyM6/JOB8j5Yhe0QLHqqEp5DKB3ZF9Osn/TeUmyWmqoo61jQpZc9y5+hVENrCvSZdLJMnEF1hCNuqwsX0bXeGhnjX2VE/Q2RLETE+MOskRmDF15cn8t/kHquqVXk2h2j0gIKCpCCR6QKPgKjdXDjollq7NAa8nEgmpT33R4aPEy/NXiX2GdZd6olurDDSg7QKdbF2KA8cpV+SkZRubMg5kImSzUYib2crvcQ6fry61ZlGpcU3WMc1v9GoNHD80RimRjnLOFWGPhrYPzeUo6ufiyopREjIusAmIo+/YucjvdEdpburEn3pulOfbtGF1YjWZrVgoX/M1qGUTHSerDULPdq5UNriIHPM6b3x6nriyQR7iDUsWFZnrAemImjf6ZitOwLYxmupNzaiLS8Tzty1rVgaE3l0qN+IqU7WoEFu4UR5TbS7J7MLmYEOVbjP2kr4RPz90Fyl/pQjgTRXxmy2agR49CPe3M/bO+jigXUGuzPyWwbIGAjYjM29kz5RNRos7aZMSaX4I/sceg7qlSVm4fjubjH7m58VTR6Vs5PcmDpLjRp+3ihwhe7ctQ783EFP0uvjDa5/Lih89C1onqkG/LkXihXkr5ev7Du8hZRJ81U/ARrIDxoout8UzIXiyvqxarNhUIeeQTsibxJ8pMUNAWg+AmPNTHztRmZAKzN07T2Du5mTIJJ1/0EgxpHux2FjpXjeltFhZtVwHbMSlbfxGnVuUNrj3u46AR9xASFxbq/tSyNy4gmW8vqqkIiWZESVVd8uzC9J8Mvw59ipUlf3faZPkZ8xsf/0c23J2q43cdj1XVxCY+wdZTeAsTnVIU6Caa/7sW7tEzh/0w8l8jqpARB6StUc1DeY30FP37TWUD87nketjb4DUH8E9KlpufGZ+GoGuV19xr9Dwfl1bq8x9h23cufoVRFXAEujU4arI0f3tw8b09QYCcxrhs5lBTAJhUXsdZdcYd4O7F8u1/85XF2VI7PD6us3VYmAbX4MDAgK2PgKJHtAouDIN1EKG5hjkj5l5ilN7zoEjxPf/+E5ax25KoXMTiTabyRGw9aAIcV/DSpPsdpX6uzYKcTNbO7TLi9z06w61j2SL0kWGVEJSwoeoLNu4m1v9XFzl4FHgfH3AduDId42Y/4qgRB/9K03znucLQa1XDqjnRpasLzOQyhllt7zl/CN6iiuPGCNWbPRrs6uMxS7FotFkKtd5wzHjJelz/dHjREUN+ri1cuxCTAYC3Y6oeaNvtuIEbOM0+bQdo6kZdVFEvE7kmWQkPR4oCTfHCI0yqV658rHZqTFu9i5hDia1yefJahYFsomz0XVlA8/45RwgDtQ9JAvMB1e2XNeiQrHvsB5iz0HdxIdL19vlMpBtSCRSNpnM+IfO3FucsrlKyjgBiIIv1pXF+u04JIKO0spMaQ/z/C55ZJYcdypY2tZg3hvslRrLSAzodtgkqh84fZLUqseOk8V/CRr8HkKVijJb1jL2Us8+jaMD3hjtZ87hq40VYum6cjGwe1HsjE/miupzQsD/B1OGiMunjxabq2olYduhMF8GYZnjy75IrnFR/o/t/G0VKVHnFkeiIZsMcp4FmbYvzV8dWcXTGFuLfbnhmHFJstEIlrFWn/Cnd1LPj+/yzGgUWVZdK8ePylrlPSRZGFv6mFTrBEFvW7a/jh0puzWqYsAMWCi5lLteWZS2rjRGiz8OqD4kaEfALM78oZll1NwAkN8kwCDrZPYCsO01dB+csUo1q5I1AyaBrjfHNMe0a99hG3e2fgXYA+wONkcPOikN9iPueCPtGDqZffm00fJvgmy6ZBsSiPSGqneskRHct9Nn09eGR86enOFfmKBSiECnstO/e3WRNWkGMv6Y3fvLoElAQEBAUxBI9IBGwbXhUE7IB8s2iEGbK8X08f0kQfXl+grpfNAkEQ1VPVKPk3Dl43OkPlog0AOyhdKe9nWJV+/jlEXJYJjEMlnHcTJbmQ9kesbNWI0i2aJKYiGV2hfkOuU+orJss5Go0M/FVQ4elbUZBTazaLzGIYfVvYMU5Fkh6XPMbgPSSEZ9Qw5Z4SvvxD5xTTRecpXzY9to+Prdu9+WmzNf9g3jgHPTn6/MXY+TlmO5zoD4iJo3+mYrzr2N2+RzayAjqJaT/npjMt5Za1/36TZ/tlbTJt9CfEE++6SF0ExHwx8iGeK0S3GB2KmBKNbvYZREkanXbtqy6/75iThr/+HiTUsmuWmTmceU0w/p0UF+H0kPiDBsgA2mDdPtAJU/NFozSQQdKkAQ1dgM0jU/L1c2EY4jU9IacPtxu4puXbuk3RueJ8HTz9eUyusja9MF7DP/8BkP2qWXJJR9hCrSCjc8NS/DBvMewVV9XMfVAc9WhonXmHvo4jOf1NiJWgv//emajPGBTfrGkO5Z971Q79vOn2fw4LtLZcXnD0qrZa8Q+q24Mrc5t7zcLBepiAxyJDOkLdFIdJdP1Fhbi671L47bTQacmZ8kM2BnINDRgdafH8Q5gUOX3+Ozp02RKWlLiFMxYN5LgrpI5ZnjrrFa/FEgGMecj5LmU/OH//7nszXuTO0RPeW8ZjxBcNMTLIrg9gXfPl1dKquxXYgrCeUad8ks+Xrx00NGSgKcarP1pdXivSXrxZ5DuokfHjBcShgRrMNXJegAsGM2Hxn/muSQC/75ibx+riHpF+eJv7271NoDjddvPHZC5D6LKjl+18ziV4BAj5Jy/OSrTbJCgDEkg/aOJB/p30wf3arX2oCAgJaBFkGi33XXXeK2224TK1euFLvuuqu44447xMSJE62f/dOf/iTuv/9+MWdOcgO15557ihtvvNH5+YCtA9eGA8eVTDYWw7tOoMQtV77GJoMIuK2EWi1s6D+GhS0gGyQbRbaXTlQcpzNKBsNGLEfJlOA0qsaQ0377uvUzjSn1jZMZJ+ehkW0SJ8s2W4kK/Vxc5eAq640w2uuWjJRXF672lpLqUjbNQTLrG/LigvQqBUWok5U7ZXhP2dQIJ55NjSL4zCxJpVfPc+RaHztn34xKGz0Lc+KQ7s5Mya2RebUjwlZJETVvVJVAXGxP4iROoCubQIseWIoiek1t8lRWa05ORvbdhYeNkhv08po6uYFesq5MTBvX13oPuZ4HTt/bKlFE5joZ8DpMW0a26IKVJd7rhDBQIMCGZrTCjAn9Ra9O7axBsFSmnnaN2IFPlm2Q0jb5eULaEFcAAF8njmQG5fxs9E+45902Yxf+8cGX4r3ln6Xdj6uOGCu++4e35bhTayS21yRKVKb47S8sFB8u2yhtM3bZB7KJXUQJ97cxOuCNCUope6NXLbgqGEx97TgBbwL+cfti6OdPk0A0jgl+qcpPfue6o8aJU6cMEfXCrkXfGBI9Shfa1ufA5hM1xdYmm3K3T60JPTokxN/P3Cft+WUjF2ODb23Bh8nPy5G/0db3MXErBvR7mSQ2s6/oaixIfokjzafmD/+d//Umpy7+BYftIo7/0ztyjMTZa0QF37oXF4oSj3RS1BqiV9SZtsPlN1xz1Fgplwg5jlY51VlUNyLZhmTKv86eLG57fkFGJS8VBGoeITHDfkN9htep9rr6ibkZ/rJrr2U7vymOxu9pe50IKcdnB3eTzycqGEez04CAgIBWT6L//e9/Fz/72c/EH/7wBzFp0iTx61//Whx22GFi4cKFonfv3hmf//e//y2OP/54MXnyZNG+fXtxyy23iEMPPVTMnTtXDBgwYLtcw44Kc8NR3C5PbmyuOXKsmPnEXHHugx+Js/YfJg4d01cSVB0K87eaFmPAjokLHp4lJo/eSZx34AhrBoMOSDaaCLkIdLXBolEmRArNScmqJFPDlyVBdjLzAOLIdw56FlUcGZW4mXHo6/I382dzRY3oVFQgs/N9ZdnZlk3r5+IqeVVZm0o+obgwX5RX16YyE4GLWCADvbnlDfQNOSWnKhPRJ/szcXB3cfWR48TVT8yxapDzrGgYSCYOWZVnfXO4uHTqaFFTVy+lYKjAUZsAnsfVT86N3LBn0zgvIHqjyFxoamNPHdnKPOjg2bJRLq2uk/Of52uTWWkuLXbfsRhjZJuxISa7TCea42zi1fx+/Nx9Jcm8oTyZ9cn8hlwAqtKDzDG9CZt+DzmPE+95Rz4LNMTLqpKSCkqiKErmCr+DDG4fenVsZ30+HIdsNcrxbSXoEOUEWY6c0F9KQKmsOnSXc0SO+Pk/Zom/nPoNSRiY9gHCmMzXuA1JTaJXPdf7T/PL5rRUTNipq/jJ1MEyWx9yBrkt7gfPUl0fGsWShNHkHPRMcV3r3lUtoOBb38z7H0VI6WtznKCUabNvOna8HBN69RL9Bq4/apzMiFUNpEkq4XMmSeSzS8wJ1h4yum1rEsc29aV10pjvHzKqd2ougb+9u8yaOfr395bJ+be1JLSiMssJZquAgVk5hh9GxqoJ2/qpB80a6/cw58ls132qdnm5TiIPeY6pv3ldShG15mBYHDSmYsD8jvl88ae4580lU4fvGSXNhwyQ+j3+i0TLtU/OTZsbrGVUWf3gvvelBIjKRveB70Stz8xFssJdBD9rog/MWb6LPCr2BOlAm9+g32c03wd1L5ZV4Xzn5//8JIPIJsj3zuL1KRulJFCoFOfYlz+WLv/GnDn1L++LP56UTDZS84V7pirR4vg1zHmuifsGuPfdigvk+eqVdwQBF60pTbNbuj48Po5qJuwCa5Sqjgq+dkBAQKsl0W+//XZxxhlniFNPPVX+DZn+9NNPi3vvvVdccsklGZ9/4IEH0v6+5557xL/+9S/x8ssvi5NOOmmbnXdAErrD/tX6cnHdy/NkJhEL4Q/3Hy5Kq5I6c74Sat2BDgjIBm9/vk7MXl0tJgzoKnp0SBInLlCu6XPQcQYh0MmSvNbIMPZlSVAezRzo2EAWRGVRZSOjEiczbtm6sgztRNWYbGDXIlEFwVuRTtA2ZhOkzoVAGVlXts0om4wX5q2S5DSBCDSJdegkAyR3pyz1vdlk0QgKHUsyanyEpE7ckT2rl9raSvuXrSsXvToXSkL8RweNFJdPHyPa5+eKmkS96NI++TtyEzF9jLj8sS2ZOHo2jB5oYfMStWEPmeqNg49g5nXGaVMae+pojMwDWLmxQpLnM59I33Qq8gsJgq2hxW7C1RRZSRe5YCOCGdtojo/s00mu6Wp+uwJT2Am0rcltVUTji/NXy3Pnu7recDYkpiIQXHIZbJJdz0f1o2CzPXPGWBlgw0/BFmGTIHp16Qn9uEftPkBm9T5+9mTBLGf+EiSBNMFWnLn/UPHrFxfJjb1PMoP3bf6QLVDTWsB46tejWNTV1ov9f/ma9TNcH9rfZmY1FUGMG11iyJdBShUBur4uyPuvrVFRQY1sSBXX+s2cJjDFePDZm6ggkQ3YChIA9LWvY2G+DNLqY5VrhmSCfDIzgXX4tL8bYyOjMshd99/MLCcgAInH8zhh0mCrPblFWxuz8aVAXL8Hn4psW9NuY8va5yWJPipnl60vl++ZRF5rDobFQWMqBvTvuNaLuGtjHHQpKvRK8w3v1SHjd/j7hmMnyAAxTUT53NuL10m/Dt9WZTzf00AYu4BfGjWPeJ8G80N7Js/B7EtCZaaz6mFED1lNJcn++96XgRtF2ut+g+s+c1zI9w+Xbkg7LjY5YeitA46ngqH6XBvYrUg2VUWarKRhj9G+ME+cef8H8vyvP3q82FxZLYrbbdl7uPwazvX4SYPFfW9+kbaXMefz+vKk72ADx+D8P1i6wVv1SkCcbPT5mzfL5s19g68dEBDQCGxX1rK6ulp8+OGH4tJLL029lpubKw455BDx9ttvxzpGeXm5qKmpEd27Z2oJgqqqKvlPoaTEXwYckB1UFghdxinDVovf+X/7WC7e60qrxP1vL4ncFMmN5bKNop+hIxwQ4JvH6LB279ZVfPLVRrHrTl2c5K7Sqca5x9mzkbBssNigmQQ6UBt+3bnUN53MA/QFXb+vMiLjZJeCuJlVkMq+5kMzxvcTy7VmbsohjWrSY9sEKQIbwunao8aKqx5Pz7I2G8rZdGGVRArnka0Gpmtj69p0KfKTrFNIBdXIjcwWeX7LNqYIbzYD9582UWp2ZmTJN5SksmF/7dM14qlZX0fq7nN9uRFl8XEz1dsKmnMtjkMwM2d89y+bCgBbMIusSL775RcVGbaEYy9ZX57W3FC3JWSV+qpimkuLXdqbh9FuzWyKPPurTU5df5c2ua73r5MivkaakNKs/bO+3Cjn6qXTRkcSjVHYUF5lLbvn/C46bJQoyMsRPzlkpJSXsckruMhFJAdsBLr6HUiYxz9eLmoSQgbSTFsBaXDALr3F5vIa8Z09dpLa8raM9V+9uFC0tXn87d+/Lb45dqC8B9jTLxuaPpvZkJsqasVVM8ZKn5HPsG7SbA/oMgkQVxA0urQOSGZfjpRyJAeN6mVtzLdwRYmU3mKeYQ+iNMqfmbMyZbd9AUxJ2j78iVWHnd/CRgzrZV+rG9vnwrRTu/RJHt9sYA74m3GJZBEVF67raIxsje/cCES5fJ84fQ5Sx6uokf4D53afw57gPxGIIGiVbaUOfo9L8xlfgPuAn2P6GYB5TBCQ7w/Ky5Xj0kXmtfRgWFPX4sZUZ+nfca0XcdfGOAkV+u+Z0nzK//TJArEXpZoG8Fm9eb2X4I6oTtNB8BjbeOPR42WjW5lRXlQgM8V98iVUUSmJJjOorvsNvl4QzFmTLLfprStgJ5JWWkT6zLx+0p/fk+sf6/Rpd76Vsq3q/MxKhIHdisUtz83PkK36jzbneS6+AA7Hu/rxOTKRz159kKwY+fYf3kr17KDydEeQYAoICGhjJPratWtFXV2d6NMnPSOKvxcsWBDrGBdffLHo37+/JN5tuOmmm8Q111zTLOcbkA49CwSCSt9YqOj//T+YmNJBd5XVmTrCYTELiDuPyViiWdbEod1lpjml4tc86dapHnTSXuJETYdWJ2FxztC0tG20Ac4dWch6aTRjVc0DsjoY32Rq6sdQZDtYsanSS/7htF//9PzYmVVsIly6sMoZ7q1tLNQG87bv7prVJsgksHGAr5w+WjboQVPR1mwvpZFukCCNyXjzbWx9my7uGSW6ZhOofY3KgrtO3CNjM6COT5CC873kkdlS4sE1PkwtzIoav7xQnEz1tmQLm3MtbirBnG0Go0l+MR8ufPgTZ0CHZ0dzO58tYe76iAI0U1XgxyR74mqxY09cOrTYGZeu/3VHj5ea5TrMdVonKeJoxPJ+XKIx6tmVV9dnZBdyj3p1LBS/fulT8bJGrGZT2RFHluL3/7NnBoGunimkAU0cX/10rZj39SbZUJF7ppee3/LsfPHjQ3aWJEhbm8fqHmBPj7zzzchsSDTSSyqqRSFi84bshxznCSGmjuubJq3DPaQ5PZmhFx8+Sr5urrcct59GFJdVJYMaBHRcero6YYN0AdDJ68LcHPHlxgrnehvXZmcTvHPZKbL5o5qd873rjx4nZSFcusxNWV/0c1PPOJFIpJFgnCvncF1EnwMFfDBl33yNAQl2MZ/NTNqoZ4HeOxU0ZhUZ546UDTYNH81nt5Ggwt/B79xR1+LGNuFlLLAGRPXjiFob4yRUNLaCLG7zeo5tq/A654ARyeqkGFJ95vtmvxY92EXlFH6Nq6m18nl0kjmb5qRR8kumv+Hzma98bI4MgB5x55tyvuh7D/ZotjUBX8fW90Gf8wRbfQGcyQ0VTcBWfUD2vh58SAbG5siAa1vytQMCArYNWrV+xs033yweeughqZOOProNZLmjua5H3AcOHLgNz7JtwsyotS26LFRrSrdkO9jK6nbqViTlH5RTECe7LmDHg2sen/fgxyK3XTKzmPJ5sg9tWp+6TrWLhMU5m79iy3i1Aee4e0PzQuUk6xvJuV9vkht7QLlgMjsmqT9I5tjxEwd5j//VhoqMzTGliWRAkwFDFni6LItfG9g2L3E+0RSOu8GwEdhcz6WPzpEbl1u/s6v47cufZTi1fEZprPJ7Tcl4Y1PVGEKS5yObrkZkjlOO6js+95nnEvX8dC1Mftvl7LPZitKkbmu2sDnX4qY0oDPnrJ4NtXRdmSRafBv4OAEdNsWVNf7n65u7EFRsUHUCXA/8YAuist04T6SXXGB+UraOvaqurZeN2Dajr/zlRiltMaZ/F3HipMFWO8rYJNNf2ZC4TdCaGhxSz27XgV0liaoTBNj+D5est2YJK2JU14q2kRtxZCkYH/qzN8dQQV6uOHRMHxnwsGVJg9P3G2btn4G9aO3zWAYe83JjZUNCamMvK2vrxYOnT5JZ6U+eN0XqI+M79unSXvaZIOBj3i+OxzNU6z3o0bGdDKQoeSCTKFaEFJIArOU2QgpilvfNSivWuvMOHLnNgne+qrWTtSx/GxiHfG/R6lLx17eWNLs8mHluum8PiUhAi7VQrfVxJWwUQRZlT5BnW7GpQj5Pql5tjWpJZoB4U3McnX70rm1VZNSM0aCdc1q4qtT72/TJycuty5APNO1AW12Lle0sraoR1x09Tq4dSvPf59vxvWufmicDix0i+mP51sZsEioUCQ0BDQHLP7TSXRVKPsgsbK24EFvlCvDRW4M5R+8H11y32QJTjinNhq0uFcfd/Xakz6OTzHHX5Sj5JT2xRh07ymdmDWBOMF/0vQwVJA+esbesUj9tyjBpv1kr4zTjVhUmrr2Lft5m9QGA2DdtBeeK7F5AQEBAqyLRe/bsKfLy8sSqVavSXufvvn37er/7i1/8QpLoL730kpgwIZnlaUO7du3kv4DmhVlOb9M8ZAGFJNdhLmxEn/W/6RgeENCYeQzh9MMDhjszL1zjVJGwo/p1Fl2K/SQKzXO/9av/pJxhspH0TCzIgl+9+FmaU0yWg5LtwOE2N1t6lmnG72nH1ZuxbZFlyW+UFqkiweKUdEcR2HzX5dSSEZgsjxWNBpsdst0bs+nyyX7omTg0Q4pDjkRp6+pamL5yXLIf18fU0G8raM61uCnNPtWY8Ol4K91dW8k4xHNUQCdZ1RLR6NjRAyRFUFkkWACZXGip+ggAJTuBvrAPBOW+15AR/dT5U8RxDf/bXJddY1ORFGRv+qDPm6YEh9SzU1U/+n2ZMqKn+PVLW2yvDr6DhrFeOWSSF9hpNa7Y7Js2euWmCtloUG9a5hxDjh4aChDt5vjVK5Za+zzmGcepUuA+byivEVdSgt/wTH9jSCCp4BF29PsTB6U9E8gmXa+YRqa6PrAJRUitX7LeKcXBc79KBrAySbqzDxjRLME7W5CHeU2AJko7OA7UfOM+bQ15MM6N52WTRjn9/g9kIESXoIub9a7WzCVry7yfgwjl+ZE4Yc4zNSchzPVnyBxHyuFtrWmi/mw3VdaI0pUlTrus0LF9nsjPzU1bg2x2YMnN00VbW4sbU8GljxmksvgX1R/L9wyyTahgTDW294x5vbICc8YYSZLjE/TtUpRRIabOg0bzLqkhKkFttsAlx4TtICjEukwAyfxN3efR/c44Da6j5JfMxBp17CifmYQlbCnzRd075giBDltVaH5OTuS56lJ9tr2L0m3P5nrbYsJKQEDAtsF2ZSwLCwvFnnvuKZuCHn300fK1+vp6+fd5553n/N6tt94qbrjhBvH888+LvfbyN/gI2Dowy55tmpMsoOiuoltJVpvpbC/4elPaYi0bgmkZTAEBUbjzhN1FfvsOqTH1wdL1kQ3dbMAhJmupqCA3o+mZAq+vLqlKc4avmDEmUhOYrBkyJ9k8zPl6U5KgenVRRknxvad8Q7z7Rfr3fVl8/D4OrU8HHhLwawvBpTb7cTa3UdnuaNzu0rez3BjEbfoZF2oTQ/DBB5oC6plFKluKDCQfVPYLmWr+4yffn718k3N82bQw2QSRWbRoTWlGRi/P1qXTG0UE7+hoSqm2WrvO2n+YWF1SKQMpZFzrwSyOe8PR48QllpJxpDh8YPyjW8y889kS15iLCvxcfcTYtEacZlY1JG+ShF8ndo3qQ9JgD9ngMjbV+fo0pM2xqe61r+pCt7tNCQ6pZ2eramuQ1fZu6l1EJn9f8sgsOXZuhcRr0LM3gyv0gtAz5px2f9E6wadsmrMqWeDHh4wUl00bLf/OyRWia1HT7WVLAc+Y+VNaTQWSe/3g/lz5WJJU0ZuK6lB/sz7e8tyCjGeCJNGzc1ekNXaMqnboUJgkdmzwkf40GXTZf73via3KwTevef3L9eWpZru6dnCcxqmu+aZIo+aWB0OPnvuO5JNNGgX5nMaCNZNggnl9KvmAJrRkFDMesNcPvrs0bZ75fDGISNecXLquXJzzwEfioTMnee02WdeDundIW4MmDOxq/c22hDj9fOKsu8C3vjC/aCfjavQb5Y+a72dz3vrcZR0lyKckg1wJLaY0YNR58rtShjEiuUOdmy0AoP/mnoO7yWQVHSq4TSWay07wOtng5msEk6mSRLaSdYo9+erNlTJ7n+ehjm3bV+hAzo65qvZMrnmZqgrd1+0P6zZNEd763iVObwbf/i+qAi0gICDAhu2e9ktJ2cknnyzJ8IkTJ4pf//rXoqysTJx66qny/ZNOOkkMGDBAariBW265RVx11VXiwQcfFEOGDBErV66Ur3fs2FH+C9g2MBcdiAcIzVyRk9pgsBlh8X/g9L1ls0azCzsNqJ6Z87V0TvYc1E2cvO8QsakC0qvpndkDdgzoci44SadNGSpLLK97Kl1XHMec8aW0T22b6oNvf01ughmvbA7NhnA4qiff+16aM4wEQtTGW2Wgg0RCiN+9usjqSKIdfuq+yUx15Yz7jsvvIxkDqUbDK1P6gdJzMuUphW8KQRuVmUU2PGT3DU/PE8fusZPo3bmd2FBWIze6NXVINiWfT7ZQmx82Mdy/B06fJIkwUx+aZ7NqU6WYs3yTmLBTF0na8Ltvfr5O7DWom/c3hvXsIB47Z7LoWJjn3TjzPveNZJlzDhwuSQQzW/LcA+1ZikgD2LIem1MzfkdEY5vjsXYxx6aO7WfVA1eb02UbKqwl4+ccUB85XziH1aWV4soZY622hOaSVQ5N3ShdbkgcX2Ygshjq7zh9SNQG96Zn58vM9YTne66xqRNKehY3gBh+af4qec/jyNCoDTG+AJt4srbXl1WJjjzfDoWyodlRuw9IBeXJzJu3okRKqPjA7/uITJ4RRBpZbne9kmmj+R4SOwTFlK1ojOYs331h3kpRU5dIu0f/+XSNzKbXAyStEVxfXV1Crkfjd+oigxuK8DQzNvX7F3Uvseu2Z8IcRhJAP25UZmGHwnwnYeMD5//oOZOlLEVaw7qGecE5XOTIeI2jt29qB7vGMY1zrz1yrLiKdd9S5cT3bzxmnOhaXCD7EiFBx5q4eE2p1HZuqhb6B1+sF0/NXuEkxGiU2BjoJOaV08eID5dtSOmp2yo+1PXqWay6LnI2OtAq4IBP+dCZ+0itZNNu04SwXV5OKkNYr8TxVe60BcRp5u0bV/qe0bW+cI/x04/+XbLxoy1bPMof1d8niYTqoTjnbVtLdX8gkgQ2gjMqA9uGODKMnBtENefFGCcRR9lPuV8QOeKhM/eWcqjTfvu6XFuxQWqdU4EAArW3Pb8gTVpMabfjg6i+K4z/Eb06ip26J/11vdeTWs+pEKEBKBKV7JmiEo4IIv74oY/T7LurEpfqDlezcN1XMYPwcXozsP8jSPvOF+sy+szM/3qT6NYh+NoBAQGtkET/3ve+J9asWSOJcQjx3XbbTTz33HOpZqPLli0TublbspN///vfi+rqavGd73wn7TgzZ84UV1999TY//x0VtnL6wtxc2TimpKpGlFfViV4d28lF/ponMnUIpWZaQ9kaGS2JnIQ4/b4PxH2nTtwOVxPQFqDG2KWHjxZXzRgjausT4ou1ZanN0QPvLrWW1uPw0YAP4Hxe+M//irtO2EM6uvzDGcYhxBGdeeTYtIyTsupa+f242oPjB3SRkgMuRxLdTj2rJeq4kAU4qnsO6SYzG7lmjp3D/+UkxJ9e/zztmhtD0OJg+pxlmXX49Dzxo4N3lsEyc1N0wzHjxeCGZk9xm6rxOTamqsT/XmPzQnULtgVCEW1GNk5opB7TsPlSzvcho/vIz9q0ibkX/bq0l78/d/kGqe9JQyRz40yTxc2V1akycwhxs2ERGS4/uO99WcZua5Zmg8qmffZH+8nn1hTN+B0VjWmOx/2FoILc9m2Izf4JCm95slEZL2pDhhboGfd/IOcbzbX4W9kSZCfuOWmvJum9uzLs0A5VsGVsD+5eLJ6duzJlY3bu3VF8Z48BYvPYPqKssk5cMX2MzASkP4PSSwdUlvjGpiKUpDzHY7OtlTZDuhdHy9BYiAw20Sfd+77Yc1BX8b+nTcoIyvMZmr65qt5o8tmxMF9U1tV7m7Vi75PNmt1Zgl9uKJd+DoR6ttrHjA90YBMiIf78RqYEzMDuxa2aRFfJEWRVPz17RaqpvC9jUyHqXrrmo40Yjap2gFw+/6CR0nbr44XX+3RqnxbI1sFrKzZWpvVdQft7aM8O8jv0PXFlvLpIcZvUAN8hA9T0sfVs2LtfWyzntQrQM/9eWbAqlcFKsF7df75HE3CCGkvWlYmduiaJsLi2Uw9scc1jB3QR1xnBef15RPX7sMEls/T4ufvKgDw+hste4+8RDOe5JxNx3LCNMz1Llev8/h/fFo+cPVlmAat1WVbr5OWKvsb85B4uW18m7QoJBNh5KuPaGprazFvfM5rrEn6vWlt1+2DLFo/yR9X6q5qPUmXmA1UTX20oF5c2VG+5/IFsAqZ61Sow/f2o8aFsAfsXqiNs9pM16pTNQ1LnRPB66fpycc9/FotR/TvL38KHxqZdOnW0OHWfoWJzdW2adjv3VSV48Gz420xgUfaGdZJrAKyBSLXSyPWaJ+emNfJWSQL4OKoXgn4fXMGwIyb0Eyfe8674+bd2FhceNkraA7MXi5kA5OvNgPQWmek1tfWyNwQNYt/7Yn2a3Kban7SVCrCAgIBtixax0iPd4pJvoWmojiVLlmyjswrIppye0vjuHQvFFY/NFh8u2ygXyt++8pl0LEzHxHQ8IDNYdH953K5BwiCgSWBMVdbWiaLCPOkck6GIM8mm7mff2kWSqre/+GlKWxUM6FYkXm7IlMQJu/6Y8RkyDgqQLHrGCZmSZG/yXR+6Nkg34EBHOZL3vL4g9RtRmoZs7sgs+2jphgxynmv+8cE7yw0mTdQ6tItH0NqIbko82ZCYBDNONNnwZKCbBHoqWPbobHH7cbtJojiOLqXaTNPE05b9wzWeMGmwLO13ZRGrbB0hFkgikPvuy6htX1AgTvrze+KuE/cQl+XlSr3HTkUForauXpz053dlcI9zRBfZ1rDIt5G0BRzVcyJrbl1ZUqsZIiaQ51sf3GM0TfWS7LjZioDNJMGSmZZMReYJjbOQhmK803TXloHrIvqYezQsc5Uk65tIV2agaTPM8UrQ+pNlG1ME+h9P2ksGtM3gF1n0J97zjvwdCCpd49gH9K1tZAQVF2TPkh3oagJsCwqYmX74GDSn0wNjfOaTrzaKy6aNkc/FrHq75qhxIjc3R1z3WLpOsmkzBnRrH5klyOdemL9SPuuohmQ0unzuJ/uJkgoa7+VLYpnzfH/JeqcEzN7DeojWiIfP3ke0L+4oXpi3Qrz26drIjE3GOGuvQmP0e23EaJxKK2wAAZ0LDt1F3PTM/AyJGAI+BEXNOctYotGp+rxaA1kbmPO+jFcbKe6TGoAMNiWrzPXQHOcE+fcb2Uvc+tyClG3S/Q09qKGaGPI7qspDNcTW13/s2cwn5ko5utR3IwIierVMHPhklq59cp64bPpo7z6CCj9sAuA5+EDQQweBt58csrO8ZhoPquAaPRT2GtI91vl3al8obn5uYdqYb8ma6Nu6mTdgbFHNqdYatS4x9i+ZOkocccebsbLcWTuYc5c5/FHe15uP+tZy5gZ+HhVIUfvUuIkyBNivP2ac+M1Ln8rs5z0GdRPFBXmyevGtz9elyGhXIMAmx6TOA+j7D1Na7I//+Vz6xubegt+64LBR4qwHPkzrHUCFCsEfAClOg+cuBOLLa2Rw7oz9hon8vBwxcWh3WeWbEfgd2VPMPGKM+NmhO4uSivQkgdH9OouhPZKVnowNJaXkyua//qn5kkDfd0RPWX12+wsL02xlUk4tXbbG5gOpccW/5368n6zGHTG2rwx62/YnJM40Z7+IgICAHQctgkQPaJ3Q9X6H9Oggyx9NbcuoLICC/FxJukM49O4YPzMmIMAFNn8je3eU2ZQfaxtecMioXuKfP9xHNg4zswAhl75YVyYdODLNFq7cnCLbGZ/9uxSJqto6+b9xjHHU0e5kk/u3M/Z2OsVsnAf3KE51j49yJHcd1FXMGN9PahKS/RnVQFEFtGY+Pkd8b+KgDAc6buMnVzbYt0b3FldTOj5jrMwGROuQzCECCL07t5f3mAwsX7MnNtVm6bkt00jfTOPEm9k/OP589r6YZbW8hqOtMgdV0MEMJvA3JPaRd2Zu5NKaNhUVNmojefn00eLkDRVSemL28o2yIsHckGTznAKaBhvxY8Kln8l3axP14pfH7balB0D7fLkhxTaY2ai2DFwb0aeXT/N5Np1m4AeSAJ3/xWvL5G+5ztupNzuypygqzBXnHjRCnH3gcNG/S3tJSts2lwS3CTSRqRZXxzxK95nzxj5xHYMaqlNc3zWz9wZ1L5b/Oy8nRxJd2GA9QLFsfbl49KOvrNdCBtozs1Z4Mw2xY9i1Aq3yUYc6H6pqIEQ/W1Mmy8ZdlS77NVS6qICBWosgLVwNUFuzpvJ3fv+2lFbj+m58ZqHz+iDMeI6M0+fmrIylww8xZZuP6pkM7F4kCVAajTJO4viRBNpvenhBxphQY5DMcbOZNwH2iupa8c2RveScJ+tVPd+oTF0bKW6TK1Ag6G1KVrUryHMGcLmHtXUJKZ+j+yE+jXAITdZGjsk6zzVfTlNV7fx4PiQKQAAq+6UCPiTPKFkivbrD1e+hUXrxi9ZGNhbX7bmvOTA+GxJukGscE7+ka4dCa0D+27sPEHGwfEN5RhCyLUGvQvjbGZOkTJ4ZFI4rEcgx9CoOlWlM1ZMPZnICa4dt/eV4BFFIIFHPw2dXGO/sBY6P2Keqc/UBEhrbx/hijSAwA5Fv6xmg+hkhQmQGdZUtMANr2Dru3WFj+4gx/TrL8cw9V8k/KinINtexBzliYco3VoE1iGr991VmNmv/S9qahjTUX96w25Brnpgnpo7vmxGgo7cIVVWDG+RZGUc+qSXmOc9D+QX0WEKKJ7nnyBfrNleJp2d/LXYf2E0U5udK20umuatqCECgE1yTAU5HdVlz94sICAjYcRBI9IAmQen9Pv2jKanFWCe+ohwPNsQs5mgaryiplAtjWMwCmoIBXYuk84VjRSb2FdPzZQbxhQ/PEqP6d7FmJDB2lbbqWf/7oXRg0Ua/5bn5Kf3Gm5+bn6GDSuOc/7fP4DQ9YTOjE8JoQLdiuRnmvCBqfI7kKfsOkc4fpC6EGdllUvPcyMrguGqu4Iyftt8wcdcrnzmbkEZlW9iywXBQIebReTUJPTYBKkOJrC0faEoUR5dS30yzgVAbA3UuPAc2D1FZQzq4l+p+v/yz/a0ZtXEbVdqyyvXPuohR/dpvOna8dUMS9zkFbP2sOjbENKyzgTmtmkDqGdXMn59b5BzM4I5NUsmce3qpO4AYZPzrGaEqgyyu1j5EJDqouuQR+um2wB/gdWRosumh4JJSUGQnJdVnfnO4WL4xGYDELiroJKSrWkcRej/4azJLWA9QKKksG3p3aueVaOG+7Dawq7TPECA+GY304GtPce3RY0WumC9eWrAlU1c9Y318qDGXrQRMa8E/z9pb5LTrIDPuf3LISPHH/yy2khtfrq9ISRSo+xql33/BYbuI37z8adpxnM+EjMUjx8q1s2N7d4NrudY4xgTzhgou1ou4MltRNkUnxVkvIYeQSjIlLDICt5pk1XtG43ETnKtJOMeVodilX+dU9q5pBxIWzeePl20UM2eMlX6TOUe/v9fAjN+yrYVx9eLbF+TGzi7nXjH3ljqaA++/cy8xql9nSai/Mn+V+NMbi60BeYL+d8ZYiyFx2yqBbntmU4ygcDYSgR3bFVjHomstU7AFcc31l3NV6y9JLQo+u8LcIFDGmuKDIvt9jS/RJv/vsg2y6pKxRWCAJDLku1SwV32X5Bzu35nfHCYunzFGLG8IIijpkt0HdU0LrLnXny3PgnXF25tp0Vpx2n5D5b3u26W92FxRKy6eOlqcUlIpnzH2UFWOQjzrJDr32eVzc9zLZ4wWz/xoihwP2EHul96MVI0N1nwfyqtrt4y7h5HXWZu6fs77nc/Xidue/zRtPvsqYtS4aaoUUUBAQIANgUQPaBLUxgENdAV9kxjleLy9eJ3M0EJygahyiAgHNAU4VfX1QlzxVDpRDtnx4Bl7i1UbK6UzS7WEylBCK7drhwJJOpGZdPjYvtIJ/s1LC6VeKv9cmVxXPT5HZtahs/fO4vVWrWylD8qmGe11fscHvkuWnMpoVQTUD/cfLp1QnEWccrQIkSmgwQ8kN5nbLkcXQghSAbg0yW3ZYK4sNp3wZbMPUe2Dbh98Tqzu7PKc/n7W3hnnElXdYpJUKpAXRQbGaVQZl2z3lagnCb10eRo9Y45mUuhaIwEUbOHWQVQwBLJ3Js0/a90l4ybU/HH1O5g+vq/U7baRcebcMyVYXvzpN8Ulj8xO+4xrbeW7f39vmdQjLa2slXYHu4EuODqo+mZT10+3oayqzjquXTakuF2mS+kjoG84Zlwq80wnIV12RxF69EPAjKI/3LkoX/799cZkXwsboohrfA824v86e7J8tlEyGgps8gnKYvNPnTJU2hqXdjyvsT5FJRa0Vnz37ndSTb55tjSap0mjSW7o169r2KLFX11bJ5tSVtTWST1gMv6Vfi/PRJfl8mVYX/H4nFSGtZqzZuVDlHY2ZPQeg/2NqXXEDbCis03mM/rkNDf+ZNmG2H1LoipCeN8k0ePKUGTbJJf7b+srwRxFakMPBrvWwrh68cC1j7Ct69gcV3Ngfo8KWhKAGCPLN1XKgIA5Tvmsbz+SsoMRNrS1wvXMZFZzTo7UqseXzaaHi2uOzPl6k7jpmHGystHsVxG3GbV+rjS71318qosYvxDa+KpDenYQz8xeIWVLgL8KpodMaKGC8Tt77CR9flslyd/eXSolvqRs4cOfOGXD1FxivBH0PWiXXvIaGUv8xvTx/aTslyKGfdWX6jf+fuY+ss/G8o3+jH4yun/90qcZiT4kDCnpNp6vavAZ14ZUViczvn2BMu47Ups+yJ4G6llqAU4ZwHvVPp+pBjMDfOp31bhpqhRRQEBAgA2BRA9oElikKAPtVJRv3SSpLICi/LxUsxPVwInO4ehOsnCTkcPrISIc0FjgNEFo3/ZCemkuwCG77sm5MqsbMv2Xzy9IK2s0y3mVJvDqTZWiur7eubnEmb54avJ/u7SykWVRGo0QwGwQfIA8nfXVJrHrwK6SGFebCgJOEGGQ+ls0EZMbQpxJNMRt4BrJeIHMp8SZDZC+QVESIrZsDd/GWmWQk9m9uarW2+zJ1CF1ObG6s8v9fHn+armJYbOgzsWncWnaH1USGzdbKk6jShfZDigbVeRifX1CPhfe47dV07HODRs87j9w6ePT+G5wK2802FIRJxjCP7NkXJdvMMFz9/U7OGb3AWJ4r45OEpdMK102ak1plWiXnyQTGGcmmeHKsPtmg3ZoMlMv+drClSXiUq3cWiGK0GXe6uPPt0lmXtBc3CQjfAQ0ZBv3mHPVCRab3dGDE/RhgIxUdgyNe0hYF6Kuk+ZjHANJAH2Or2zIKGTuRhGMNEWDJHdlr/IasljvLl7nldtpC0gSIJnkBrbclGVR6ybrpNK1Rn7n7P9LZqsr6NUZxYX5cj7GIX0VqavGmQLH8CGqz0ljbArzB3uC1jBZ8ss3lou9hyerK1QFDAE81xpERrZvnSVYZhKCvrHPNSoZCu4HWvCuHg4mkRbHN1DXoTSW8VHMhr5RevHMCaT1FLFn2jokdlZurhSfri4VndrlSxk/ztQn34AEpWqo6Gt469qP6HYwKou6tSJKmgsCPW6fDN8cYQzuPRSZj88yiOc4zajNc2UdIQnFlHJUZPe/PvxS/L+9k814OxcXeNdSgoEn7ztEfLa6VDzwzlI5j5Xvt7GiWs4ZUmII6N547ATZP0Amv0RIDepziQoV3e9kr6ACa3GqL3n9lM2VkmS/ZOroyHUuSrrNl4gSi/x2BMqumDFGBph99ovnxr1F0k4PgtBw22ZruD+sGVPH9k1J3GBbFq4okT5QYytIAwICAuIgkOgBTYLaGP7n0zUpx1134nEEWED/ftY+4urH03Wo+QwOFc5rkjDIDRHhgKzwxHn7ClFQJMcNDfnIXrPp0ypnE5LqtucXyMwjnLQDdu4lMzXJUCErSW3slGNJw1s6u/sAoeMD58bGWW3scfJcJAqOJJtaHMfH/rvcugnQNXtxCssaSiBtjq5ywnGwdakDfeOoMspt2RpRGShqk7lTt2KppUgpqC1zFzIujhNrOrtIAkh9aO1coqpbFEnDBujKIyDWEuKMKUObNavbJNtt5CKba66HLB+z6aq6/3OWb3Lq44MZE/qLaeP6hoz0rYA4lQdmybgPiuR1PU8kmWwEK2OHAJ9qyG3KRkl93j2SGeycqy2L98oZo0X7/DxRUZMMRG+qrBG5JTny3NncujRnfXOJuQtRqRC1SeZeQiyYZJePbMNWYBs5T51gMe2OLzih7BikiashK83OXO9xjNUllZKM05+1muOQmhB0PqjzjcpehXDB10EGg/XFJI0IiLYVSHJHC3hyfVceMVYcfZe9gaDu++njTkEPUmNbN5T7M8n1MaSPMwUazfrWEZ/0AERXKrhWtEUyxmdTlq0ry5BLMRv4qiCMEwl0nJNjx1xn8VVUpZ1OCLrmuJJI0JuQ+kjlbCsolG+AfaPvgq+hr0svXgUgOFcq6a4+Yqyoq0/I7+BTFOblyF5ML2s+nwxAHzgy9tiw9VKJav6s20GfDW3N2FoSGOYcYe5QzWMjnpH75LPZnCvjhWaRtjWYGY0/Sm8O1gugnp0epJOJXkUFolfnduIHf3k/ucclYaZhnXMFD3zNhfXAnq86kuSLcw8cKX1e9iRxqy+5f9OWb0olnZjAH0Y6yifd5prrvjGursEXdOHecV15ucIqe8mxeZ3xQMa6udbT78KET86LigA9+J9NBWlAQEBAXAQSPaDJqKypF9c9PT9D25JlmMUc/TcIdF90HgKPxmBkxgYExMWwXh1F587JdMsPlqyXGnw+lFTUSgI9ipBRRDqke5xszSiCeOGq0pQzSja5LatKyhscO15U19aKexw6neCyaenZJmqja3N0faSeep97gANsy9aIk4GigJawL3M3jhNrOruKKKTcm5Jab9ZQgxbu2tIqSTx3QKaneOtIorCRJruOAAYZsWTS7Tm4m8yg0YkHrs0k0PXz/ukhO3ubDLLpChJXWw9xKg/ijoePlm2UPRKcmqQWglUSMlL7M70hd4Y+72NzxQOnTxKfrynLyOR86L1lsszcbG6nAliuBqTpa3VOWuamajCma5ZHbZLRecYXMMmIDhEZv9gKnWBRDcV0xLFj+CBPnLuvmPlkZsBqWK8OkqA27xE295qjxopl68rF+tIq2SDdBM+re8QY0e2kj1yiXP/DJRvE3a8tlud8iib9xf2jMWZbAusDjbzJoJ6zvER88mWmbIaNTGLdcGUsqkCp3i/DBnPt0scZIOhuW4dVsNpForvI8OuPHi+fn82mqEq0qCzQqCAMlRIEqjk/SC8qmzq2z5NBot+89KkY2qtjWnCN5IDC/Bxx7O4DZD8Fff5eMX20+N2rizLusY1UnmJUEPC8CPbHl2bw/4atiaoZ1LTd05/9479Wm0CPg2zGhk2uxpWhatpBlz/S2rE1JTD0OdIcTR+palagasjX54P58afXk/612gsA/lbjXdmAm5+ZL/5y6jfEC/NWxjqfqMADtl7ZL9ae647eki0NmC9IM+JHMjdoIppN9eV1T82T/cmuejx9rvObV8wYLfuhuIAtsc11NcapCjD7rOj+O4EJH7jvVJyb/oGSveT1+06dKPp0aidufX5h2lyy7UN8cl6mnFTcpImAgICAbBBI9IAmA8dBd9xZHNsV5IqrjxwnlqwrE706+Uuhzz1ghNw0De/ZISxoAY0CG6qauqRD5gP64XGJZbC5oiYyCwON6yiCWGXWqQ0XTQvJMtGzXgb3KJak1fwVJc7NmMymMTTVFYlv28zF1TnFqSS7xrwOrt1FZtg2mb7M3bhOrE8uRZH8tqwhyuO/e/fb8ns0hBvcQLo3N1ZsrEg1LTMJOTJmPvlqoxjXv4soyMuVts/3LM8/0E1wgiBx1TrAmGMDe+/J3/B+jkztBStKUhmsOnkd1RSMbHLVkFEP+N15wh4Z5LAuY0GDRJ9+OiT8Td8eL7WU1XzDXukEehyCAH11Mt32bNCiVoiSO9CzjlVFx8++tXPa+caxY1zL52vL0uyq2qCfet/74pFzJlvfm3HHG/K7z/14P+c5+srB9eqXKHJJDxLq19NWM+JYkwkccH+o+gLmfVTyQ/iKHcuqpcY+awgBoMsfJfkiU39Y2X9fdYFJBJnZ7ZzXTc/Mt44J1VPAhI8MJ9v6vINGyibArGE6VCVanCxQn71nfFw2fYzV1+B+0SfFJi2H5KLqkcDxkU2gauUyi8ST6RvI4PRRY8X60moZnCYDlOxh9bu+5AFf4E39hquJahR89xTpO9ZjGzlrGxtmdjqf0eUgfHbQ3PvQWLctVNRuKwmM6N4E/nWHNQOZQrVeKDLYfbwtjWDVs6OnBq9TlaqTurzPuODZxjmfqMADfirBXBpoHj62j7j2yblSBkb5zPp8Yf4iUZJN9SXny56FZBJIbd2mrdhYaQ1gKhCM27cheI4vo4PkNmR17vT471HXzj4FSUmX7GXyGPnyM+Z12q4/Gzmp5k6aCAgICACBOWHb5gAAYTFJREFURA9ovuai2uKIo/33M/eWZOUJEaVohfm5okN+rugbtH8DssTiNaUisbFObgppmrNkbZm3QVB+Xk5WDbTIcPFpD2/RTxZegljPrFMbLqX3h3NJoyO18aa5qQ9shF0kvr6Zi+PYqo2j2vSZBDba3t/fa6Ak41wBAl+jQRNxnVjX53SS38waOv3+D1KbBNdGJ5tztX2e8fDGorVSasem8Uy98NRxfVPakrYyVB16LwkbXBJX2V7HjoTtcW9UIDmqEoZM7W///nUrwRwlnaQaFAM19qjQwH74CLq6hDtbkrlDpdg1TySbFI9u2LTbEGVLyDbmd+g5QZMzFXjzBeJ4HfIdIoQAp5JJOI1GnfsOTQUZ4jZHJLvYZds3V9SK/xo6ufp58PuMHZeeuS1QqpO6JrnEsZCgoBKgPpEQ5VW18jiMxx0hI471FjKTRnm6JJV+7azbVHBM++3rKdutNPZpBHrLdybINX2jhdxC95ayfXNtMp+Jer6swTo4H8Z8NgGNOGS4kjbSv29mwZvQiT+Vwe2yYb5gNNdDnxRbkELvkQA+Wrree06Qwc//ZD+ZFTv9t8lAE9AbtUYlD0Rlp4LGBo989xQ79Og5k8W1T82zVhnoY0NhYPciuV6rcVYiyd1kIF5/HoxZE/re55kfTZF7mtaObSGBgd1nTfTBF5BQlQ6MUbW+QQb7UNwuL+PZkZdCT4s4QS7f+fgCDwR1KmrqZNCW/hsXHDZKvL14vZSlUiS6GVBQSUG+9dscz0WF+WJNaXXKB1Wg0s0n3VZckC9la1ZuqhAn7TNE/OSQnWUQtKqmTmqSq/2567nHCbpQtan7AnqfEyWxZfPdbdcfV2oyICAgYGshkOgBTQaLo5kRhGNC9tf9P5iY6oDuAuSnn3oICLCjooaNVL0oKsgTlTW10tlTephmljClk0/P/lqM6usminTnTG28nzxviiirqhE3Hj1eElmQ3Dbiw0cQq8w6Nvw4kHqZNK+zMWZDQCM7ND99Db5Uw7M4JL6uoWwDTrqZVWS7DtemParRYHNDEQgrNlXKDbpJrPg2Otmeq+3z2Lkrp4+RpfE28FkaqClEVUYUF+R5M1yReDAlrrb1PW9N2F73RhHMvn4H2KA+nduJv52xtySoyGrN1/obRI0V5BOY+2qc8xuXTxsduVksraqVY4g5wtxB6sCecZdJ/mWTjZ1IJNf90//6vrRfZzdk9jHGDxndRwixwKrjfMKf3pHk/eXTR0tCgIbKc1dsEh8v3SB+dujO4pR9h8iKDh+4Fu6vLcNUgXvn6tvAeRzz+7dk5p9rrOjkJRUFVTX1MvNe3T/dHi/fUC7l6XJEjqgXCfHW5+tStlyNx2yb8rUm8CxOnTJEnPfgxzIDnTGoy3Ko4KtswufR2FfPwUbkQQzzTMnsRFaLe0s1EuNGXw/UGmurkMq2xD8OGW7LgrRpvOtQxB/XRTDKvC+mDXP5Gvr1VFTXiC5FSeLqyw0Vsk+C0m6Xxyjyk6CF+Xni+qfmZUixqAqXW7+zq9QvpmFgMkiU1CnPJjt1UBMaZ/vuKc+ezFuqDFivOc/2BGyMsaHbr+fnrkoLphyz2wDrmgIZ6ZMaembOSnmcJTdPF60dW1MCQxHg2PsovW39O3pwKT8nJyWhpxJIaC7rC9qyHpmIyl5X70dl4HMe5xw4QjYKN8luGpSer0lFJsQCeb5kwLuaHesZ2Or6kABkXVXv6+OZz5KVv/ugTKkrX/PUa48eK+VXb35uoXh2zqq082ZNpp8LlSy+5x4VdOEcb3h6Xqqnw0cOWc0HT59kva/q+mkgzpxEtscHAlmfrykNCSYBAQFbDYFED2gyWKBuOHpciiBUGNW3k1hVUiWz0lyllZBSRL7vfXOJXKTjNnELCADfu/tdkduuOI0Mef3TNVLCoLYuITeQZA93bJcndW/RQDx4FISOn5DhWMgRkYVBlgp63011xAZ5NMPlRk1qI6/1NvjivLgW5ErikvhRJC0OrtKmdGXv2o4dp9FgNlne2Ti76NXynExpG9dGJ9tzdX2ev9kA2JqQKegZMlGNGwkgsvEwf0s2RztopCyhjXNe6jruPy1zA7KjoKnjsSlQBLNPrx/y+sg730ybyxCBB43qJZshR5Vsz/5qU8a4W7KuXGZQ+gBhrza3wJVxF6X3qjbJtrHKRvvVhavltYzp30VKP3RBH7qoQBKo7fJyJNlZKeWJaiX5SRABAl2VsC/fUCGz5zjGJVNHi28M6S6bNvOaL4tuS2PQcbI83gb8D/ojIFGjbDDZzZ3a5wkS/LG/PAv05l/7dI2zma9uBxlv2O5DRvVOI5e+Wl8uLn5klrWRMLZ8W4zH7YGHzpwkctt1kNUAVOtAoDPWef6MGYhsMjE3VSSljDoU5Enpsqix6CLyOLZJNs8Y31dcMm20eGRQN2tfDhvMtY3n6loL45LhkFzqGMwB5iA9DXjd7GmAHUDTXEmymNrl6n7EHTPqetBuv8Si3a4afdPkzyeHgyS8rUGh3qh1+h1vZBD9+vlFZadSRddYROnmf7Bsg5j15cZUU/FPvtwgenduLwnGqGxe5UPY1hTdxr8RM8u9NWNrSWAou69nkZtrpp7x7kpq0H1k1sbiQqREx0ri1wyW4tMr/15/Lyp7nfeTskbuxs+mnjn9CCD0sQG2RA9V9arruZvNjvWxxt5FVaIO7FYsrnt6nnUdVj2EzAajioi+5ogx8n3WW3ncLzfKShOy4yG431+yIZV8k5JTG9QtwzewNVf2STEqW/3uF+vlc736yGJZAWeu6QSmbfOa82c+D+haJC59ZHakT6CCWSHBJCAgYGshkOgBzYJ2ebnSOSfjhSg8XdUp5T33waSGK44AGVmmk8TG+v/9+V35vY1aWVtAQLbA6YJEwZE87NdbJBPA/adNFB9/uUGcPmWodGp9HeyH9uggtU1XbaoQf37zC3HipMFi5aZKmdnAxq0pmQ3t83OlVnZBXo4oaMg8XbquTFzx6OzI5luy8egx4yQZH5eQdmWHqLlHIzQbGRHH8YxqNKicbtu5EdxoTMawbSOlE1Rk3Oobry2Ofo24+PBR4pTJlfL7eoa+jTz0XRvPiYaALugZxS5SVZEZbOoBWpMENGTmLtJEjqaoUfd8R0bc8bg1oM8zU1KJTR+k2Wl/fT9tE429uurxOWLmEWNFTV0iVsk2G1QdsiFlSZU3805ln/LdT1cnGxy7YMtq1+cv5NuV00fL9dpsCobG9H0/mCivSSf6OQc25+iVn95QYq7KuJmrHAdiEVvE65Dwv3pxofjpt3YRdfX10u55mwkfNVbOF+bS1UeMFT+YUpFGVtLIGUk5SBVsXk5ujqATAeG3ooJ8MdNoes79pkFsXLLSvFeXGgS6zZZv7fG4PfD9P24JaCuozEiVvbybppfPuHjg9L3FifckAym+sWgjuiGszPn+1OyVktRhrI/q585gda3han1RRBgyA8jJUAUCIcQY9801qjGQaEIGgb4Zs5dvFOMHdJHj1yRcGc9/e3epnBuJREKeM/I/L81fbb2/2YwZn3Y7zwH/5gf3ve+VPKHaywfWcORP9KCASfS7MnNNgjQu9OeIvrStskSdP7r2+m90bFcgjv/TuynbTFUhz5XgpE5w6ucmm14aY8zMiiVIhL2xEaUBbihtef1+nrHfMDmemKN4USVVNSK3JEf6za6kBqog9ODyna98Lsb16ypJVr35bllVnehUmCf6dC1KqwoFUWso50TGPLJT+Jg2P9XUM5cVC8N7ZsiqmGCv7Gp2rO7N1UeMkWsXa1UyUJBcP3+4/3CZUMLnmINq/KFp/tT5NBidk3ZNEOV7D+shbcMbEU2OTbIf2Rkld+Zqrqxknsx5rc8j7hPHx07a9mD0aKGS7ZzKWhnoVvYF+a7Lp4+RzyAbiRs9AKl+37YOBInEgICAbBFI9IAmg8Xngn/NEqdPGSbeX7pedhQ/4o430z6jEwtkX9bXJ8SAbkVSo/Tbe+4kfv3SZ7JxGhuVEDEOaCxM/UIFstJp9vgDmdU4XFx79Dhx5WPpDqYke44YI477Y7I5JeTNroO6SifuRw99LJ1LGubOL6mSBGdUhpsJW7Y5ZP5FU0c5M75wDiF/2cyTfWIj0KMkLGzZIZS9I0tDuSMkFhsEVRYblaGtHE0INDYKNskZgASO7dxuOna8eGbWiozKlKhsO1emMfcoNydHPPuj/dKIZ5ejbyNuTPIwqomiC2bTMnPDvdmRHRk326ux57UjIOrebG2NTDXPlm+skBnigLEAuetq4If9Yf7RCAztbDRRme/VtfViTWmVKMzLbHIGyO6684Td5VwuqaiVYwuJEbJ/1bg2ZSwYX90jxpgpg6TPX7Vxnzq2b4r4VuQZ+N2Je4qrH59jJe6ufWquvC7AcWxl3NhbXqdEH3tHk8SFKzfL+crm3gxOQID17dw+LVPxssfmpGcqjugpfn7YLlJiBpRW14mZTyTPEdv18bINVsL7SsiKRlTSSCLFY8v1fhttTbN1n2HdxbvLK51kBuNAEUTqb54rGvr4fqZ8mU97OJuAWVyJJ1NfOXN89hDXHzNe3HLMeHGxRRLouqPHi1ufm58mh3DjMePEXwwCXV+zbjHOIUpDPO6YiaPdrkuemI1VbQE727nYGh3rwXM9M1f/DQLGSpYuCnognL0DCQ0qEE7lAc8RIpu1laxeSEl636jGsKoigPfIwIVgVGNM2bR7TtpLJkkQJCQ7Xo0d15qisp6/ObKXrFSMIkoDMqFL/agG10dM6C/XCtNnu/7o8c6qFdOucqwfPvChfNYQ3nUFCan3Pajblqo+2W/h2xPkOk0ApDA3V/YTgKS2SX0d/8ct/qLLTzXHCmtYh/Z5abrf5rqJJAljNarZMdAJcTX++Mfc4/O6reL9RWtKZbAM30CvyoEMtwULfPsnzoP7hByNCkC4AnRUepn7Its8smmac6+Yz7c8t8AaLF9bWin+cdY+0iZgA0xegT2NLZjFM0Mq05SnUusAT8AMyvLejlzZGRAQEI1Aogc0GWpDc/zEQWkdxV2Nd8hewfmmvHVor45iWO+O4o//WSylGdpimXPAtoWpb4iTidOKE8s4vPW5T8W9bywRD/9wH1FeUy82ldfITBWyUZS8AIDkRY+XEnQ2+pA6rsyLKEin7+FPMggWmdVcUuX9LgQD8wUJl8ZKWOgkLaTCBf/8xJnNrRPpUWSE7XsKaK7azo1Nqk3ayfabOrzZ4Z+tlSSknoHuysSzZduYhE2UlivknVlKiqN/7oEjZIafrQxVlpVr2ZGNQdR57ciIujc+Uq65wPhjnCpyCew7vKf3OxBAaH6z8YTwOfj215yfZUMNgf7QmXtL2QfTHj38w8lifRkElV3GIkpegUw4iGXVRFcn0G3Eopr/n64q8co/cJ7ovyN9cvykQZJIoMKHkndFKGATqFa74NBdJLGgro2AF/P14qntUlmFXdoXpNldp/xSwzFpnor9VwQ68DWYfj0i69dFzP7o4GQ/Dhd04mBbjMdtiUumjRKF7TvKDGxXrwqTOEkGkeqkzTQrilzawzzr9eXVscjmbCSe1PpCcIVxntk4ep2sGLvlO7tKomh9WbUkljq0y5MZ6CaBDph/rjnBbyFXtDVsWNxGpkieMN9t8wCi21WxZwaL9UoLde/NzFwTE4d0j/TzowLhaZUHfdOP5ZL/IMuV8SYbQTeszSdOHGTVZo96Hm0tELYtQSKHLieEjTcJdGUjrnhsdobP5gP2g14MPr19gi66tBn2JrnOJLPXSchgDOl7Ap+fSoCa7GpsXIfCfGkD122uFveevJe449Uk4a3PH17/bFWpOHhU78hmx+iEu4hvM4igQDDp+398R+4bJg7tnnp9aUOA3wWbPjxVH8iscN30+vCR8HqjVN88svWAwX5Ybe9na8UVj81JBQt0G2DyCr59lGnL1DowdXw/6xoREBAQ4EMg0QOaDNVRXC2K+uJoi8LjrPA6G5DuHQrlf2m2Rtf0eStK2lyZc8C2ha5vqLLhklku/VKvM8ZWbKqSDp/P8WLMou3/zuKkowrxo2eSuDIvdOCIsyF1baajwFxxNTTKVsLCl80NTM3lKDLC9T3Ol3Jp27nZMlDibEyjMo2xI5+t2ixLQCEAcbjRkTSzzrBFkBGqeStloua9jSIbyeq57shxoqI2uRFHoufNRWskKWJqrkZpaWaDqPPakRF1b3wNwbbmeUTprZL9qOyH7xoYR2Rf/81CoOtkw03HjBdry6pFQVWtaN9Qfp36LY+8E7ILU3/7emq+sHFX89e1uVV/o0FLzwkf2HxDtKKDii1U8xHpFMreCVZ+uGyDKMzPESUVWzbyqvxbB9loOonus4OKZCDrTz//xtohPWMZwlX5NjS35lnqzV9NqOzb/bbheNxWoHqCK7Ktp+pZo99vSoAo0kY9m2uOHCsmD+8hnymZ2XppvarmIrgdh2z2jQtkZmh6b1ZW7WFkdepg3PJZmpMzZ1U1AoEAk0BvzBhrLhsWV7vdJzf2zRE95XNwyaWY2t9qnql739TKoLiBcO7VipJkBYQuzeCS/yDrlKo1fL+oRplRzZRVIMGlzRxgB/OYzOqTJw+RcizcO9M++3w2s/qRBrWQxXGan6rKBvxFJE9UVrO5zvzjrL29pL0+frkeSF6CtirgnJ/IkQ2y3/l8nXXdzBVUoozPOE9b5ajaY7tg2hl9bOoyLD7boO41wQO9+fm/PvxS9OvSPlVxhn/tA1rrkOZ6hY05j1LroNErzRfY1oMFtmQY1t7GgHNiHAYEBARki0CiBzQZRQ0dxVVjtNR/Hd23yW5RZdtfrC1Lbbpw3O85+RtSBiIgoDFgDOHA/fOsfWSmC1i7uUrMnDFGvPPF+rTNDhvJ8urMbAgd6PSy6Xp69gpnozgccheJrjZz5x4wwvkbzBdX412uZ0iPDuI2h35othvVOGRTtmSE+T2cZZxbyidtsGWg2H4z26ywypo6cezv37I+I2CzRalGa8a9jSIbD/tNkmw0JSHYHJz5zWHikqmjZGWDer4+Lc1s4Dovdc93ZETdm20RmFWkGhnJZx8wXDbRQoDbp7dKIDnuNTC+yKjySTVsrKwRx/zuLadshblJpwwaQlFlZyrom+WozS1yWVFgI63If19m+1G79hddizIbBuswiYAoOwjJYGbYNdYOcd98kh9kI7KxN4l0nvXg7sVi6rg+4sLDRrW5RIHv/uEd8aOpEzIIxagqhs5FW4JM+IzXHz1OXPLI7Iwsf+w0uvask8isuYhLnWx2jQt1TgSdTD18AjpRJFG/Bhkh9Y81wIZsx1hz2TACDz6bo9YmXW5Ml1oc3KNYBqJJEoAwl/IvVckm7c/OXenV/lb3vqlZ9XEkaRQWrykTNz49P2XropILCPBLKSzGR4OpcTUStj0PM5BgC0S0dTRWQ1oPcLz1+brU2GN86YiyG2oMqga1cX47G4m/qPGp3k9dz6L0gDNJHASIb3v+U+v3+XxFjT3IZsr7UaHmA3ZGD0qThU5QGv+URqTIsKi5YWvI67rXSkpnxYby1HyPsmnArPLR5xG+Br/1wLtLxckyGJpI2eCooKP+vm4DOE9If9easJ9ROeM7bkBAQEBcBBI9oEnAgaCJkixPe+MLqdP64DvLpIM5Y3ylsyyWLTef0RdkFsUcsVBuogICsoXSL/z2799Kc4ZxstFHhMDRNzuQ62wmnY4Xm/FO7WTGjK9RnI/AUZu5Cw/bxfkZ5s3T50+ROrxmxhcNLMm4uPFYO0Ga7UbVd6440hB6qiSVAIIKRESRVGSBPHbO5LQsINcmWwXZogiQbLLCePaUm7qeEbDZomT27hyrhFQcstEkF3kdWZmbn03XdIyj+e7Wgq0VnYvyUw0ibZlKvsyrHQnb89645AOmDO8u7RJNj029VV2zPO41LFy12XseOlnsGnOVtfVy3a6uS4j29QlJQpgZ1PraHLXJLGlorOezpV2KCyRJGpXZfu2T86SWtI8EhLTJxg5yLWZFQGPtELbQWXbO3zk5svnqpZoOvrLl1z89T/z4kJ1FW4Uts9n3rKUWbYNWvvrsVTKjM9N2Qn7Ru+OlBau9jWZ1stk1LnzndI4n4M0coRrk602VYuGq0pRdRu7AhsaMsabaMOzQDU/Pkw1L8R1Mm3P1kePE9//4dobUIvfu+qPGpfqKQNw9PXul/AfwC5CecgXTAPdGnWdTs+rjStKo+a3bOuaoT4uaqhg9y9jX1Fx/HjR+5ZmYUkUqEHH5tNGyIqOtSTWZiNtnwAY9wKHLfD55/r5pn4uqfiJZgbWTZpnJipVqL5GfjcQf8wSfNs74NQM2yidkrYsKyMWVA4qqUOvfpb1sEozmt0mCHzK6j/Rb1dzgnpmNVV33WlW36Tbal/SjkuhsVbBqHpWU14jlJRXip9/aWc7hS6eNFtcV5om1pVWiXYG/as8k8Kn8fO7H+4mnZq+Qfjnjz7YmsP87+q43Yx83ICAgIA4CiR7QJLBQri+tbmgY9YWYvXyTOGh0b1GQmysj8fpGUgHndrdB3eSiWmKU1LEwkyUSEBAHfz9rkhAFHWRmIiTNzc/MzyDQVVa0mXXVs2M70aEwT5x34IhMx2tET9nsb1WJW4bFLF+2QSefDxrVS4zp3yVjUzfv603yfebEqZYGX5y3K9s9242qi1RQmSi3v7DQ2ngnqlQSImF4746xzo1NLGW5ZMtkk21nZoWpTfLkYT1kkzaVeaOX+upZ8q7Nv0+HXc8IglS49JHZae/byEVf1q7vt+JkTCkN/riNSHdEbI9745MPoFxdZS4qvVXV5MtFOPiuIYowNslic8zFzcbTCcCoTSbBNhexyTEol77lmfmpDEKvHvmitaK8pk5cd9S4jMCiCpRW1dRlLbvAdw8e1UuMbrDBBLuO3LW/uO7JpLyMzw7pWZdFhXni0DF9UuXtGef/2Vrx44NHpoKRpi3/2bd2kQ3k2iLMNZa1ETvtetY829PLtqzXUTr1pzSU3eu/c8aUYXLtb5efJ8qqa+XY4XkB5h7PgX47ugyE73feXrzOShJxHfee/I2M5nSMqxuOGS+bXKLRrYPf4/eZPVFjrDlsmG6HqILRNZ6xOTRGJ/NzdN9OGRn4zLfBPbdIJJmBc8Yycou+QBm9Qporqz6uJI0uXZGydUUF3ixmfI9sAtyp57G6VBx395YAhIIig4/ZbYD08doqGF9IExKEYD0jqKXmVNwkgbqGOWkGNkho0QOnUdVPEKM3PDU/zSfzEflxKxuUn8Ux4oxf2zwBUnPfWKdMxA22+OYSUoH0QSEwvuugbuJDTcKQ60qIBSm5ReUH4EMiQ6mSNMji9tnoi7X5wn7lmqPGipmPJ6uCXNUZtgABv72hvEbc8coia/PYp2d/7bQvZh8G5Qvh96tz19cetfYS2Ht2zooMmUXdbjGmAwICArJFINEDmgQcCJoTsbBCmh80qrf43t3vyIVs/5G9Mj7vKxtTm3g6bAcExMHyDZWie7f24s3P14pjdx8gN7M//dYuUhIIh62qpl58tbFCkuVPnjdFvLJwlbj7tcXSycSRp8zxrP2HiYsbMi14neZ6bxDMqa8XeXl+WQHQsUHfz0d4vbFojbhs2miZDW+OezLDcIJ9GV6urKxsN6oussmViaI2Rrd9d9ess8pc54asyZDuxY3KtlPZLGSEUc1y9eNzvKW+cUs1N1ZUi/krSmRQjw04ma6MGUWc8VpurpDkP7IxavNXbMmcaazWcpyMqTga/AFbr2QdOQPWJ/RU9RL2OHJHpr4qGq6NKYlX5dgfLduYkWm5alOFbGZmrrmQiQSBGMNUXsTJxlOkOAEqX0YtrzNm9xzUTc475ifZvNwjk0CuqK2X5xw1RzZV1IoPlq4TM48cK2pqE3LOQNTzOzR6u+ekvay2JqMSYERPccWM0WLFxkoxa/lGccWMMTLTWdkM7g1Z45fPGCMqq+usdshaYTCip7OhMmBT7uq1AdHblgNgenYp2roQblGfjwt93PA9xuhux3cVv3hhYZqkFnb6rlcWpZE8PDMSNtDu94kPccwnzpsirnkiPSOecXLXq5+l6fmrubd8Y4W4ZNpo+b9fnL869Z09B3cT/bsUiV8ct5uUVdja1TG6HbL1Enjg9EnijPs/kOdOZQRAi/rl+atFidRd7uAM1jGXfYEySPg4+s5xr90mO6HA62s2V8mKlfE7dRErNlVK/07kJGTDVyprfNUPyaSf7APcLv9J2pEZY6SdVY2Zh/dKTypo7YjTWD7qHnIMM2ipjoFUE3KeqnrCtkbo825jWY04dcpQKe0Uh8iPqmxQWc16Q+4449c2TxTwERtT7aRD+QilVTXiuqPHyUoHfBCCufgASAUqG8pvUQ1OMtu4/l3S+pBxj3Tfk2tU1/kesnMelFfVynsPEX3CpMHi5HvfE/ecvJeUlrMFil0BAtbvyx+b7cx4RwZvl76drfbF7MOADeBZFTQ8VzU29hrUTQZV8/NyZZAAW48NPn3KsIzjcgx6yOTl5mTM6x29x1BAQEA0Aoke0CTgQCjHGqd1/IAu8n8/+O5S2R3dhK9sTG3i23opZEDzoZ2WzX3M7gNSGUOqAZmZKUHW+YQBXcW5D34knT8cvl+9+Jn8Z4Lx2z1iszega1GGtIBt01Vdm5AN9Wzj/pon58pmao3Nyorj6OuOOJkrSNToDiM6ir7saQiAxmSVRZ1bXA1Nk2gkk/O8v32cUSVga3Q6pGcHkUj4NZsra+rFt3//urXsnTGi7Jvp2FMqS4XBKwvWpF6PytptT1Nlo+FjNhlTPg3+gK1LGjAuIJ90PVbmRZTcEVnPehNKNra19fXi5//8RLykkW5xSuJVOTbE3Z2vLkrX5B7ZU5w2ZWhKmkUFrZGSYa5QMh9XZ5jv//29ZeIX391Vbtqxr1KT2qINfNHDs8St35kgxBvJeXbiPe/G7rvgsnd3vvK5KK+uT92zsuo6SRpwXjYfgaDXtPH9xEWH7yK+XF+R2tijD893Ljxs5wypEF6nWo77dqeFeJEVcg9/kmFnWFfqRSKjoXIcGxBVSdCWEKfviLpXjH2yBn0wZVNs/iSv3fHKZxapnbWysmHG+H5i98HdnL+RJIESYtqE/nKuK5KoX5ciOVZciSCMIQgZ5AkIxpprXZ8kN9RssK2LrO/e71TUpAU51BwmAaZDuwKr7yIlzKYMFb06tRN7DupqzfYkaIT8m/PcOmZWqkXBJjuhbPB1R48XdfX1cu9x/dPJCpebn5ufeuYEUXx27gcNhFq2AW5bYoAetNGzopfcPF20FbjsoM3fIsFBrCnNCAhv0Q63H+Oo3QeIO17+VNz6nV3l/CFjvTEa6S4iP6qyAbs8ql/nrKtCzMCKHnB2BZ3iVmPoPoheeVmYnyuDRfgAtoalU8f3TQugqT5krr1KZNVHu3zx2Dn7imfnrkjd5ydnrRCffLnRmjzgChBE+baXTR8j/vifxdIeYV9q6hJiSI9iGZjSCXpdCq99frX41uje4nsTB0neYbeB6UFVef0je8q938Sh3VN2i7WE3g8DuhXLz9j2KQEBAQE+BBI9oElgoSGzVDnWw3t1EDc+M19Gqz9dtTkjCu8r0WMRvXTq6LB4BcTGuQ98JPYbO1ASOTc9M19ccNguon1+rrjysfRSQ6DG4fTx/eRYjdP0y6tFOKJng4xMYeSma8naMvHrlzKJeoATSmM+X9YVGRc++Bx9kwxUWVOXTx8ts28g9KLKGXEs2QTjaG4sr5HZlJBaOKIcr7Hn1ljtTc7dl/l7ydTR8n8TXMHRp0LGp6dOCb8OnsPVT8yRGx02RW5tzgWyioHsIPXslHSE7VliD5+atULM+nKjkyyNyphS76vSahpAQiCi2T64x5ZMwgA3ojLAXfIsyfLoLaSBynxjPrnA/Bjao4O4/+0lRhPKnrKxFs3V1ObQlUmnB8G6FBWKj5auF49+vDyTKGyQj1HnZ5KMZnNNE/r7qlRcD9hANHMeVG5Q5UMfArW5/du7y+SYRi86ClFa0dg7iCnIUJMw4XWbj8B5QWKZzX5Tx925l7vJ22drpeSXmYGO3Y6S8zIBYQHpZEMcW95WoBpYRmnlD+peLKsy1DN12WmIkkE9isWDp0+SNo91KxlsSfcno2QgeGYfL90gf9tFAPXq2E7sv3OvNLKUrHrg1MP/bK0kfJm7w3p1TM3ZpF5z/MaLTVkXma9mbwMdNp+H66DxuTmnOFfWv6Xry+U8VIRgvUgnMU1CsCl62aZtxr9QpKrsDdI+X97LdxavE//66Ct57sx383lQLeaD6/04CTxmYgBSdlT32DSi2wKytYPcEyRvzGceVa3FGDxx4iDRr2uR/A7jQLcFURrpOpGvgiH6WGL+NcXHjhtYUfOEfQjSYfk5OeKCQ3cRl03NleOua3GhtRrDVvVGsosi0OMEEADj8BTZsDOzDxlVjI2p+mBtvLehWar6nYUrSmTQEJsXlVjDtRFciUo2YJ5TTWxW7XQb3Uf+trIBerUAv3P1kWPFRf+aJT/jss1UoFAts6G82ppoFCQSAwICskUg0QOaBN2BYHE/cJek7jMLGY1VzCh8VBl3Wy91Dmh+qLGFA7V8QzIzw7Wh4bNoqO49tIeUa7HppeqZFC5JEpV11r8hi8EHNgQrN6VnjJgor651Zl3Zmg/GhY0MlNmXj8yW18hmkE0+TQZ9UJtLiPMrGhz7xmyQm3rugOdwcsNzduHL9eXiv8s2yGzyToV58v65nuMV00eLlZuqMvTUVWZuFClDli6bBrLZNzdsgL6/18CMzYXK2uUcvj9xkNyYMi4YYzrBEpkxVZQvlm8oF0vXlafIpNc+XSMDBveeMjHGnd2xEYfkcW34kyXN3cRhY/uIMf06p2R9IKdc5B/j69qnMqtQXNnMZiadfr6KID5tyjAvqcH7gKw1/dimXroJmgqaDYJ16BtN5ifz6pBRvdM+zzzwNfUj25igzxET+stGm+ZzYC5BQJDZaSNMkJeBzDehNuiu7L+K6qjmqLUZtuf4iYNENsBeIzGQI3IyiOOm2vLWBKVdj/SOlF055RvyudmeNaSZDl7796drpCSHGjvrSqvEpKHd5bqlH4P120SUj8n71z09XzbzvsqorNAJoC7F6dmJquldnJ4XrJNNIZIbuy5CuhHQM3t3uDSFFdBKt/ndzGPmIb4885lneNY3h8tkF4J1vE/AQbcJrnOb+fgccX0DQeYKXvpss54lPLZ/Z/Gzf7i1s6MSJGzv8ztI+Sk5Fl/Qw+yV0lYJ9Lh2UM05U59eDwhHEajMc90WmL53nOCYAuuROZZYnx46cx+ZHBHHx85Gas0MrCD/N/PIceLyR5L74oweQ8ZxXE3Jr5w+Rnx3r4FSjuQWrdJCv25g+hA2G8g1M/dsFTG+qg9lx7k2dY9VwK5fRKUp9xACHtkXggcdjWoXE9y3pMyM8XrDOapnwv2iybF6Jvgcagz4bDMVgfSeCggICGgOBBI9oMnQdYr5h7PDRpaFXUXhL5maKyPAZG34EKRcArLBXSfuIRaur02Ot4YyPR/Y9PXv1l68+8U60btz+9Qmne72d52wh5R5obJCz6Roiq6nAtmjPnBMs9mPmXHRGPiyf9SGnzLWlxes9mYLcr2+DTIbHbI81pdXN1vWnY/IjGp0yjPFWV5dUilKCnJFaU2dPCf1HLFFZI+TSavkHmx6kpAG3TsURmT35aVKQnXwW2i1EqRQ0hLcJzZRZkaRTrBEZQV1KMyXWTc2zcgAP6LGsG/D78sG+84eO0mCmxJ0s4x41526isssDbYB5BSVDCbZTE8H2/kqIgEiy4dO7fLFP3+4T7JxshYcMpu36eB15lV/S0m7eQ/1CgjGq5LZgFDaXFktnjhvXyn9Yssin/XVJtkbAns7dVxf2SxSl4UA+BEuYup1Z7l+gbW5pTp2h3b+AEKx9r6yPaqRpS/ooJrkcQ+QjiLbsLSyRtxw9DjZ7A1yvjlseUvHI2fvI+oLilPZwjR/RbterZd3xlxDyZh8ZtaKtOd/07HjxeWPxsv2jZTTKkgGeGj698P9h8uqJhpNoouLTJgrO5HqAuZIlI9BlcbVT34WaWN0cOzUul+UL/1k11iJWtO5HhXQi2q+rd7vUJhvJY/5rQ+XbXDavRuOHp92La5z41mfe9BIccE//mttXK4yj222GTkZgsTYvs1VtXKekfig1mTb8/BWP4zoKf2CtNdG9hTnHDhCTNX0peMGPaLI4daMuHaQOYes3U8O2Vl+53cn7pFay7DljJEoGSubT6f73mtL/dWSahzw3OifccE/P0kbSxwDeT7O7YrpY+Rzww7R08iUOWlMNYUZYLbJDeo2gLWBOc+Yrq2rl/0T9hrSLU3L/IOl68Wa0qqGPk3xK6JcNtAnV8T+A811yGkq0gi44y8oAh1wv1TVkC7JaLPjX60vF5c+ki7f89CZk7z+x6aKapkgYvOnfc9EyVipMeDSR6+uSzadDol6AQEBzYFAogc0C9SitHJTpYz2upxuCAOcWNtmiEXU16QxIMAl58J4Y9xFbaBpIrq+tFo8NXtFBgl5/kEjxXM/2k86Xb4MzMbAJwuj6wfqzX7iICpbJmqDh1M9tGcHWZqpSFhb4x2OKTOuPJv3RWtKUzqMcTagvnPnvaraurTNGBt/wLO2SUUp8PrA7kVyLMhM7do88crCNfIarzlqnGhfkCt+9dKn9ixXq56kv4mgj9AnWw+w6S/Iy5G60ZDuJ04aLLOF1XXpmytfVhCv0/DOlZGERntA04JKrg2/r5ycplh7Deme0vLUSeHKWnvwRZHytz23IKPR2rf3GGA9X7VJ7NbBT0gwp9QYViXfjK8FK0vE5dPHyA2pXoGzx6CuyQ10dY3YVJ7nl4ay9Jq45shx4uZn5omXFqxxyqmoLHLIAu7lPW8sdsq50ADUBb1Rqm47dBtr6j7zOiXfPptRVJCXOibPjusgoOb6DvOxIC9XNqdWdgGCIVvt57aCnft2Fp07+wMwUWvoFt3k9DlKVrrNZ7SRpVFNcBknjE9fhqhtbaI6gjny9Ua/XFFxYb4z+DthYNdUYFUdF51ys5G0svUQWyai1nQk2uI0344T0OW3fHYPjXm9l4Ar+Ejw7JbnFjgblyui1LxveuBSz66H9FZrss3n8zVAPXXKEDmvaSJJwAsZNKn7ft/7aeu7yp7HZ+C6NlfWyuBkbo6QpJwKuLTlHgcEhQkSkkjg2rfxLPp0ai9+dPDOGc+Y+00vjSgfGKkmiG9lf5EyKczDf6sWHRsCbtUR1ZKqGowEGKoDbXOQ50ug6o6Xkw2Cswnm+IJgZkAMvXKy9/GpzSpXxhrJJmaDb+7vOQcOl+u23ih05oyx4vO1pd5r1wNJvoqTqCS1+nohjrjjTef7jPk46xtE+MWPpCd6gPMe/NhZDaAy3n/7/d3l8wfKBjP+rrAEUfUEHjUGlM1w6aNvrcrZgICAHQ+BRA9oMtSGA9KLzM5p4/qKG56xl579+qVPxTVHjRUzH0/XrFaN/HxNGgMCbFDj7PJpo8Uzc1amdGltcgffGt3HOTbBzceM3yo6pi5ZmLgNhmzwZWaQIcp1EFhgA2s68go0KGKzPfOIsbLBqU4Cmo13ojbvuiMfteHwnTvahWRamw0McYznLN/klIpSz51NLzIRerNPlanNppiMOFdzI7ue5FqRcDQRdDVQsunQsxn93auLMghTRQboJK6tKoFnSvYkRKUNrmsKEFkFlVwb/qh+Hj/91s5yE4fsQ3VNshEmGaV6hrMOHzlFA8xfHLdbxvkqwogeCj6iUN9E8xm+d8/J3xC3Pb8gTRccAuSp86eIZevKxXf/8LYcf65NpiQXDAJdHZ9NMZUfjE3ffdKzGn1l1/X19kbAZqNU/TrYSMvGjg6NVkBzMXXO+v0678CRMtPxuLvf2XLMET3E6fsNEwfu0lvcJhakbfr5Dk0n8WdsWrwBzRvkcmV/K7JUl4rhNZt8DM/sosNGyWfmI3NtUiyMr+uPGidWb6wQO3Utduqp8xusX3GrWMiwf2bW19aG4wRRWQPMoHoUaQtRptZcX/Nt5gQ6x757QYAYiUbffNarQmjEriozVPCbLFoIaNf6xO+tKKkU5VWZvUB8+vM0C+d9W9BEVaMgpfXTQ3aWwUxVDQaRx/v7j+wlbRbErU3+hmdGs0KzoSZk5xUzRsuA5E7dir3kcGsGPsx1T84VHy7bKJNPkAm67ql5afZfzoujx0m790tLkCS5NsxNBVpsPjAEOsc2M8eVz3b8n96V1aEElVxZzNhqGt9OHd9PVluwFzXl+XzjKSqYo3/OrILS+5WwZzCbV5u65ZwDn4kj78ZnrntqrvjxITt7n5XyC7gP5xw4Upz21/czPuPyVRuT7OMD9wOpQdt85z6d+pf3xP+eNlGUI39YkbxnyEmedt/78v1NlTViQ3mNDNCp54BNcVUhca48c8Yi85s5zzN26aPHDYYEBAQERCGQ6AFNgk4WkTWK0zJtXL/UwmXTRq2tr5cNICGrFFmHTura0kpJFKFFGRCQDZLjLUc89N4y8T97DxYXTR0lTimpSsu23H1QV0FisGszx+tfbqgQJ9zz7lbJWmgOWRgFX7YMr08b3y9tY2hrQMRrBB1w2NnIkKmpdL1t5xa1eTczwmwbjqhzx7llI2S+p54ZG2LVoNUm2UDjuRsNAl3/Po51pUOWJUpP8uwDRngbqqnNFCWpHGPXgV3Fh0s3pDZOd75q13gGauNEVqKCqkrAxqJ1i466jaAJiF/hEIeAAjwzyvt1eZYoGYe6uoTYXFsrbno2nUyAKLORbl6yedE6mc0GKaVLCSnCaFN5jbVyRBEPzA0d9Cn55fOZJAfnxGaVeaFKtl2bTEkuGBtZfX3vUJgv9hjUTXQrLvDKH0XdR8B3zc08x+Sc7nvziwxikOu4/LHZ4ujdBsj77bJjbNZn0FharxYoqRS9O7cT37v77YxnwJrys0NHSrLtVO07PAdlS6kqUQhydI2Hq/qIe+yqMFNk6bM/2k8GjPVnDnEHOav6pPDMCEqaa4MCYw2y9VqIQmOuqvEFYfj1pgpx8uQhshrCNvdyLEbaRd4lM+zt/sgbDTZA1/7NhuiKauRIRYqP2Ob7spqr3B8YUmsW65TZYJN7csnUUeLL9f4eJovXlKUkoXREBS7POWCEOP3+D6wB9T0HdZOSfSfd+16GLcKWEOCEQCeJwJZo4CTwF62VYwSb+d9li8TNx04Qt357gnjV0PFvzVA+GgS6Cv7c/dpieU9UkkHfzu2lnBUJUcdPGuQcx4zB5RsrxNqy6jRJPTVXbdIrNt/o5mfny6aTlxsVeoyxk/cdKr7/x2T/Bf7m2VBtYvq8rE++4C1jAf/NBz1QautXEuXj2ca0bR1V45H7euHhuV65RTK1IZqpsKC6gr2OmX0dN1kHOSh6Dul7J1Pi0odk43G7zeA6Zx45VlxpCTTwOs+KHgtXPjY77f0on+GLdWXSJv/t3aWyXw3yeVH66La9SUBAQEA2CCR6QKNhkmE43Dgry9aXe7NviJZfOWNsWhn0k+fvKzZW1Irf/3uO+MV3dw2LW0DWYHOrypMV0aqcTJqIoXu6KkJX0XT+Gpu14NI4ba4O8L4NMq//+OCRaUSW6cibZNuL81dLR5XrdJVr+jbvrhJSW2ZmVKYPzrANXMP5B27JUDUlGwBazL5MbRxrV2awgouwQQYGuQYbOWfLrNcDF3GbYrEB4lgqaKNsLIQ849rUvgwQWWmZxiGguOdUQhAA0YM0A7v7o7uF+XnithcyiWqy9+5taIDoGvc2fLG2TAYFIXiU1IDKvMXWvTR/VVrlCIHoF+atssoORY2/y6aOFoeNQQooR7yycJUkTNQmU9kyyDKdbAL29d0vfwRZRuaYD2TAQoar5rlIrfToWCgJRV9DVe4FwUOXHaPCAykGrkXN45G9O4pjf/9WKohgEmbnH5wePPNp8cbJ1AvIRJT99Em0QPBA5tnWVV5DgoN1GIkAstN9YFy45ijEXVlVnXjz83WyibMp3cQ5Ml8h+uJWsUTqq5fXiOP/9E6aDYtb1RZVdUMgzgf6hvzmpU9lxYUPRYV54v0l66Wu866DukoNdd3vQFc5jk49VaxmpnHU/eF7T543RfaQuPHo8fLzXDe+D88dsttGoGPHbIS/breibCZybLxP5cvNsqIgXcd/yc3TRWuF8tEghvVAQpqdH9lTHLlrf/HSgtXi2D138h5vybpycc4DH6XGsW6bfTKBVBxeNWOMJEbR6WbdSGpg18rAixnQBGaDSeXz8tyLPcEN3se7JADrgwqUpgINSzfI+3T42L6xG5+av+uSP1XjEQkoW9CcvTTJLx8uWS+ufjI51hUhr35vUPdiGdyJ2ne4mps+86P9ZGA87r5FyaFlW30HyCKnOtZc46PsB9I/8Amy10VVXSzbEarGAgICmopAogc0GiYZhjPDoo72rz+TgxK1eeKhM/eWXbtxhAtyc8X/vbNUZsyFCHFAYzCwW5HcNNmyLWlkp3TzfPImNmct26yFZevKstI4bQwiN8gVNRlEliTLpo2Wm0Nz4xHnOl2bd1f2qyszMxtZGDNLp1ORf8lSDrTv2DkiJ7YUho6uRXY9SJ/MBeDcoxx63ue3IRL+8NrnqaCN3thLZjEN6ubVaN6REVfLNIqA0jf1+qaWjbKvWV1urr3KRVYi/PUD8fAP9xFXzciVeq3MixoESD3AFnGObOwpd4ccVpm31xw5VjZHQ55InSOZaK5NfNT4W7o+SXIkpU1GiAkDuorq2hqxdF2ZlJUwM251aSVbpqZL/ohNeb8u7cWqzZWyEZ0tK5jPELC65JHZac9ySoPsig9cZ5Qdg4jUK4sgAG0EugKayXG1eIPfkn2FiGve6vZTSbQQCM9WDg05spyNFeKmZ+Y7A7T6WuMDZLwKZNlIL3wMguWmjXHNvyhyiOZ+NhsWp6otqupGHduFdgVJMmvXiDXn6dkrUvfBVvEGfEEQjsG5E4CQcm6aDE/U/SHY5tNoRtqtqjbd1mNL73oFWTV/5nOUBrckZQvz5LkS7IvT9La1QPlocaW5op6Tel9VSvIMaOSLDXD5g4pcvl5KyKT70tcfPV5W57nstppvOnnNc6WyzAXep3+Ab7yblR4Q6Jzjvz78UuSN65chZaTvMXid7w/oVpQVscz7SCJBEnPfLp82RqzYtKW65og73pBVF/y20lPnmSnb2C9GFa3LBvM39xlbExfYnZcXrLbew6jA1JXTx4g1JZmJTlF9LnhfXTe/EWdMhqqxgICApiKQ6AGNhun8PP7xcvF/p0+SJAGkgr9cfa04ZfMQuXFXG2cchOraOplVEhCQDXCkfFItZuNLl7yJi0B1ZS2YxAAZkybpFKVxGue4pja7TXvUDAr89c0vxJnfHJaWlU8mnd40M+51Kpibd9WUy5Z16srMVE2DXNCdXzNLx09k9ojsqcCmu6LGLoXB99FLJ+vXhC/LdGVJpXMD7ctAMs9LBSK4j4oEVDZWbQpdDdOwn9ceOVbsyIiqcPhqY4WUd2Du+Ago16bepr+s7j0ZVGTbucAz5f1d+nSS0iCADG+Xxqtui+RGdsaYjCoIGghOm9BfZooyPtCEdfWCsEkl2OacGlPTx/cTI3p1EJdYbJlqwHvR1F3SbEuU/JEsu588REyXm/6u4tqjx4lckWxGqsD9IJOXoKd+j7ED3LdO7fOtch/mdWSTZYaEnA9F+XnO6gWe/YheHb2VSlG2fEevEGEc+2RHsJ9kmw/pXmydt4DAFzIMxQ3Z5pBOqvGjvm6R2e3SM+d8OhTmRxLPKpBlSonpvgNjCn+WKoqOhXkih26UFvjIIeby2s1bCCUzOBRV1RZVOUaGuI+You+Cb81hrp5iBM9NIlpd44KvN4kLDxslcjy9BZAr41iPn7uvfIYkAhBMc9m0OJUftmADMjw2DXR1/sjPjOnXWQzu7k94qKvfEih0yVe0VqgATJzgf1ySU4G59+X6cumH8gyRD7HBRS6/0dDIG4LY5cvqPiS+1WPnTJZrxlOzVzjPc/KwHvJZKgkbm49lVnpwjjSwpKnqjc+kk/3mHmNozw5yLFbW1qet+1HEMpJFby9eJ23g3sN6SI10M/gs/c8cIR45e7LsFUBzY1d1jg3Z6sD7wJxcuKLE6mNHgQq7oZZEI2+jYMMGyWS+Bn30OMGQgICAgMYikOgBjYae6SL1Sk/YQ1zx6Ow0J8QH3UFjAaexIXql+wzvudXOOaDtQTlSUdqd+ngzN3s4XRA8tmxqV9aCjRh48PRJVlIM8DqyCFEkepQkhUt7NCUdMiiZaY5Djzb8H/+zOEU00aCyqdkZ5uYdIv3Zwd1iZQhy7pDuLucWbXaOpwIEA7sVi1ue29IINkVkipyM60cX84V5K70Zb5BweblC/OG1xWnl+Gy0qGQAewzqmvYM+d51R4+zbiIgyKim8YHjz1tR4s1iRsZFD0QoElBlRqpNoYvAGdazg9TF3JERVeFAtiBBW1UV4spgdGVwuvSXIeyQXuG/PvCcdHIXO8B5EFx7I2JjSGBake8K9A6hibciiAhO3XTsBHk8cy5S0h2HsNeJy9LqOm8D3vOqkk06faAUXM+aU2Mc24QuqmwcN2lwWiPj6tp68dL81aljMAfuPGF3OfdNWTheV40C9evIJsusQ2G+lwDiufqqF3yZflG2fEdAVIXITw7xVxdgm2/77q6itLJWBsEIREBIYY9dMjCMKzLPyURW91mtW7d4niVjzdc0FOJZvW9rMn3GlKHWc3L1RfA1QT33wJFSI16XZcsmOBRVOcY58r6LmFJyL7Y1Z2D3IvH8XLt0lBk45hofO2dfsa6sKrK3AP/lXijbvGJjhQxs10cQmlH3Qf8cutU+oN/OOkHA3mczITbjZr22NqgATNwM82xITt0XZ1xOXbrBGiiJ0sO/dKqdfDfXM6QUGU88d995FkT4WKyhuq3HT1DPn34jrga+HOeTLzdK/0yORSHS1v2oQAW/fezuA6RtWbm50tnTQWnPq+AEcztuf7G4DdfjBIX539hdquR0H5v1HUk2H0iEwrcyg3/qmRCYvPqIsTLAxj9bRS3PGL/jhqfnWYn8UDUWEBDQXAgkekCjoWe64CjojgQLGx24fTAdNOV8q/KxsMgFRAES5dMNSQfr72ftnfV4I+voqF37S2eQAJBNw9eWteAiBqIykigHbwrhAJkg33eUIpMRSzMttWlh068CBVxHtw7xmpJtjYapuoakbSMDgS7LVR/dEiCATNc3scqZfuD0SanGxPpmHCRJdtUYcAtRTTNjsswhxJGNUs2O+T4b4p32GCCueWqedaN/7ZNzxY3HTsgIgPhkIBQ4ho8sOXnfIWn9IQD3kExl7pXaFCqiz9SC57kFexm/8W1UVYgvg9Omv8y4htwjA8yXVcozPGa3AWmvI+/EedBAECLepvHqI4Vt2aiuuXhjQ1O212OSHCURtixK+oIsUqo0XNmCMqNw+hgZQNLP0yS5qKb5yxtfZJBZqvEn73+wZL3MdFX60dnYMZ7n+QeNtBIrvN6l4Xlje219LpoqL9TWEZXliMSYD50sjQd5xoznq59Mr1gwm0jb7nPUeiWbFyIlZARpmSePfvSVuKmBALOR8MD2zGVfhFO+IRtD69/DngzsWiSOpKJkcvp69oO/vi8D4npWd7YSBFGVYzpZSBUdcmmKHOd115rjk44COjHINTw7d4XYfWC3yO+YcxfSEjuD3nlZda08D4IqcTSem7pO6ISrK8hJ/yZ8C1cFY2uFCsC89ukabzYvjXiBOZYI6KJbblvLTF/8uqfnyyDLNU/NzSprmeObQQ6CKxccuos47a/JakJ9PPHcfVUk2Blfvx0qwXRw3CXrymJlkk8Z0VO0165ZrfusJz6JGcA6M6xXMqj02epS72f14EQ2a0yHiAocMtuzCQrzv5kbZgPZ/yxc46wsUX4uFUS24B+28oCde0mbwNqKz+zy0dBw5/dpFAvpTtWIsh22vUlAQEBAqyXR77rrLnHbbbeJlStXil133VXccccdYuJENwH7z3/+U1x55ZViyZIlYuTIkeKWW24R06ZN26bnHJCe6WI6EixYZAbHzX7LRtM0IECBLMTcdsWxypNt442sIyQWIENs+pmurAUXMRCVuROVCc6cYTN9/MRBGZIFnBdkm6/0/aeH7CxOuve9tE0Lc1Ndh02v1XedcaGTeZC/NEJauKpUkk1sXqpq6sTasmq5+aRJJr9P+ba+kdm5d0dxmUagA1uWDtfGfXCRc2yS6LdwyuaqtE0SBBvfpQmRLYtwxoR+MsvHleljqyIgG8dbkt+QBUzzM5z3OxsIDbJoIA/RQDc3mWrjxz28/un5ciNPyXDIqvEjm8a3vqqQuI379M+zuftyQ7nUE8+UCeopTp0yRPzt3WWi55RMaR/OgQ02mbPNEdxyyTywcSeA9PmaMkmmlUWQHJ0iJGDaF+Y513dex5ZFZdkxB8wMe5PkgoBwycZgKy6dNlpmr/E82UCbz8jV5FmBz1KFAgl//oF1okO7ZIO5hSs3SwkRV8ZzVEZ5c5bIt2ZEZTmijewL7H60bKM1EEHfEdYSvWpBQW8uaLvPtjkCMUPQZ8XGSnHR4aPEj2vrxJrSKjkeIdj++Nrn4vLpYySJ4yLhXU0SZV+E+97PqGLhexA9F/5rlvXe6FndM8b3lU08F6woiR3Iiaoc0/WTkdWgqkqtjVuqvtID0tjSARFVFMoPYv0798AR8tqjdJXJVHXZ1+acJ3HXCZ1wvXjqKOkrmkFOzpng/G9e/lS0NWDXqHTaZ1gPceXjczJsnwoaqXupjyUqL5DMibMW870vIKMbspbRou/VsZ0kXX1Auom1A9kwiOiaBkkzpIGwy39/b5m49qgtFYT6c7f5f/9v78FZJZhwXPTNaXDqA+d2xn0fSB9QH8fMW/6xPvkkpvTfjdOfozFrDH3MfHsn3vcFhWVVy7HjZf8J17zFNs58cq41YKIHpkg0iAp0xvXRdoT1NSAgYAcm0f/+97+Ln/3sZ+IPf/iDmDRpkvj1r38tDjvsMLFw4ULRu3fvjM+/9dZb4vjjjxc33XSTmDFjhnjwwQfF0UcfLT766CMxblyycWDAtoNa7D61RMhpAoXeYcKiPXzlEWPFs3NWpJWq6tltoXN2QFzgOOEsl1ZWixuOHp/h8PsaX+oSC3Ezqn3EQFQDLTLBXUjKtMz26ipGSdaQGWRqvEPw6Rkp2VynD7ayTrJXTR1lrvuqI8aK975YJ0b17SxJ/cPH9hUvzV+VloH93I/3y8iwdwUlVBNjW0YLestzl28Slz46J+O9/bTsKdPx/jJClsVWRQDB4isRptHckJ7pGo/qPvO8aSJqEuhqE0AQQt/I5+fkyCyrS6bmiA3lNTJjZ6euRWGj0MjGt76qkGzniMqYRALh2iPHSXKYzEkIQmwRBLq+oY977s0dJGHcEHxCquCTZRucGWEEJCEkfEHwzRU11vVd6Ryz/pta7HqTYNnPQd6z9I2+SXIpbWYXsD+QIjRuNTPvXE2eyTYmO41gVofCfPHhsg0yW1jNRewEGcd9G7LefOSB3iRP/+1sSuTbMqIyf7l3rrHPnJn229cjGxvaoAI4POMoyCCJ0Rxa2Y0z7v9A7Dm4m8xsVIS1i9j1PXPG1oby6lTQSK2fkOi+ZudcBwT6hYePEhc+/EmTG5a7bNvitWUZFU+ugDQSTS7bQNCwb5f2Mlt9RO+OMmhNcCsq2IzkhhkQ2Br9BLJZJxQxjEa66t+kn3PPTu3ECX96Rx6P+5NNJnVrgBrnd3rWQtc6mc1ajGSWSWy/+vP9vUHa1SWV8jv8U0016ZdBEkRNXSJtvsZZYwlkY29cAQPbuKN6I6rfCOQ+48hm77E7VF4jJYlWf1SCBJUs2SQKxV1jsEG2JA31vHi/PpG0uTao5roEQLp7bCP3gaoUeq6YlQCMCews4yfOvG+ufUxAQEBAqyXRb7/9dnHGGWeIU089Vf4Nmf7000+Le++9V1xyySUZn//Nb34jDj/8cHHhhRfKv6+77jrx4osvijvvvFN+N2Dbg0WLhdNEeU2dLMOl3BrZDDbmgAXz6LvelGWeOkGIY0Rkn4126JwdEAdPnLevGNqvZ4PjlNxIQmrQuAgHjbLfT1dttmZb7muRWIib9eQiBlya3Wqz68oaSxE1Hl1FNgs0NvNBkc5mZkdzZ3fZMjPZVJ5zwHDx8bJ0R55N0HVPzhPTxvdNyx6HBNfn/2YLqenaeHOf/3LKN4SwyKOcd9BIGawwv6fr3k4c0j3D8Y4iW2xVBHwXgsBWIgxZT1mpC1GbAPV7ttJiFXQIGwb3PaVaQVUK2OZ/VFVItnNE/7zaBPJcj5jQX5w6eUjksbbFplDZLakvfgKBn8zeAucdOFJ0bJcn7n1jsbhyxlhx/VM0TMskQlZtrhI//8cn1tJ47jfXgsa5IsTNJsGujG6T7Chu57d5KvBOVq6ZgW4S6MoeIWsDmanOwwxWYlOQ7FDPw0ce6E3y9OuIIo93FB/Hl/nL66oBqG3sI5dgk1hT8FU6qLWQgBbrlatiYMvau9a79qLJ3qez/1rjPnOXlrvZ7BzQ7+Ky6WMyCPTGNCz32bbO7aszAsKcB9npJoHMs3ng9L1lk0Ozf8iVR4yRxDLEswpq8V+IuGN2HyCuNpoG61Vy26qfgGlrVdNJ2zoh75dBlOLrnLrvEPH1hgp5DLX+X6nJU7Ul+NZC13v6PfZV3rmqRGvq6609Q1RSBmPMtANqzjNmbPPVtcZyPuf97WMpn8dzVMG5nboVib6d2zuvHRIdHy9OxbU5JvTg7Fufr0tbRyHmbUGlnBzhJbvN4ETccYj8DhWsrrWchqVRQWGkLO/69yIxY0J/sf/OvTLmqLKNd7+2WNqYe42msQTfrj9qnCirros975u7SiUgICCg1ZDo1dXV4sMPPxSXXnpp6rXc3FxxyCGHiLffftv6HV4nc10HmeuPPfbYVj/fgOw2SizCOCeUr9787IKMDYC+SUEHley1tZurJAkaOmcHxAFagZ0NJ4oMSEXWKuKGgI3N6aTk0yax0FhigPHOMW/5zgSZlS3LrtvnS1LXt8n1ETWqpDtKsgYnlOZFZOUo5xeCt7nnkiszk7/JptE1XFPvLVorNczTX1snG4bx+VlfbpQyCiZcWd5c1+DuxeLWb0+QZB4bNEWmvbpwtfjft5eKnx+6i9RDRLbCVg5qgmfky3yyVRHohJ9JDMbJIPZtAhpzPgFb7mnHkkrx83/8d7vcv8Zu7rb2plC3W0hhEeD+8SEj5RrN/CNr9Lm5K6VkxM8PHSV+9cICceHhu4izK4fLTbJJkrsCPAAZI8q71fyYMLCrJNBN22XTb9XJDhGRfecqt0fCxZUZyphQZISNMFXnpbLhGqNDG0Ue7yg+Tjal9+bY7xjRc8KVBar3kYC4o+LHpQ8cZ+2Nm9UZ55m71k/bGOQ7/bq0l9JebzaxYXmcc7cFhGkiartnJ97zjnx+SNzIio52edI/UQS669n6spq3ZT8B/ZyWkoW/bIOVQCfY37tzO5mwUVGdJMhfXbhK/N87S2VvFcD38GFo/hhIPfs9tlXesQ6fYiF/eb1LUdJnVj1DqMIkiUSNMb0fDeuSSca75qtpZxhrF2ljzdZvxqfLvmZztezrcNOzC5wVsDZ7r9sdlwa7GQToWlwobn1uQUr6hmao7Hfe9sgCxgG+0B6D7NruylcqiOjnxDNQ9tI2R3XbaNoYglRUJFGZZva/2BH7iAQEBLQObFcSfe3ataKurk706dMn7XX+XrBggfU76KbbPs/rNlRVVcl/Cps2bZL/LSkpaYYrCNDLzC7/1hBRVVEm3v486ey/veArMWlAe7Fztzzx22e/tH7v9bnl4rwp/UVlWak49743pBzHzj2LRU5tpSgpqdzGV7HjolOnTiKHNIcWimzmcWF9tdh7pyKZ3VFaJeS4+n97DxHf23UX+T6kNhvP/31tnrh82phGjTU13qsryuTvKEwe3kNceOAg0TG3RnTsIET/DsrEVouSEjch8PWaDaK+qtz5flnpZnHcrj3FBQ+8La4+apyoqSgT7yxen3of3cqT9+ojvn/XK6KiOknq7D2su7jwoEHNPpe+WFMqXpuzzDmfv7drT+u1bNi4KeN1Pn/Knn3EkaOGiOqqcjFxQPu061LP78LDdhE/3X8nUVldJzq2L5DZi8W5yU1SUaJK3PzM3IznsGffdqJPUUKIIsj1eiEi7gNUwaWHDBbXYsPS7m13+XqR4xl2zBXihunDxbqygaK0siZ1fh1ya0RJSeMlGxpzPi15Hm/rtbixz7Mtw7Rbtz/9ibi94Z6g+/vZunIxtHOu6JDTXnz25WoxsFOu+HLlOtG3Szvx19c+Ta3tYMmKtWLSgCK5gTfB/GufqBIlJYnU/CAz/LfP2rWf/z1nmfhixcBUAzV1rr3aC/H5ms3i1L36ZNg87Nupe/UVHy/6WlzxrSEZdu7rNeu9NtW0RzbbtWLNOjmffceprSxLva9fh2+NsJ1va5jDjZ3HjbWR+lpugvvYvaA2433GBWvlPz9YJo7ba5C46OFP5Jpojq+4a29qnNRUiJISf1VEnGe+OOb6qX8naizzfv/4ii7ec5/5RFnaPJ15xBjrPF9dVS7ufmmO2GNQN9GrU6HYbWBX0a6+Ttxz/Fjvs1Xzuld797rs8zFstqKp+Gr1BjlmMv2q7uLCgweJT5etltrWs77aJP73nSVit526ihP2HizHVn11vXVOt+R5vD32xTYbUJiXI256dq4o3bzZuT6zjnfMqRbXPDvLageY71+sWCOfn3oeEjHma1PH2vLVG6TcE2TwuZP7ix/tN0AGvABjBd+Vhrr29clvd1h7erVPr7ThXvzsgIHi2ifnyTlaVJgrbv3OruL9hV+l3cOoNaYxvlK1xxbzDNjvcz3YS9d6rnMEysbw3bO+OVwM6lYkVqxZv03nfRRa8hy2geb2YNNXi0V9rbuCKwqlq5fL/5asXCLatWu33Y7RFs+luY7Tks6lpV3T5pVLk8crLZVr2ladx4ntiOXLlzPjE2+99Vba6xdeeGFi4sSJ1u8UFBQkHnzwwbTX7rrrrkTv3r2tn585c6b8jfAv/Av/3P9Wr16daMkI8zj8C/9a9zwOczj8C/9a9xwGYR6Hf+Ff657HYQ6Hf+Ff657DNnC+2/uehX/hn9iB5nEO/09sRzmX4uJi8fDDD8vmoAonn3yy2Lhxo3j88cczvjNo0CAp5/KTn/wk9drMmTOlnMsnn3wSGXHnuIMHDxbLli0TXbokS/FaG4isDBw4UHz55Zeic+cIkcYWinANLesamBcteT6EedwyEa6hZaA1zOMwh1smwjW0DLSGOQzCPG6ZCNfQMtAa5nGYwy0T4RpaBlrDHLaBipKuXbu2iXsfrmH7oi1dw8atOI+3q5xLYWGh2HPPPcXLL7+cItHr6+vl3+edd571O/vss498XyfRaSzK6zZQEmArC+CGttaBocD5h2vY/mgL19DSS9bCPG7ZCNfQMtCS53GYwy0b4RpaBlryHAZhHrdshGtoGWjJ8zjM4ZaNcA0tAy15DvvOty3c+3ANLQNt4RpytuI83q4kOiCrnMzzvfbaS0ycOFH8+te/FmVlZeLUU0+V75900kliwIAB4qabbpJ///jHPxb777+/+OUvfymmT58uHnroIfHBBx+IP/7xj9v5SgICAgICAgICAgICAgICAgICAgICAtoatjuJ/r3vfU+sWbNGXHXVVbI56G677Saee+65VPNQystyc3NTn588ebJ48MEHxRVXXCEuu+wyMXLkSCnlMm7cuO14FQEBAQEBAQEBAQEBAQEBAQEBAQEBAW0R251EB0i3uORb/v3vf2e89t3vflf+awwoYUNDvSmdX7c3wjW0DIRr2H5oreetI1xDy0C4hu2D1njOJsI1tAyEa9h+aK3nrSNcQ8tAuIbtg9Z4zibCNbQMhGvYfmit560jXEPLQLiGeNiujUUDAgICAgICAgICAgICAgICAgICAgICWjK26KQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBKQhkOgBAQEBAQEBAQEBAQEBAQEBAQEBAQEBDgQSPSAgICAgICAgICAgICAgICAgICAgIKAtk+h33XWXGDJkiGjfvr2YNGmSeO+997yf/+c//ylGjRolPz9+/HjxzDPPpL2PTPxVV10l+vXrJ4qKisQhhxwiPvvssxZzDX/605/EfvvtJ7p16yb/cX7m50855RSRk5OT9u/www9vMddw3333ZZwf32tNz+GAAw7IuAb+TZ8+fbs8h//85z/iiCOOEP3795e/89hjj0V+h8a9e+yxh2y8MGLECPlcmjq/GoMwh8Mc3h7X0NLmMAjzuPWMnzCPW8Y1tLR5HOZw6xk7YQ63jGtoaXMYhHncesZPmMct4xpa2jwOc7j1jJ0wh1vGNbS0Odyi53GileOhhx5KFBYWJu69997E3LlzE2eccUaia9euiVWrVlk//+abbyby8vISt956a2LevHmJK664IlFQUJCYPXt26jM333xzokuXLonHHnss8cknnySOPPLIxNChQxMVFRUt4hpOOOGExF133ZX4+OOPE/Pnz0+ccsop8ny/+uqr1GdOPvnkxOGHH55YsWJF6t/69eu3yvk35hr+8pe/JDp37px2fitXrkz7TEt/DuvWrUs7/zlz5sixxbVtj+fwzDPPJC6//PLEI488QrPgxKOPPur9/OLFixPFxcWJn/3sZ3Iu3HHHHfL8n3vuuUbfk8YgzOEwh7fXNbS0OQzCPA7zeFteQ5jHzY8wh8Mc3pbXEObw1kGYx2Eeb8trCPO4+RHmcJjD2/IawhxO7FDzuNWT6BMnTkyce+65qb/r6uoS/fv3T9x0003Wzx933HGJ6dOnp702adKkxFlnnSX/d319faJv376J2267LfX+xo0bE+3atUv87W9/axHXYKK2tjbRqVOnxF//+te0AX7UUUclthWyvQYmI0bEhdb4HH71q1/J51BaWrrdnoNCHCNz0UUXJcaOHZv22ve+973EYYcd1mz3JA7CHA5zuLnQluYwCPO4dY2fMI+bB21pHoc53LrGTpjDzYO2NIdBmMeta/yEedw8aEvzOMzh1jV2whxuHrSlOdzS5nGrlnOprq4WH374oSyFUMjNzZV/v/3229bv8Lr+eXDYYYelPv/FF1+IlStXpn2mS5cuMs3fdcxtfQ0mysvLRU1NjejevXtGKUPv3r3FLrvsIs4++2yxbt06sTXQ2GsoLS0VgwcPFgMHDhRHHXWUmDt3buq91vgc/vznP4vvf//7okOHDtvlOWSLqLnQHPckCmEOJxHm8Pa7htY8h0GYx82DMI/DPN5eCHO4eRDmcJjD2xNhHjcPwjwO83h7Iczh5kGYw2EO7wjzuFWT6GvXrhV1dXWiT58+aa/zN4PUBl73fV79N5tjbutrMHHxxRdLnSB9MKBNdP/994uXX35Z3HLLLeK1114TU6dOlb/VEq6BSXfvvfeKxx9/XPzf//2fqK+vF5MnTxZfffVVq3wO6CjNmTNHnH766Wmvb8vnkC1cc6GkpERUVFQ0y9iMQpjDSYQ5vH2uobXPYRDmcfMgzOMwj7cXwhxuHoQ5HObw9kSYx82DMI/DPN5eCHO4eRDmcJjDO8I8zm+2Mw7YLrj55pvFQw89JCNCevMCokYKNJiYMGGCGD58uPzcwQcfLLY39tlnH/lPASMzevRocffdd4vrrrtOtDYQqeM+T5w4Me31lv4cArY/whxuGQhzOKApCPO4ZSDM44DGIszhloEwhwOagjCPWwbCPA5oLMIcbhkIc7gNZ6L37NlT5OXliVWrVqW9zt99+/a1fofXfZ9X/83mmNv6GhR+8YtfSEPzwgsvyAHsw7Bhw+RvLVq0SLSka1AoKCgQu+++e+r8WtNzKCsrk8b+tNNOi/ydrfkcsoVrLnTu3Fl2jG6O5xqFMIfDHG4u7IhzGIR53DwI8ziJMI+3PcIcbh6EOZxEmMPbB2EeNw/CPE4izONtjzCHmwdhDicR5nDbnsetmkQvLCwUe+65pywnUKB0gr/1SJAOXtc/D1588cXU54cOHSpvoP4Z0v/fffdd5zG39TWAW2+9VUa1nnvuObHXXntF/g6lJOgV9evXT7SUa9BBWcXs2bNT59dangP45z//KaqqqsT//M//bNfnkC2i5kJzPNcohDkc5nBLuIbWOodBmMfNgzCPkwjzeNsjzOHmQZjDSYQ5vH0Q5nHzIMzjJMI83vYIc7h5EOZwEmEOt/F5nGjleOihh2RX2/vuuy8xb968xJlnnpno2rVrYuXKlfL9//f//l/ikksuSX3+zTffTOTn5yd+8YtfJObPn5+YOXNmoqCgIDF79uzUZ26++WZ5jMcffzwxa9Ys2YF26NChiYqKihZxDZxfYWFh4uGHH06sWLEi9W/z5s3yff57wQUXJN5+++3EF198kXjppZcSe+yxR2LkyJGJysrKFnEN11xzTeL5559PfP7554kPP/ww8f3vfz/Rvn37xNy5c1vNc1CYMmWK7PprYls/B37v448/lv+Y2rfffrv830uXLpXvc+5cg8LixYsTxcXFiQsvvFDOhbvuuiuRl5eXeO6552Lfk+ZAmMNhDm+va2hpc1j9ZpjHrWP8hHncMp5DS5vHYQ6HObwtryHM4bAW6wjzOMzj7XUNLW0ehzkc5vC2vIYwhyu3yjW01Hnc6kl0cMcddyQGDRokJ9/EiRMT77zzTuq9/fffP3HyySenff4f//hHYuedd5afHzt2bOLpp59Oe7++vj5x5ZVXJvr06SNv8MEHH5xYuHBhi7mGwYMHy0Fk/sNogvLy8sShhx6a6NWrlzSifP6MM85oVgPf1Gv4yU9+kvos93natGmJjz76qFU9B7BgwQJ571944YWMY23r5/Dqq69ax4U6Z/7LNZjf2W233eT1Dhs2LPGXv/wlq3vSXAhzOMzh7XENLW0OgzCPW8/4CfO4ZVxDS5vHYQ63nrET5nDLuIaWNodBmMetZ/yEedwyrqGlzeMwh1vP2AlzuGVcQ0ubwy15Hufw/5ovgT4gICAgICAgICAgICAgICAgICAgICCg7aBVa6IHBAQEBAQEBAQEBAQEBAQEBAQEBAQEbE0EEj0gICAgICAgICAgICAgICAgICAgICDAgUCiBwQEBAQEBAQEBAQEBAQEBAQEBAQEBDgQSPSAgICAgICAgICAgICAgICAgICAgIAABwKJHhAQEBAQEBAQEBAQEBAQEBAQEBAQEOBAINEDAgICAgICAgICAgICAgICAgICAgICHAgkekBAQEBAQEBAQEBAQEBAQEBAQEBAQIADgUQPCAgICAgICAgICAgICAgICAgICAgIcCCQ6AEBAQEBAQEBAQEBAQH/v717C7F5i+MAvoaTRq65k3tCiMk1ueQuaeJNUi55RDR54MVQivJCYfLEk5BCKSRiUiaGFIqQQi4zPAjlEnNaq8icc3Znzznt+dvm86l/s///l/m+7Pb6/9ZavxUAAPhniuhkYt++fWHgwIGhtLQ0TJo0KVy7di3rSECeqqurQ3l5eejTp08oKSkJJ0+ezDoS0AQ7duwIEyZMCB06dAg9evQIixcvDvfv3886FpCnqqqqMHr06NCxY8d0TZ48OZw5cybrWMD/sHPnzjSu3rBhQ9ZRgDxs3bo1fWd/voYPH551LApMEZ1md/To0VBRUREqKyvDzZs3w5gxY8L8+fNDXV1d1tGAPHz48CF9b+NkGFB8Ll++HNasWRNqamrC+fPnw5cvX8K8efPSdxv49fXt2zcV3G7cuBFqa2vDrFmzwqJFi8Ldu3ezjgb8B9evXw8HDhxIk2NA8Rg5cmR48eLFj+vKlStZR6LAShoaGhoK/U/gZ3HleVwBt3fv3nT/7du30K9fv7Bu3bqwadOmrOMBTRBn3E+cOJFWsgLFqb6+Pq1Ij8X16dOnZx0H+A+6dOkSdu3aFVavXp11FKAJ3r9/H8aOHRv2798ftm/fHsrKysLu3buzjgXksRI97si+detW1lFoRlai06w+f/6cVs3MmTPnx7NWrVql+6tXr2aaDQBaordv3/4owgHF5evXr+HIkSNpJ0ls6wIUl7gzbOHChY3ej4Hi8ODBg9TidPDgwWHZsmXhyZMnWUeiwP4o9D+An71+/ToN9nv27Nnoeby/d+9eZrkAoCWKu8Fi/9UpU6aEUaNGZR0HyNPt27dT0fzjx4+hffv2aVfYiBEjso4FNEGcAIvtTWM7F6D4OiwcOnQoDBs2LLVy2bZtW5g2bVq4c+dOOneI35MiOgBAC14BFwf7ejhCcYkv7XELedxJcvz48bBixYrUkkkhHYrD06dPw/r169PZJKWlpVnHAZpowYIFPz7H8wxiUX3AgAHh2LFjWqv9xhTRaVbdunULrVu3Dq9evWr0PN736tUrs1wA0NKsXbs2nD59OlRXV6eDCoHi0aZNmzBkyJD0edy4cWkl6549e9LhhMCvL7Y4raurS/3Qv4s7tuNvcjw77NOnT+m9GSgOnTt3DkOHDg0PHz7MOgoFpCc6zT7gjwP9CxcuNNpKHu/1cQSAwotnyscCemz/cPHixTBo0KCsIwH/UxxPx6IbUBxmz56d2jLFHSXfr/Hjx6e+yvGzAjoU3yHBjx49Cr179846CgVkJTrNrqKiIm05jYOEiRMnptPH42FIq1atyjoakOcA4ecZ9sePH6fBfjyUsH///plmA/Jr4XL48OFw6tSp1LPx5cuX6XmnTp1C27Zts44H/IvNmzenbeTxN/fdu3fp+3zp0qVw7ty5rKMBeYq/v389i6Rdu3aha9euziiBIrBx48ZQXl6eWrg8f/48VFZWpsmvpUuXZh2NAlJEp9ktWbIk1NfXhy1btqQX97KysnD27Nm/HTYK/Jpqa2vDzJkzG02MRXFyLB6uAvzaqqqq0t8ZM2Y0en7w4MGwcuXKjFIB+YotIJYvX54OMouTX7EXayygz507N+toANAiPHv2LBXM37x5E7p37x6mTp0aampq0md+XyUNcU8vAAAAAADwN3qiAwAAAABADoroAAAAAACQgyI6AAAAAADkoIgOAAAAAAA5KKIDAAAAAEAOiugAAAAAAJCDIjoAAAAAAOSgiA4AAAAAADkoogMAAAAAQA6K6AAAAAAAkIMiOgAAAAAA5KCIDgAAAAAA4Z/9CWu8yZAtCbkHAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345
count1000.0000001000.0000001000.0000001000.0000001000.0000001000.000000
mean0.4763370.5119250.6280710.4802680.5083790.476343
std0.0150610.3023580.2244860.3076840.2766950.290834
min0.4290190.0000830.0735380.0012670.0006390.000521
25%0.4663060.2556020.4750810.2112810.2806790.206512
50%0.4768470.5322100.6517810.4682010.5137340.473771
75%0.4862080.7766990.8108190.7635090.7452670.731109
max0.5259080.9990890.9940730.9999140.9998500.990766
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 \\\n", + "count 1000.000000 1000.000000 1000.000000 1000.000000 1000.000000 \n", + "mean 0.476337 0.511925 0.628071 0.480268 0.508379 \n", + "std 0.015061 0.302358 0.224486 0.307684 0.276695 \n", + "min 0.429019 0.000083 0.073538 0.001267 0.000639 \n", + "25% 0.466306 0.255602 0.475081 0.211281 0.280679 \n", + "50% 0.476847 0.532210 0.651781 0.468201 0.513734 \n", + "75% 0.486208 0.776699 0.810819 0.763509 0.745267 \n", + "max 0.525908 0.999089 0.994073 0.999914 0.999850 \n", + "\n", + " 5 \n", + "count 1000.000000 \n", + "mean 0.476343 \n", + "std 0.290834 \n", + "min 0.000521 \n", + "25% 0.206512 \n", + "50% 0.473771 \n", + "75% 0.731109 \n", + "max 0.990766 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta_true: [0.51182162 0.9504637 0.14415961 0.94864945 0.31183145 0.42332645]\n" + ] + } + ], + "source": [ + "theta_df = pd.DataFrame(samples.get(\"theta\"))\n", + "\n", + "plot_theta_pairs(theta_df, theta_true, \"Theta Posterior\")\n", + "plt.show()\n", + "\n", + "display(theta_df.describe())\n", + "print(\"theta_true:\", theta_true)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "post_predictive = Chain(\n", + " Predictive.run(model, x=x, y=None, rng=rng, state=state)\n", + " for state in samples\n", + ")\n", + "\n", + "fx_post = post_predictive.get(\"fx\")\n", + "y_post = post_predictive.get(\"y\")\n", + "\n", + "plt.scatter(x, y, label=\"data\", c=\"k\")\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.fill_between(\n", + " x,\n", + " np.quantile(fx_post, 0.05, 0),\n", + " np.quantile(fx_post, 0.95, 0),\n", + " color=\"blue\",\n", + " alpha=0.3,\n", + " label=\"Post. predictive (fx)\",\n", + ")\n", + "plt.plot(x, fx_post.mean(0), color=\"blue\")\n", + "\n", + "plt.fill_between(\n", + " x,\n", + " np.quantile(y_post, 0.05, 0),\n", + " np.quantile(y_post, 0.95, 0),\n", + " color=\"orange\",\n", + " alpha=0.3,\n", + " label=\"Post. predictive (y)\",\n", + ")\n", + "\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/demos/linear-regression.ipynb b/demos/linear-regression.ipynb new file mode 100644 index 0000000..2ad3c60 --- /dev/null +++ b/demos/linear-regression.ipynb @@ -0,0 +1,271 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Optional\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from aria.distributions import Gamma, Normal\n", + "from aria.ppl.context import Context, Predictive\n", + "from aria.ppl.inference import AIES, Chain" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def linear_regression(\n", + " ctx: Context, X: np.ndarray, y: Optional[np.ndarray], bias=True\n", + "):\n", + " _, p = X.shape\n", + " beta = ctx.rv(\"beta\", Normal(np.zeros(p), 10))\n", + " mu = ctx.cached(\"mu\", X @ beta)\n", + " if bias:\n", + " alpha = ctx.rv(\"alpha\", Normal(0, 10))\n", + " mu += alpha\n", + " sigma = ctx.rv(\"sigma\", Gamma(1, 1))\n", + "\n", + " ctx.rv(\"y\", Normal(mu, sigma), obs=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulation truth: {'beta': array([3.57380411]), 'alpha': array(-12.08318632), 'sigma': 2}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rng = np.random.default_rng(0)\n", + "X = (x := rng.normal(0, 1, 50)).reshape(-1, 1)\n", + "sim_truth = Predictive.run(\n", + " linear_regression,\n", + " state=dict(sigma=2),\n", + " rng=rng,\n", + " X=X,\n", + " y=None,\n", + " return_cached=False,\n", + ")\n", + "y = sim_truth.pop(\"y\")\n", + "\n", + "print(\"Simulation truth:\", sim_truth)\n", + "\n", + "plt.scatter(x, y)\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 3000/3000 [00:01<00:00, 2755.23it/s]\n" + ] + } + ], + "source": [ + "# Affine Invariant Ensemble Sampler.\n", + "\n", + "aies = AIES(\n", + " linear_regression,\n", + " rng=rng,\n", + " X=X,\n", + " y=y,\n", + " transform=False,\n", + " nwalkers=5,\n", + ")\n", + "samples = aies.fit(2000, burn=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Or try with random-walk Metropolis.\n", + "\n", + "# from aria.ppl.inference import RandomWalkMetropolis\n", + "#\n", + "# proposal = {\n", + "# name: (\n", + "# lambda value, rng, mcmc_iteration: rng.normal(\n", + "# value, np.clip(10 * np.exp(-mcmc_iteration / 100), 0.1, 10)\n", + "# )\n", + "# )\n", + "# for name in sim_truth\n", + "# }\n", + "# rwm = RandomWalkMetropolis(\n", + "# linear_regression, proposal=proposal, rng=rng, X=X, y=y\n", + "# )\n", + "# samples = rwm.fit(2000, burn=1000, thin=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bundle = samples.bundle\n", + "if \"mu\" in bundle:\n", + " bundle.pop(\"mu\")\n", + "\n", + "plt.figure()\n", + "for i, (name, value) in enumerate(bundle.items()):\n", + " match value.ndim:\n", + " case 2:\n", + " value = value.flatten()\n", + " case 1:\n", + " pass\n", + " case _:\n", + " raise NotImplementedError()\n", + "\n", + " plt.subplot(3, 2, 2 * i + 1)\n", + " plt.plot(value)\n", + " param_truth: float = sim_truth[name] # type: ignore\n", + " plt.axhline(param_truth, c=\"k\")\n", + " plt.axhline(value.mean(), c=\"b\")\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(f\"$\\\\{name}$\", rotation=0)\n", + "\n", + " plt.subplot(3, 2, 2 * i + 2)\n", + " plt.hist(value, density=True, bins=30)\n", + " plt.axvline(param_truth, c=\"k\")\n", + " plt.axvline(value.mean(), c=\"b\")\n", + " plt.xlabel(f\"$\\\\{name}$\")\n", + " plt.ylabel(\"density\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "X_new = (x_new := np.linspace(-3, 3, 50)).reshape(-1, 1)\n", + "post_predictive = Chain(\n", + " Predictive.run(linear_regression, state=c, rng=rng, X=X_new, y=None)\n", + " for c in samples\n", + ")\n", + "y_new = post_predictive.get(\"y\")\n", + "mu_new = post_predictive.get(\"mu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_new, y_new.mean(0), label=\"mean\")\n", + "plt.plot(\n", + " x_new, x_new * sim_truth[\"beta\"] + sim_truth[\"alpha\"], label=\"truth\", c=\"r\"\n", + ")\n", + "plt.scatter(x, y, c=\"k\", label=\"data\")\n", + "plt.fill_between(\n", + " x_new,\n", + " np.quantile(y_new, 0.025, 0),\n", + " np.quantile(y_new, 0.975, 0),\n", + " alpha=0.2,\n", + " label=\"95% CI\",\n", + ")\n", + "plt.fill_between(\n", + " x_new,\n", + " np.quantile(mu_new, 0.025, 0),\n", + " np.quantile(mu_new, 0.975, 0),\n", + " alpha=0.2,\n", + " label=\"95% CI\",\n", + ")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/arianna.html b/docs/arianna.html new file mode 100644 index 0000000..b40dfdf --- /dev/null +++ b/docs/arianna.html @@ -0,0 +1,256 @@ + + + + + + + arianna API documentation + + + + + + + + + + + + +
+
+

+arianna

+ + + + + +
+
+ + \ No newline at end of file diff --git a/docs/arianna/distributions.html b/docs/arianna/distributions.html new file mode 100644 index 0000000..c9af5d6 --- /dev/null +++ b/docs/arianna/distributions.html @@ -0,0 +1,265 @@ + + + + + + + arianna.distributions API documentation + + + + + + + + + + + + +
+
+

+arianna.distributions

+ + + + + + + 
1from .distributions import *  # noqa: D104, F403
+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/arianna/distributions/abstract.html b/docs/arianna/distributions/abstract.html new file mode 100644 index 0000000..164f75f --- /dev/null +++ b/docs/arianna/distributions/abstract.html @@ -0,0 +1,2034 @@ + + + + + + + arianna.distributions.abstract API documentation + + + + + + + + + + + + +
+
+

+arianna.distributions.abstract

+ + + + + + + 
  1from abc import ABC, abstractmethod
+  2from functools import cached_property
+  3
+  4import numpy as np
+  5from numpy import ndarray
+  6from numpy.random import Generator as RNG
+  7from numpy.random import default_rng
+  8from scipy.special import expit, logit
+  9
+ 10from arianna.types import InvalidBoundsError, Numeric, Shape
+ 11
+ 12
+ 13class Distribution(ABC):
+ 14    @cached_property
+ 15    @abstractmethod
+ 16    def event_shape(self): ...
+ 17
+ 18    # TODO: Think about how to implement this.
+ 19    @cached_property
+ 20    @abstractmethod
+ 21    def batch_shape(self): ...
+ 22
+ 23    @abstractmethod
+ 24    def logpdf(self, x: Numeric) -> Numeric: ...
+ 25
+ 26    @abstractmethod
+ 27    def sample(
+ 28        self, sample_shape: Shape = (), rng: RNG = default_rng()
+ 29    ) -> ndarray: ...
+ 30
+ 31    def pdf(self, x: Numeric) -> Numeric:
+ 32        return np.exp(self.logpdf(x))
+ 33
+ 34    @cached_property
+ 35    @abstractmethod
+ 36    def mean(self) -> Numeric: ...
+ 37
+ 38    @cached_property
+ 39    def std(self) -> Numeric:
+ 40        return np.sqrt(self.var)
+ 41
+ 42    @cached_property
+ 43    @abstractmethod
+ 44    def var(self) -> Numeric: ...
+ 45
+ 46
+ 47class Continuous(Distribution):
+ 48    @abstractmethod
+ 49    def to_real(self, x: Numeric) -> Numeric: ...
+ 50
+ 51    @abstractmethod
+ 52    def to_native(self, z: Numeric) -> Numeric: ...
+ 53
+ 54    @abstractmethod
+ 55    def logdetjac(self, z: Numeric) -> Numeric: ...
+ 56
+ 57
+ 58class Discrete(Distribution): ...
+ 59
+ 60
+ 61class Multivariate(Distribution):
+ 62    @cached_property
+ 63    @abstractmethod
+ 64    def mean(self) -> ndarray: ...
+ 65
+ 66    @cached_property
+ 67    def std(self) -> ndarray:
+ 68        return np.sqrt(self.var)
+ 69
+ 70    @cached_property
+ 71    @abstractmethod
+ 72    def var(self) -> ndarray: ...
+ 73
+ 74
+ 75class Univariate(Distribution):
+ 76    @cached_property
+ 77    def event_shape(self) -> Shape:
+ 78        return ()
+ 79
+ 80    @cached_property
+ 81    @abstractmethod
+ 82    def batch_shape(self) -> Shape: ...
+ 83
+ 84    def _reshape(self, sample_shape: Shape) -> Shape:
+ 85        return sample_shape + self.batch_shape
+ 86
+ 87    @abstractmethod
+ 88    def _sample(self, size: Shape, rng: RNG) -> ndarray: ...
+ 89
+ 90    def sample(
+ 91        self, sample_shape: Shape = (), rng: RNG = default_rng()
+ 92    ) -> ndarray:
+ 93        shape = self._reshape(sample_shape)
+ 94        return self._sample(shape, rng)
+ 95
+ 96
+ 97class UnivariateContinuous(Univariate, Continuous):
+ 98    def logpdf_plus_logdetjac(self, z: Numeric) -> Numeric:
+ 99        """Logpdf plus the log absolute determinant of the jacobian.
+100
+101        Logpdf plus the log absolute determinant of the jacobian, evaluated at
+102        parameter on the transformed (real) space.
+103        """
+104        x = self.to_native(z)
+105        return self.logpdf(x) + self.logdetjac(z)
+106
+107    @abstractmethod
+108    def logcdf(self, x: Numeric) -> Numeric: ...
+109
+110    def cdf(self, x: Numeric) -> Numeric:
+111        with np.errstate(divide="ignore"):
+112            return np.exp(self.logcdf(x))
+113
+114    def survival(self, x: Numeric) -> Numeric:
+115        return 1 - self.cdf(x)
+116
+117    def logsurvival(self, x: Numeric) -> Numeric:
+118        return np.log1p(-self.cdf(x))
+119
+120
+121class Positive(UnivariateContinuous):
+122    @abstractmethod
+123    def _logpdf(self, x: Numeric) -> Numeric: ...
+124
+125    def to_real(self, x: Numeric) -> Numeric:
+126        return np.log(x)
+127
+128    def to_native(self, z: Numeric) -> Numeric:
+129        return np.exp(z)
+130
+131    def logdetjac(self, z: Numeric) -> Numeric:
+132        return z
+133
+134    def logpdf(self, x: Numeric) -> Numeric:
+135        # ignore divide by zero encountered in log.
+136        with np.errstate(divide="ignore"):
+137            return np.where(x > 0, self._logpdf(np.maximum(0, x)), -np.inf)
+138
+139
+140class LowerUpperBounded(UnivariateContinuous, ABC):
+141    @abstractmethod
+142    def _logpdf(self, x: Numeric) -> Numeric: ...
+143
+144    def __init__(self, lower: Numeric, upper: Numeric, check: bool = True):
+145        self.lower = lower
+146        self.upper = upper
+147        self.range = self.upper - self.lower
+148        if check and np.any(self.range <= 0):
+149            raise InvalidBoundsError(
+150                "In LowerUpperBounded, lower bound needs to be strictly less than upper bound!"
+151            )
+152
+153    def to_real(self, x: Numeric) -> Numeric:
+154        return logit((x - self.lower) / self.range)
+155
+156    def to_native(self, z: Numeric) -> Numeric:
+157        return expit(z) * self.range + self.lower
+158
+159    def logdetjac(self, z: Numeric) -> Numeric:
+160        return np.log(self.range) + z - 2 * np.logaddexp(0, z)
+161
+162    def logpdf(self, x: Numeric) -> Numeric:
+163        # ignore divide by zero encountered in log.
+164        with np.errstate(divide="ignore"):
+165            return np.where(
+166                (self.lower < x) & (x < self.upper),
+167                self._logpdf(np.clip(x, self.lower, self.upper)),
+168                -np.inf,
+169            )
+170
+171
+172class MultivariateContinuous(Multivariate, Continuous):
+173    def logpdf_plus_logdetjac(self, z: ndarray) -> Numeric:
+174        """Logpdf plus the log absolute determinant of the jacobian.
+175
+176        Logpdf plus the log absolute determinant of the jacobian, evaluated at
+177        parameter on the transformed (real) space.
+178        """
+179        x = self.to_native(z)
+180        return self.logpdf(x) + self.logdetjac(z)
+181
+182    @abstractmethod
+183    def cov(self) -> ndarray: ...
+184
+185    @abstractmethod
+186    def mean(self) -> ndarray: ...
+187
+188
+189class Real:
+190    def to_real(self, x: Numeric) -> Numeric:
+191        return x
+192
+193    def to_native(self, z: Numeric) -> Numeric:
+194        return z
+195
+196    def logdetjac(self, z: Numeric) -> Numeric:
+197        return 0
+198
+199
+200class UnivariateReal(Real, UnivariateContinuous): ...
+201
+202
+203class MultivariateReal(Real, MultivariateContinuous): ...
+
+ + +
+
+ +
+ + class + Distribution(abc.ABC): + + + +
+ + 
14class Distribution(ABC):
+15    @cached_property
+16    @abstractmethod
+17    def event_shape(self): ...
+18
+19    # TODO: Think about how to implement this.
+20    @cached_property
+21    @abstractmethod
+22    def batch_shape(self): ...
+23
+24    @abstractmethod
+25    def logpdf(self, x: Numeric) -> Numeric: ...
+26
+27    @abstractmethod
+28    def sample(
+29        self, sample_shape: Shape = (), rng: RNG = default_rng()
+30    ) -> ndarray: ...
+31
+32    def pdf(self, x: Numeric) -> Numeric:
+33        return np.exp(self.logpdf(x))
+34
+35    @cached_property
+36    @abstractmethod
+37    def mean(self) -> Numeric: ...
+38
+39    @cached_property
+40    def std(self) -> Numeric:
+41        return np.sqrt(self.var)
+42
+43    @cached_property
+44    @abstractmethod
+45    def var(self) -> Numeric: ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ event_shape + + + +
+ + 
15    @cached_property
+16    @abstractmethod
+17    def event_shape(self): ...
+
+ + + + +
+
+ +
+ batch_shape + + + +
+ + 
20    @cached_property
+21    @abstractmethod
+22    def batch_shape(self): ...
+
+ + + + +
+
+ +
+
@abstractmethod
+ + def + logpdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
24    @abstractmethod
+25    def logpdf(self, x: Numeric) -> Numeric: ...
+
+ + + + +
+
+ +
+
@abstractmethod
+ + def + sample( self, sample_shape: tuple[int, ...] = (), rng: numpy.random._generator.Generator = Generator(PCG64) at 0x103F8E960) -> numpy.ndarray: + + + +
+ + 
27    @abstractmethod
+28    def sample(
+29        self, sample_shape: Shape = (), rng: RNG = default_rng()
+30    ) -> ndarray: ...
+
+ + + + +
+
+ +
+ + def + pdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
32    def pdf(self, x: Numeric) -> Numeric:
+33        return np.exp(self.logpdf(x))
+
+ + + + +
+
+ +
+ mean: float | numpy.ndarray + + + +
+ + 
35    @cached_property
+36    @abstractmethod
+37    def mean(self) -> Numeric: ...
+
+ + + + +
+
+ +
+ std: float | numpy.ndarray + + + +
+ + 
39    @cached_property
+40    def std(self) -> Numeric:
+41        return np.sqrt(self.var)
+
+ + + + +
+
+ +
+ var: float | numpy.ndarray + + + +
+ + 
43    @cached_property
+44    @abstractmethod
+45    def var(self) -> Numeric: ...
+
+ + + + +
+
+
+ +
+ + class + Continuous(Distribution): + + + +
+ + 
48class Continuous(Distribution):
+49    @abstractmethod
+50    def to_real(self, x: Numeric) -> Numeric: ...
+51
+52    @abstractmethod
+53    def to_native(self, z: Numeric) -> Numeric: ...
+54
+55    @abstractmethod
+56    def logdetjac(self, z: Numeric) -> Numeric: ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+
@abstractmethod
+ + def + to_real(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
49    @abstractmethod
+50    def to_real(self, x: Numeric) -> Numeric: ...
+
+ + + + +
+
+ +
+
@abstractmethod
+ + def + to_native(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
52    @abstractmethod
+53    def to_native(self, z: Numeric) -> Numeric: ...
+
+ + + + +
+
+ +
+
@abstractmethod
+ + def + logdetjac(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
55    @abstractmethod
+56    def logdetjac(self, z: Numeric) -> Numeric: ...
+
+ + + + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + Discrete(Distribution): + + + +
+ + 
59class Discrete(Distribution): ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + Multivariate(Distribution): + + + +
+ + 
62class Multivariate(Distribution):
+63    @cached_property
+64    @abstractmethod
+65    def mean(self) -> ndarray: ...
+66
+67    @cached_property
+68    def std(self) -> ndarray:
+69        return np.sqrt(self.var)
+70
+71    @cached_property
+72    @abstractmethod
+73    def var(self) -> ndarray: ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ mean: numpy.ndarray + + + +
+ + 
63    @cached_property
+64    @abstractmethod
+65    def mean(self) -> ndarray: ...
+
+ + + + +
+
+ +
+ std: numpy.ndarray + + + +
+ + 
67    @cached_property
+68    def std(self) -> ndarray:
+69        return np.sqrt(self.var)
+
+ + + + +
+
+ +
+ var: numpy.ndarray + + + +
+ + 
71    @cached_property
+72    @abstractmethod
+73    def var(self) -> ndarray: ...
+
+ + + + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + Univariate(Distribution): + + + +
+ + 
76class Univariate(Distribution):
+77    @cached_property
+78    def event_shape(self) -> Shape:
+79        return ()
+80
+81    @cached_property
+82    @abstractmethod
+83    def batch_shape(self) -> Shape: ...
+84
+85    def _reshape(self, sample_shape: Shape) -> Shape:
+86        return sample_shape + self.batch_shape
+87
+88    @abstractmethod
+89    def _sample(self, size: Shape, rng: RNG) -> ndarray: ...
+90
+91    def sample(
+92        self, sample_shape: Shape = (), rng: RNG = default_rng()
+93    ) -> ndarray:
+94        shape = self._reshape(sample_shape)
+95        return self._sample(shape, rng)
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ event_shape: tuple[int, ...] + + + +
+ + 
77    @cached_property
+78    def event_shape(self) -> Shape:
+79        return ()
+
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
81    @cached_property
+82    @abstractmethod
+83    def batch_shape(self) -> Shape: ...
+
+ + + + +
+
+ +
+ + def + sample( self, sample_shape: tuple[int, ...] = (), rng: numpy.random._generator.Generator = Generator(PCG64) at 0x103F8EDC0) -> numpy.ndarray: + + + +
+ + 
91    def sample(
+92        self, sample_shape: Shape = (), rng: RNG = default_rng()
+93    ) -> ndarray:
+94        shape = self._reshape(sample_shape)
+95        return self._sample(shape, rng)
+
+ + + + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + UnivariateContinuous(Univariate, Continuous): + + + +
+ + 
 98class UnivariateContinuous(Univariate, Continuous):
+ 99    def logpdf_plus_logdetjac(self, z: Numeric) -> Numeric:
+100        """Logpdf plus the log absolute determinant of the jacobian.
+101
+102        Logpdf plus the log absolute determinant of the jacobian, evaluated at
+103        parameter on the transformed (real) space.
+104        """
+105        x = self.to_native(z)
+106        return self.logpdf(x) + self.logdetjac(z)
+107
+108    @abstractmethod
+109    def logcdf(self, x: Numeric) -> Numeric: ...
+110
+111    def cdf(self, x: Numeric) -> Numeric:
+112        with np.errstate(divide="ignore"):
+113            return np.exp(self.logcdf(x))
+114
+115    def survival(self, x: Numeric) -> Numeric:
+116        return 1 - self.cdf(x)
+117
+118    def logsurvival(self, x: Numeric) -> Numeric:
+119        return np.log1p(-self.cdf(x))
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + def + logpdf_plus_logdetjac(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
 99    def logpdf_plus_logdetjac(self, z: Numeric) -> Numeric:
+100        """Logpdf plus the log absolute determinant of the jacobian.
+101
+102        Logpdf plus the log absolute determinant of the jacobian, evaluated at
+103        parameter on the transformed (real) space.
+104        """
+105        x = self.to_native(z)
+106        return self.logpdf(x) + self.logdetjac(z)
+
+ + +

Logpdf plus the log absolute determinant of the jacobian.

+ +

Logpdf plus the log absolute determinant of the jacobian, evaluated at +parameter on the transformed (real) space.

+
+ + +
+
+ +
+
@abstractmethod
+ + def + logcdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
108    @abstractmethod
+109    def logcdf(self, x: Numeric) -> Numeric: ...
+
+ + + + +
+
+ +
+ + def + cdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
111    def cdf(self, x: Numeric) -> Numeric:
+112        with np.errstate(divide="ignore"):
+113            return np.exp(self.logcdf(x))
+
+ + + + +
+
+ +
+ + def + survival(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
115    def survival(self, x: Numeric) -> Numeric:
+116        return 1 - self.cdf(x)
+
+ + + + +
+
+ +
+ + def + logsurvival(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
118    def logsurvival(self, x: Numeric) -> Numeric:
+119        return np.log1p(-self.cdf(x))
+
+ + + + +
+
+
Inherited Members
+
+ + + +
+
+
+
+ +
+ + class + Positive(UnivariateContinuous): + + + +
+ + 
122class Positive(UnivariateContinuous):
+123    @abstractmethod
+124    def _logpdf(self, x: Numeric) -> Numeric: ...
+125
+126    def to_real(self, x: Numeric) -> Numeric:
+127        return np.log(x)
+128
+129    def to_native(self, z: Numeric) -> Numeric:
+130        return np.exp(z)
+131
+132    def logdetjac(self, z: Numeric) -> Numeric:
+133        return z
+134
+135    def logpdf(self, x: Numeric) -> Numeric:
+136        # ignore divide by zero encountered in log.
+137        with np.errstate(divide="ignore"):
+138            return np.where(x > 0, self._logpdf(np.maximum(0, x)), -np.inf)
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + def + to_real(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
126    def to_real(self, x: Numeric) -> Numeric:
+127        return np.log(x)
+
+ + + + +
+
+ +
+ + def + to_native(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
129    def to_native(self, z: Numeric) -> Numeric:
+130        return np.exp(z)
+
+ + + + +
+
+ +
+ + def + logdetjac(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
132    def logdetjac(self, z: Numeric) -> Numeric:
+133        return z
+
+ + + + +
+
+ +
+ + def + logpdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
135    def logpdf(self, x: Numeric) -> Numeric:
+136        # ignore divide by zero encountered in log.
+137        with np.errstate(divide="ignore"):
+138            return np.where(x > 0, self._logpdf(np.maximum(0, x)), -np.inf)
+
+ + + + +
+
+
Inherited Members
+
+ + +
Distribution
+
pdf
+
mean
+
std
+
var
+ +
+
+
+
+
+ +
+ + class + LowerUpperBounded(UnivariateContinuous, abc.ABC): + + + +
+ + 
141class LowerUpperBounded(UnivariateContinuous, ABC):
+142    @abstractmethod
+143    def _logpdf(self, x: Numeric) -> Numeric: ...
+144
+145    def __init__(self, lower: Numeric, upper: Numeric, check: bool = True):
+146        self.lower = lower
+147        self.upper = upper
+148        self.range = self.upper - self.lower
+149        if check and np.any(self.range <= 0):
+150            raise InvalidBoundsError(
+151                "In LowerUpperBounded, lower bound needs to be strictly less than upper bound!"
+152            )
+153
+154    def to_real(self, x: Numeric) -> Numeric:
+155        return logit((x - self.lower) / self.range)
+156
+157    def to_native(self, z: Numeric) -> Numeric:
+158        return expit(z) * self.range + self.lower
+159
+160    def logdetjac(self, z: Numeric) -> Numeric:
+161        return np.log(self.range) + z - 2 * np.logaddexp(0, z)
+162
+163    def logpdf(self, x: Numeric) -> Numeric:
+164        # ignore divide by zero encountered in log.
+165        with np.errstate(divide="ignore"):
+166            return np.where(
+167                (self.lower < x) & (x < self.upper),
+168                self._logpdf(np.clip(x, self.lower, self.upper)),
+169                -np.inf,
+170            )
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
+ lower + + +
+ + + + +
+
+
+ upper + + +
+ + + + +
+
+
+ range + + +
+ + + + +
+
+ +
+ + def + to_real(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
154    def to_real(self, x: Numeric) -> Numeric:
+155        return logit((x - self.lower) / self.range)
+
+ + + + +
+
+ +
+ + def + to_native(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
157    def to_native(self, z: Numeric) -> Numeric:
+158        return expit(z) * self.range + self.lower
+
+ + + + +
+
+ +
+ + def + logdetjac(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
160    def logdetjac(self, z: Numeric) -> Numeric:
+161        return np.log(self.range) + z - 2 * np.logaddexp(0, z)
+
+ + + + +
+
+ +
+ + def + logpdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
163    def logpdf(self, x: Numeric) -> Numeric:
+164        # ignore divide by zero encountered in log.
+165        with np.errstate(divide="ignore"):
+166            return np.where(
+167                (self.lower < x) & (x < self.upper),
+168                self._logpdf(np.clip(x, self.lower, self.upper)),
+169                -np.inf,
+170            )
+
+ + + + +
+
+
Inherited Members
+
+ + +
Distribution
+
pdf
+
mean
+
std
+
var
+ +
+
+
+
+
+ +
+ + class + MultivariateContinuous(Multivariate, Continuous): + + + +
+ + 
173class MultivariateContinuous(Multivariate, Continuous):
+174    def logpdf_plus_logdetjac(self, z: ndarray) -> Numeric:
+175        """Logpdf plus the log absolute determinant of the jacobian.
+176
+177        Logpdf plus the log absolute determinant of the jacobian, evaluated at
+178        parameter on the transformed (real) space.
+179        """
+180        x = self.to_native(z)
+181        return self.logpdf(x) + self.logdetjac(z)
+182
+183    @abstractmethod
+184    def cov(self) -> ndarray: ...
+185
+186    @abstractmethod
+187    def mean(self) -> ndarray: ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + def + logpdf_plus_logdetjac(self, z: numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
174    def logpdf_plus_logdetjac(self, z: ndarray) -> Numeric:
+175        """Logpdf plus the log absolute determinant of the jacobian.
+176
+177        Logpdf plus the log absolute determinant of the jacobian, evaluated at
+178        parameter on the transformed (real) space.
+179        """
+180        x = self.to_native(z)
+181        return self.logpdf(x) + self.logdetjac(z)
+
+ + +

Logpdf plus the log absolute determinant of the jacobian.

+ +

Logpdf plus the log absolute determinant of the jacobian, evaluated at +parameter on the transformed (real) space.

+
+ + +
+
+ +
+
@abstractmethod
+ + def + cov(self) -> numpy.ndarray: + + + +
+ + 
183    @abstractmethod
+184    def cov(self) -> ndarray: ...
+
+ + + + +
+
+ +
+
@abstractmethod
+ + def + mean(self) -> numpy.ndarray: + + + +
+ + 
186    @abstractmethod
+187    def mean(self) -> ndarray: ...
+
+ + + + +
+
+
Inherited Members
+
+ + + +
+
+
+
+ +
+ + class + Real: + + + +
+ + 
190class Real:
+191    def to_real(self, x: Numeric) -> Numeric:
+192        return x
+193
+194    def to_native(self, z: Numeric) -> Numeric:
+195        return z
+196
+197    def logdetjac(self, z: Numeric) -> Numeric:
+198        return 0
+
+ + + + +
+ +
+ + def + to_real(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
191    def to_real(self, x: Numeric) -> Numeric:
+192        return x
+
+ + + + +
+
+ +
+ + def + to_native(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
194    def to_native(self, z: Numeric) -> Numeric:
+195        return z
+
+ + + + +
+
+ +
+ + def + logdetjac(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
197    def logdetjac(self, z: Numeric) -> Numeric:
+198        return 0
+
+ + + + +
+
+
+ +
+ + class + UnivariateReal(Real, UnivariateContinuous): + + + +
+ + 
201class UnivariateReal(Real, UnivariateContinuous): ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + MultivariateReal(Real, MultivariateContinuous): + + + +
+ + 
204class MultivariateReal(Real, MultivariateContinuous): ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+ + + + +
+
+
+
+ + \ No newline at end of file diff --git a/docs/arianna/distributions/distributions.html b/docs/arianna/distributions/distributions.html new file mode 100644 index 0000000..0801502 --- /dev/null +++ b/docs/arianna/distributions/distributions.html @@ -0,0 +1,4517 @@ + + + + + + + arianna.distributions.distributions API documentation + + + + + + + + + + + + +
+
+

+arianna.distributions.distributions

+ + + + + + + 
  1from functools import cached_property
+  2from typing import Optional
+  3
+  4import numpy as np
+  5from numpy import ndarray
+  6from numpy.random import Generator as RNG
+  7from numpy.random import default_rng
+  8from scipy.special import (
+  9    betainc,
+ 10    betaln,
+ 11    gammaln,
+ 12    gdtr,
+ 13    gdtrc,
+ 14    log_ndtr,
+ 15    ndtr,
+ 16)
+ 17
+ 18from arianna.types import NegativeParameterError
+ 19
+ 20from .abstract import (
+ 21    Distribution,
+ 22    LowerUpperBounded,
+ 23    MultivariateContinuous,
+ 24    MultivariateReal,
+ 25    Numeric,
+ 26    Positive,
+ 27    Shape,
+ 28    UnivariateReal,
+ 29)
+ 30
+ 31
+ 32class IndependentRagged(Distribution): ...
+ 33
+ 34
+ 35class Independent(Distribution):
+ 36    def __init__(self, dists: list[Distribution]):
+ 37        assert self.is_same_family(dists)
+ 38        self.dists = dists
+ 39
+ 40    def is_same_family(self, dists: list[Distribution]) -> bool:
+ 41        first_type = type(dists[0])
+ 42        return all(type(d) is first_type for d in dists)
+ 43
+ 44    def logpdf(self, x: list[Numeric]) -> Numeric:
+ 45        return sum(di.logpdf(xi) for di, xi in zip(self.dists, x))
+ 46
+ 47    def sample(self, sample_shape=[]) -> ndarray:
+ 48        # TODO: Check the logic.
+ 49        return np.stack([di.sample(sample_shape) for di in self.dists])
+ 50
+ 51
+ 52class Uniform(LowerUpperBounded):
+ 53    @classmethod
+ 54    def from_mean_shift(cls, mean, shift):
+ 55        return cls(mean - shift, mean + shift)
+ 56
+ 57    @cached_property
+ 58    def batch_shape(self) -> Shape:
+ 59        return np.broadcast_shapes(np.shape(self.lower), np.shape(self.upper))
+ 60
+ 61    def _logpdf(self, x: Numeric) -> Numeric:
+ 62        return -np.log(self.range)
+ 63
+ 64    def logcdf(self, x: Numeric) -> Numeric:
+ 65        with np.errstate(divide="ignore"):
+ 66            return np.log(self.cdf(x))
+ 67
+ 68    def cdf(self, x: Numeric) -> Numeric:
+ 69        return np.clip((x - self.lower) / self.range, 0, 1)
+ 70
+ 71    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+ 72        return rng.uniform(self.lower, self.upper, size=size)
+ 73
+ 74    @cached_property
+ 75    def mode(self) -> Numeric:
+ 76        # FIXME: Really, it should be anything in [lower, upper].
+ 77        return self.mean
+ 78
+ 79    @cached_property
+ 80    def median(self) -> Numeric:
+ 81        return self.mean
+ 82
+ 83    @cached_property
+ 84    def mean(self) -> Numeric:
+ 85        return (self.lower + self.upper) / 2
+ 86
+ 87    @cached_property
+ 88    def var(self) -> Numeric:
+ 89        return np.square(self.range) / 12
+ 90
+ 91
+ 92class Beta(LowerUpperBounded):
+ 93    def __init__(self, a: Numeric, b: Numeric, check: bool = True):
+ 94        super().__init__(lower=0, upper=1)
+ 95        if check and np.any(a < 0):
+ 96            raise NegativeParameterError(
+ 97                "In Beta(a,b), `a` must be strictly positive!"
+ 98            )
+ 99        if check and np.any(b < 0):
+100            raise NegativeParameterError(
+101                "In Beta(a,b), `b` must be strictly positive!"
+102            )
+103        self.a = a
+104        self.b = b
+105
+106    @cached_property
+107    def mode(self) -> Numeric:
+108        # https://en.wikipedia.org/wiki/Beta_distribution
+109        raise NotImplementedError
+110
+111    @cached_property
+112    def batch_shape(self) -> Shape:
+113        return np.broadcast(self.a, self.b).shape
+114
+115    def _logpdf(self, x: Numeric) -> Numeric:
+116        # Hide warnings if 0 * inf, which is nan. Should just return -inf.
+117        with np.errstate(invalid="ignore"):
+118            return (
+119                (self.a - 1) * np.log(x)
+120                + (self.b - 1) * np.log1p(-x)
+121                - betaln(self.a, self.b)
+122            )
+123
+124    def logcdf(self, x: Numeric) -> Numeric:
+125        with np.errstate(divide="ignore"):
+126            return np.log(self.cdf(x))
+127
+128    def cdf(self, x: Numeric) -> Numeric:
+129        return betainc(self.a, self.b, np.clip(x, 0, 1))
+130
+131    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+132        return rng.beta(self.a, self.b, size=size)
+133
+134    @cached_property
+135    def mean(self) -> Numeric:
+136        return self.a / (self.a + self.b)
+137
+138    @cached_property
+139    def var(self):
+140        c = self.a + self.b
+141        return self.a * self.b / (np.square(c) * (c + 1))
+142
+143
+144# TODO (12/4/2024): Write tests for all methods in Scaled Beta.
+145class ScaledBeta(LowerUpperBounded):
+146    def __init__(
+147        self,
+148        a: Numeric,
+149        b: Numeric,
+150        lower: Numeric,
+151        upper: Numeric,
+152        check: bool = True,
+153    ):
+154        super().__init__(lower=lower, upper=upper)
+155        if check and np.any(a < 0):
+156            raise NegativeParameterError(
+157                "In ScaledBeta(a,b,lower,upper), `a` must be strictly positive!"
+158            )
+159        if check and np.any(b < 0):
+160            raise NegativeParameterError(
+161                "In ScaledBeta(a,b,lower,upper), `b` must be strictly positive!"
+162            )
+163
+164        self.a = a
+165        self.b = b
+166        self.base_dist = Beta(self.a, self.b, check=False)
+167
+168    @cached_property
+169    def batch_shape(self) -> Shape:
+170        return np.broadcast(self.a, self.b, self.lower, self.upper).shape
+171
+172    def _broadcast(self, x: Numeric) -> Numeric:
+173        shape = np.broadcast_shapes(np.shape(x), self.batch_shape)
+174        return np.broadcast_to(x, shape)
+175
+176    def _to_unit_interval(self, x: Numeric) -> Numeric:
+177        return self._broadcast((x - self.lower) / self.range)
+178
+179    def _from_unit_interval(self, y: Numeric) -> Numeric:
+180        return self._broadcast(y * self.range + self.lower)
+181
+182    def _sample(self, size: Shape, rng: RNG) -> Numeric:
+183        return self._from_unit_interval(
+184            self.base_dist._sample(size=size, rng=rng)
+185        )
+186
+187    def cdf(self, x: Numeric) -> Numeric:
+188        return self.base_dist.cdf(self._to_unit_interval(x))
+189
+190    def logcdf(self, x: Numeric) -> Numeric:
+191        with np.errstate(divide="ignore"):
+192            return np.log(self.cdf(x))
+193
+194    def _logpdf(self, x: Numeric) -> Numeric:
+195        return self.base_dist._logpdf(self._to_unit_interval(x)) - np.log(
+196            self.range
+197        )
+198
+199    @cached_property
+200    def mean(self) -> Numeric:
+201        return self._from_unit_interval(self.base_dist.mean)
+202
+203    @cached_property
+204    def var(self) -> Numeric:
+205        return self.base_dist.var * self.range**2
+206
+207
+208class Gamma(Positive):
+209    @classmethod
+210    def from_mean_std(cls, mean, std, check: bool = True):
+211        if check and np.any(mean < 0):
+212            raise NegativeParameterError(
+213                "In Gamma.from_mean_std(mean, std), `mean` must be strictly positive!"
+214            )
+215        if check and np.any(std < 0):
+216            raise NegativeParameterError(
+217                "In Gamma.from_mean_std(mean, std), `std` must be strictly positive!"
+218            )
+219
+220        var = std**2
+221        return cls(shape=mean**2 / var, scale=var / mean)
+222
+223    def __init__(self, shape: Numeric, scale: Numeric, check: bool = True):
+224        if check and np.any(shape < 0):
+225            raise NegativeParameterError(
+226                "In Gamma(shape, scale), `shape` must be strictly positive!"
+227            )
+228        if check and np.any(scale < 0):
+229            raise NegativeParameterError(
+230                "In Gamma(shape, scale), `scale` must be strictly positive!"
+231            )
+232
+233        self.shape = shape
+234        self.scale = scale
+235
+236    @cached_property
+237    def batch_shape(self) -> Shape:
+238        return np.broadcast(self.shape, self.scale).shape
+239
+240    def _logpdf(self, x: Numeric) -> Numeric:
+241        # Hide warnings if 0 * inf, which is nan. Should just return -inf.
+242        with np.errstate(invalid="ignore"):
+243            return (
+244                -gammaln(self.shape)
+245                - self.shape * np.log(self.scale)
+246                + (self.shape - 1) * np.log(x)
+247                - x / self.scale
+248            )
+249
+250    def logcdf(self, x: Numeric) -> Numeric:
+251        with np.errstate(divide="ignore"):
+252            return np.log(self.cdf(x))
+253
+254    def cdf(self, x: Numeric) -> Numeric:
+255        return gdtr(1 / self.scale, self.shape, np.maximum(0, x))
+256
+257    def survival(self, x: Numeric) -> Numeric:
+258        return gdtrc(1 / self.scale, self.shape, np.maximum(0, x))
+259
+260    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+261        return rng.gamma(shape=self.shape, scale=self.scale, size=size)
+262
+263    @cached_property
+264    def mean(self) -> Numeric:
+265        return self.shape * self.scale
+266
+267    @cached_property
+268    def var(self) -> Numeric:
+269        return self.shape * np.square(self.scale)
+270
+271    @cached_property
+272    def mode(self) -> Numeric:
+273        return np.where(self.shape > 1, self.scale * (self.shape - 1), 0.0)
+274
+275
+276# https://en.wikipedia.org/wiki/Inverse-gamma_distribution
+277class InverseGamma(Positive):
+278    @classmethod
+279    def from_mean_std(cls, mean, std, check: bool = True):
+280        if check and np.any(mean < 0):
+281            raise NegativeParameterError(
+282                "In InverseGamma.from_mean_std(mean, mean), `mean` must be strictly positive!"
+283            )
+284        if check and np.any(std < 0):
+285            raise NegativeParameterError(
+286                "In InverseGamma.from_mean_std(mean, mean), `std` must be strictly positive!"
+287            )
+288
+289        shape = (mean / std) ** 2 + 2
+290        scale = mean * (shape - 1)
+291        return cls(shape, scale)
+292
+293    def __init__(self, shape: Numeric, scale: Numeric, check: bool = True):
+294        if check and np.any(shape < 0):
+295            raise NegativeParameterError(
+296                "In InverseGamma(shape, scale), `shape` must be strictly positive!"
+297            )
+298        if check and np.any(scale < 0):
+299            raise NegativeParameterError(
+300                "In InverseGamma(shape, scale), `scale` must be strictly positive!"
+301            )
+302
+303        self.shape = shape
+304        self.scale = scale
+305
+306    @cached_property
+307    def batch_shape(self) -> Shape:
+308        return np.broadcast(self.shape, self.scale).shape
+309
+310    @cached_property
+311    def mean(self) -> Numeric:
+312        return np.where(self.shape > 1, self.scale / (self.shape - 1), np.nan)
+313
+314    @cached_property
+315    def var(self) -> Numeric:
+316        return np.where(self.shape > 2, self.mean**2 / (self.shape - 2), np.nan)
+317
+318    @cached_property
+319    def mode(self) -> Numeric:
+320        return self.scale / (self.shape + 1)
+321
+322    def _logpdf(self, x: Numeric) -> Numeric:
+323        # Hide warnings if 0 * inf, which is nan. Should just return -inf.
+324        with np.errstate(invalid="ignore", divide="ignore"):
+325            return (
+326                self.shape * np.log(self.scale)
+327                - gammaln(self.shape)
+328                - (self.shape + 1) * np.log(x)
+329                - self.scale / x
+330            )
+331
+332    def logcdf(self, x: Numeric) -> Numeric:
+333        with np.errstate(divide="ignore"):
+334            return np.log(self.cdf(x))
+335
+336    def cdf(self, x: Numeric) -> Numeric:
+337        with np.errstate(divide="ignore"):
+338            x = np.maximum(0, x)
+339            return gdtrc(self.scale, self.shape, 1 / x)
+340
+341    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+342        return 1 / rng.gamma(shape=self.shape, scale=1 / self.scale, size=size)
+343
+344
+345class LogNormal(Positive):
+346    @classmethod
+347    def from_mean_std(cls, mean, std, check: bool = True):
+348        if check and np.any(mean < 0):
+349            raise NegativeParameterError(
+350                "In LogNormal.from_mean_std(mean, std), `mean` must be strictly positive!"
+351            )
+352        if check and np.any(std < 0):
+353            raise NegativeParameterError(
+354                "In LogNormal.from_mean_std(mean, std), `std` must be strictly positive!"
+355            )
+356        var = std**2
+357        sigma_squared = np.log1p(var / mean**2)
+358        mu = np.log(mean) - sigma_squared / 2
+359        sigma = np.sqrt(sigma_squared)
+360        return cls(mu, sigma)
+361
+362    def __init__(self, mu: Numeric, sigma: Numeric, check: bool = True):
+363        if check and np.any(sigma < 0):
+364            raise NegativeParameterError(
+365                "In LogNormal(mu, sigma), `sigma` must be strictly positive!"
+366            )
+367
+368        self.mu = mu
+369        self.sigma = sigma
+370
+371    @cached_property
+372    def batch_shape(self) -> Shape:
+373        return np.broadcast(self.mu, self.sigma).shape
+374
+375    @cached_property
+376    def mean(self) -> Numeric:
+377        return np.exp(self.mu + self.sigma**2 / 2)
+378
+379    @cached_property
+380    def var(self) -> Numeric:
+381        return (np.exp(self.sigma**2) - 1) * np.exp(2 * self.mu + self.sigma**2)
+382
+383    @cached_property
+384    def mode(self) -> Numeric:
+385        return np.exp(self.mu - self.sigma**2)
+386
+387    @cached_property
+388    def median(self) -> Numeric:
+389        return np.exp(self.mu)
+390
+391    def _logpdf(self, x: Numeric) -> Numeric:
+392        # Hide warnings if 0 * inf, which is nan. Should just return -inf.
+393        with np.errstate(divide="ignore", invalid="ignore"):
+394            z = (np.log(x) - self.mu) / self.sigma
+395            return -np.log(x * self.sigma * np.sqrt(2 * np.pi)) - z**2 / 2
+396
+397    def logcdf(self, x: Numeric) -> Numeric:
+398        x = np.maximum(0, x)
+399        with np.errstate(divide="ignore"):
+400            z = (np.log(x) - self.mu) / self.sigma
+401            return log_ndtr(z)
+402
+403    def cdf(self, x: Numeric) -> Numeric:
+404        x = np.maximum(0, x)
+405        with np.errstate(divide="ignore"):
+406            z = (np.log(x) - self.mu) / self.sigma
+407            return ndtr(z)
+408
+409    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+410        return rng.lognormal(self.mu, self.sigma, size=size)
+411
+412
+413class Weibull(Positive): ...
+414
+415
+416class Gumbel(UnivariateReal): ...
+417
+418
+419class Logistic(Positive): ...
+420
+421
+422class LogLogistic(UnivariateReal): ...
+423
+424
+425class Normal(UnivariateReal):
+426    def __init__(
+427        self, loc: Numeric = 0.0, scale: Numeric = 1.0, check: bool = True
+428    ):
+429        if check and np.any(scale < 0):
+430            raise NegativeParameterError(
+431                "In Normal(loc, scale), `scale` must be strictly positive!"
+432            )
+433        self.loc = loc
+434        self.scale = scale
+435
+436    @cached_property
+437    def batch_shape(self) -> Shape:
+438        return np.broadcast(self.loc, self.scale).shape
+439
+440    def logpdf(self, x: Numeric) -> Numeric:
+441        z = (x - self.loc) / self.scale
+442        return -np.square(z) / 2 - np.log(2 * np.pi) / 2 - np.log(self.scale)
+443
+444    def logcdf(self, x: Numeric) -> Numeric:
+445        return log_ndtr((x - self.mean) / self.scale)
+446
+447    def cdf(self, x: Numeric) -> Numeric:
+448        return ndtr((x - self.mean) / self.scale)
+449
+450    def survival(self, x: Numeric) -> Numeric:
+451        return 1 - self.cdf(x)
+452
+453    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+454        return rng.normal(loc=self.loc, scale=self.scale, size=size)
+455
+456    @cached_property
+457    def mean(self) -> Numeric:
+458        return np.broadcast_to(self.loc, self.batch_shape)
+459
+460    @cached_property
+461    def std(self) -> Numeric:
+462        return np.broadcast_to(self.scale, self.batch_shape)
+463
+464    @cached_property
+465    def var(self) -> Numeric:
+466        return np.square(self.std)
+467
+468    @cached_property
+469    def mode(self) -> Numeric:
+470        return self.mean
+471
+472    @cached_property
+473    def median(self) -> Numeric:
+474        return self.mean
+475
+476
+477class MvNormal(MultivariateReal):
+478    def __init__(
+479        self,
+480        mean: Optional[ndarray] = None,
+481        cov: Optional[ndarray] = None,
+482        **kwargs,
+483    ):
+484        match mean, cov:
+485            case (None, None):
+486                raise ValueError("mean and cov cannot both be None!")
+487            case (None, _):
+488                mean = np.zeros(cov.shape[-1])
+489            case (_, None):
+490                cov = np.eye(mean.shape[-1])
+491
+492        super().__init__(**kwargs)
+493
+494        self._mean = mean
+495        self._cov = cov
+496
+497    @cached_property
+498    def mean(self) -> ndarray:
+499        return np.broadcast_to(self._mean, self.batch_plus_event_shape)
+500
+501    @cached_property
+502    def _icov(self) -> ndarray:
+503        return np.linalg.inv(self._cov)
+504
+505    @cached_property
+506    def cov(self) -> ndarray:
+507        return np.broadcast_to(
+508            self._cov, self.batch_plus_event_shape + self.event_shape
+509        )
+510
+511    @cached_property
+512    def cov_inv(self) -> ndarray:
+513        return np.broadcast_to(
+514            self._icov, self.batch_plus_event_shape + self.event_shape
+515        )
+516
+517    @cached_property
+518    def L(self) -> ndarray:
+519        return np.linalg.cholesky(self.cov)
+520
+521    @cached_property
+522    def event_shape(self) -> Shape:
+523        return self.mean.shape[-1:]
+524
+525    @cached_property
+526    def batch_shape(self) -> Shape:
+527        return self.batch_plus_event_shape[:-1]
+528
+529    @cached_property
+530    def batch_plus_event_shape(self) -> Shape:
+531        return np.broadcast_shapes(self._mean.shape, self._cov.shape[:-1])
+532
+533    @cached_property
+534    def log_det_cov(self) -> float | ndarray:
+535        _, ldc = np.linalg.slogdet(self.cov)
+536        return ldc
+537
+538    @cached_property
+539    def var(self) -> ndarray:
+540        return np.diagonal(self.cov, axis1=-2, axis2=-1)
+541
+542    def logpdf(self, x):
+543        d = x - self.mean
+544
+545        # Compute quadratic form
+546        quad_form = np.einsum("...i, ...ij, ...j -> ...", d, self.cov_inv, d)  # type: ignore
+547
+548        return -0.5 * (
+549            self.event_shape[0] * np.log(2 * np.pi)
+550            + self.log_det_cov
+551            + quad_form
+552        )
+553
+554    def sample(
+555        self, sample_shape: Shape = (), rng: RNG = default_rng()
+556    ) -> ndarray:
+557        shape = sample_shape + self.batch_shape + self.event_shape
+558        standard_normals = rng.standard_normal(shape)
+559        b = np.einsum("...ij,...j->...i", self.L, standard_normals)
+560        samples = self.mean + b
+561        return samples
+562
+563
+564class Dirichlet(MultivariateContinuous):
+565    def __init__(self, concentration: ndarray, check: bool = True):
+566        if check and np.any(concentration < 0):
+567            raise NegativeParameterError(
+568                "In Dirichlet(concentration), `concentration` must be stricly positive!"
+569            )
+570        self.concentration = concentration
+571
+572    @cached_property
+573    def concentration_sum(self):
+574        return self.concentration.sum(-1, keepdims=True)
+575
+576    @cached_property
+577    def event_shape(self):
+578        return self.concentration.shape[-1]
+579
+580    @cached_property
+581    def batch_plus_event_shape(self):
+582        return self.concentration.shape
+583
+584    @cached_property
+585    def batch_shape(self):
+586        return self.batch_plus_event_shape[:-1]
+587
+588    def logpdf(self, x: ndarray) -> float | ndarray:
+589        # TODO: Test.
+590        return (
+591            np.sum((self.concentration - 1) * np.log(x), -1)
+592            + gammaln(self.concentration.sum(-1))
+593            - gammaln(self.concentration).sum(-1)
+594        )
+595
+596    def sample(
+597        self, sample_shape: Shape = (), rng: RNG = default_rng()
+598    ) -> ndarray:
+599        shape = sample_shape + self.batch_plus_event_shape
+600        alpha = rng.standard_gamma(shape)
+601        return alpha / alpha.sum(-1, keepdims=True)
+602
+603    def to_real(self, x: ndarray) -> float | ndarray:
+604        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+605        raise NotImplementedError
+606
+607    def to_native(self, z: ndarray) -> float | ndarray:
+608        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+609        raise NotImplementedError
+610
+611    def logdetjac(self, z: ndarray) -> float | ndarray:
+612        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+613        raise NotImplementedError
+614
+615    @cached_property
+616    def cov(self) -> ndarray:
+617        raise NotImplementedError
+618
+619    @cached_property
+620    def mean(self) -> ndarray:
+621        return self.concentration / self.concentration_sum
+622
+623    @cached_property
+624    def var(self) -> ndarray:
+625        m = self.mean
+626        return m * (1 - m) / (1 + self.concentration_sum)
+627
+628    @cached_property
+629    def std(self) -> ndarray:
+630        return np.sqrt(self.var)
+
+ + +
+
+ +
+ + class + IndependentRagged(arianna.distributions.abstract.Distribution): + + + +
+ + 
33class IndependentRagged(Distribution): ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + Independent(arianna.distributions.abstract.Distribution): + + + +
+ + 
36class Independent(Distribution):
+37    def __init__(self, dists: list[Distribution]):
+38        assert self.is_same_family(dists)
+39        self.dists = dists
+40
+41    def is_same_family(self, dists: list[Distribution]) -> bool:
+42        first_type = type(dists[0])
+43        return all(type(d) is first_type for d in dists)
+44
+45    def logpdf(self, x: list[Numeric]) -> Numeric:
+46        return sum(di.logpdf(xi) for di, xi in zip(self.dists, x))
+47
+48    def sample(self, sample_shape=[]) -> ndarray:
+49        # TODO: Check the logic.
+50        return np.stack([di.sample(sample_shape) for di in self.dists])
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + Independent(dists: list[arianna.distributions.abstract.Distribution]) + + + +
+ + 
37    def __init__(self, dists: list[Distribution]):
+38        assert self.is_same_family(dists)
+39        self.dists = dists
+
+ + + + +
+
+
+ dists + + +
+ + + + +
+
+ +
+ + def + is_same_family(self, dists: list[arianna.distributions.abstract.Distribution]) -> bool: + + + +
+ + 
41    def is_same_family(self, dists: list[Distribution]) -> bool:
+42        first_type = type(dists[0])
+43        return all(type(d) is first_type for d in dists)
+
+ + + + +
+
+ +
+ + def + logpdf(self, x: list[float | numpy.ndarray]) -> float | numpy.ndarray: + + + +
+ + 
45    def logpdf(self, x: list[Numeric]) -> Numeric:
+46        return sum(di.logpdf(xi) for di, xi in zip(self.dists, x))
+
+ + + + +
+
+ +
+ + def + sample(self, sample_shape=[]) -> numpy.ndarray: + + + +
+ + 
48    def sample(self, sample_shape=[]) -> ndarray:
+49        # TODO: Check the logic.
+50        return np.stack([di.sample(sample_shape) for di in self.dists])
+
+ + + + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + Uniform(arianna.distributions.abstract.LowerUpperBounded): + + + +
+ + 
53class Uniform(LowerUpperBounded):
+54    @classmethod
+55    def from_mean_shift(cls, mean, shift):
+56        return cls(mean - shift, mean + shift)
+57
+58    @cached_property
+59    def batch_shape(self) -> Shape:
+60        return np.broadcast_shapes(np.shape(self.lower), np.shape(self.upper))
+61
+62    def _logpdf(self, x: Numeric) -> Numeric:
+63        return -np.log(self.range)
+64
+65    def logcdf(self, x: Numeric) -> Numeric:
+66        with np.errstate(divide="ignore"):
+67            return np.log(self.cdf(x))
+68
+69    def cdf(self, x: Numeric) -> Numeric:
+70        return np.clip((x - self.lower) / self.range, 0, 1)
+71
+72    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+73        return rng.uniform(self.lower, self.upper, size=size)
+74
+75    @cached_property
+76    def mode(self) -> Numeric:
+77        # FIXME: Really, it should be anything in [lower, upper].
+78        return self.mean
+79
+80    @cached_property
+81    def median(self) -> Numeric:
+82        return self.mean
+83
+84    @cached_property
+85    def mean(self) -> Numeric:
+86        return (self.lower + self.upper) / 2
+87
+88    @cached_property
+89    def var(self) -> Numeric:
+90        return np.square(self.range) / 12
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+
@classmethod
+ + def + from_mean_shift(cls, mean, shift): + + + +
+ + 
54    @classmethod
+55    def from_mean_shift(cls, mean, shift):
+56        return cls(mean - shift, mean + shift)
+
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
58    @cached_property
+59    def batch_shape(self) -> Shape:
+60        return np.broadcast_shapes(np.shape(self.lower), np.shape(self.upper))
+
+ + + + +
+
+ +
+ + def + logcdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
65    def logcdf(self, x: Numeric) -> Numeric:
+66        with np.errstate(divide="ignore"):
+67            return np.log(self.cdf(x))
+
+ + + + +
+
+ +
+ + def + cdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
69    def cdf(self, x: Numeric) -> Numeric:
+70        return np.clip((x - self.lower) / self.range, 0, 1)
+
+ + + + +
+
+ +
+ mode: float | numpy.ndarray + + + +
+ + 
75    @cached_property
+76    def mode(self) -> Numeric:
+77        # FIXME: Really, it should be anything in [lower, upper].
+78        return self.mean
+
+ + + + +
+
+ +
+ median: float | numpy.ndarray + + + +
+ + 
80    @cached_property
+81    def median(self) -> Numeric:
+82        return self.mean
+
+ + + + +
+
+ +
+ mean: float | numpy.ndarray + + + +
+ + 
84    @cached_property
+85    def mean(self) -> Numeric:
+86        return (self.lower + self.upper) / 2
+
+ + + + +
+
+ +
+ var: float | numpy.ndarray + + + +
+ + 
88    @cached_property
+89    def var(self) -> Numeric:
+90        return np.square(self.range) / 12
+
+ + + + +
+
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + Beta(arianna.distributions.abstract.LowerUpperBounded): + + + +
+ + 
 93class Beta(LowerUpperBounded):
+ 94    def __init__(self, a: Numeric, b: Numeric, check: bool = True):
+ 95        super().__init__(lower=0, upper=1)
+ 96        if check and np.any(a < 0):
+ 97            raise NegativeParameterError(
+ 98                "In Beta(a,b), `a` must be strictly positive!"
+ 99            )
+100        if check and np.any(b < 0):
+101            raise NegativeParameterError(
+102                "In Beta(a,b), `b` must be strictly positive!"
+103            )
+104        self.a = a
+105        self.b = b
+106
+107    @cached_property
+108    def mode(self) -> Numeric:
+109        # https://en.wikipedia.org/wiki/Beta_distribution
+110        raise NotImplementedError
+111
+112    @cached_property
+113    def batch_shape(self) -> Shape:
+114        return np.broadcast(self.a, self.b).shape
+115
+116    def _logpdf(self, x: Numeric) -> Numeric:
+117        # Hide warnings if 0 * inf, which is nan. Should just return -inf.
+118        with np.errstate(invalid="ignore"):
+119            return (
+120                (self.a - 1) * np.log(x)
+121                + (self.b - 1) * np.log1p(-x)
+122                - betaln(self.a, self.b)
+123            )
+124
+125    def logcdf(self, x: Numeric) -> Numeric:
+126        with np.errstate(divide="ignore"):
+127            return np.log(self.cdf(x))
+128
+129    def cdf(self, x: Numeric) -> Numeric:
+130        return betainc(self.a, self.b, np.clip(x, 0, 1))
+131
+132    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+133        return rng.beta(self.a, self.b, size=size)
+134
+135    @cached_property
+136    def mean(self) -> Numeric:
+137        return self.a / (self.a + self.b)
+138
+139    @cached_property
+140    def var(self):
+141        c = self.a + self.b
+142        return self.a * self.b / (np.square(c) * (c + 1))
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + Beta( a: float | numpy.ndarray, b: float | numpy.ndarray, check: bool = True) + + + +
+ + 
 94    def __init__(self, a: Numeric, b: Numeric, check: bool = True):
+ 95        super().__init__(lower=0, upper=1)
+ 96        if check and np.any(a < 0):
+ 97            raise NegativeParameterError(
+ 98                "In Beta(a,b), `a` must be strictly positive!"
+ 99            )
+100        if check and np.any(b < 0):
+101            raise NegativeParameterError(
+102                "In Beta(a,b), `b` must be strictly positive!"
+103            )
+104        self.a = a
+105        self.b = b
+
+ + + + +
+
+
+ a + + +
+ + + + +
+
+
+ b + + +
+ + + + +
+
+ +
+ mode: float | numpy.ndarray + + + +
+ + 
107    @cached_property
+108    def mode(self) -> Numeric:
+109        # https://en.wikipedia.org/wiki/Beta_distribution
+110        raise NotImplementedError
+
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
112    @cached_property
+113    def batch_shape(self) -> Shape:
+114        return np.broadcast(self.a, self.b).shape
+
+ + + + +
+
+ +
+ + def + logcdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
125    def logcdf(self, x: Numeric) -> Numeric:
+126        with np.errstate(divide="ignore"):
+127            return np.log(self.cdf(x))
+
+ + + + +
+
+ +
+ + def + cdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
129    def cdf(self, x: Numeric) -> Numeric:
+130        return betainc(self.a, self.b, np.clip(x, 0, 1))
+
+ + + + +
+
+ +
+ mean: float | numpy.ndarray + + + +
+ + 
135    @cached_property
+136    def mean(self) -> Numeric:
+137        return self.a / (self.a + self.b)
+
+ + + + +
+
+ +
+ var + + + +
+ + 
139    @cached_property
+140    def var(self):
+141        c = self.a + self.b
+142        return self.a * self.b / (np.square(c) * (c + 1))
+
+ + + + +
+
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + ScaledBeta(arianna.distributions.abstract.LowerUpperBounded): + + + +
+ + 
146class ScaledBeta(LowerUpperBounded):
+147    def __init__(
+148        self,
+149        a: Numeric,
+150        b: Numeric,
+151        lower: Numeric,
+152        upper: Numeric,
+153        check: bool = True,
+154    ):
+155        super().__init__(lower=lower, upper=upper)
+156        if check and np.any(a < 0):
+157            raise NegativeParameterError(
+158                "In ScaledBeta(a,b,lower,upper), `a` must be strictly positive!"
+159            )
+160        if check and np.any(b < 0):
+161            raise NegativeParameterError(
+162                "In ScaledBeta(a,b,lower,upper), `b` must be strictly positive!"
+163            )
+164
+165        self.a = a
+166        self.b = b
+167        self.base_dist = Beta(self.a, self.b, check=False)
+168
+169    @cached_property
+170    def batch_shape(self) -> Shape:
+171        return np.broadcast(self.a, self.b, self.lower, self.upper).shape
+172
+173    def _broadcast(self, x: Numeric) -> Numeric:
+174        shape = np.broadcast_shapes(np.shape(x), self.batch_shape)
+175        return np.broadcast_to(x, shape)
+176
+177    def _to_unit_interval(self, x: Numeric) -> Numeric:
+178        return self._broadcast((x - self.lower) / self.range)
+179
+180    def _from_unit_interval(self, y: Numeric) -> Numeric:
+181        return self._broadcast(y * self.range + self.lower)
+182
+183    def _sample(self, size: Shape, rng: RNG) -> Numeric:
+184        return self._from_unit_interval(
+185            self.base_dist._sample(size=size, rng=rng)
+186        )
+187
+188    def cdf(self, x: Numeric) -> Numeric:
+189        return self.base_dist.cdf(self._to_unit_interval(x))
+190
+191    def logcdf(self, x: Numeric) -> Numeric:
+192        with np.errstate(divide="ignore"):
+193            return np.log(self.cdf(x))
+194
+195    def _logpdf(self, x: Numeric) -> Numeric:
+196        return self.base_dist._logpdf(self._to_unit_interval(x)) - np.log(
+197            self.range
+198        )
+199
+200    @cached_property
+201    def mean(self) -> Numeric:
+202        return self._from_unit_interval(self.base_dist.mean)
+203
+204    @cached_property
+205    def var(self) -> Numeric:
+206        return self.base_dist.var * self.range**2
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + ScaledBeta( a: float | numpy.ndarray, b: float | numpy.ndarray, lower: float | numpy.ndarray, upper: float | numpy.ndarray, check: bool = True) + + + +
+ + 
147    def __init__(
+148        self,
+149        a: Numeric,
+150        b: Numeric,
+151        lower: Numeric,
+152        upper: Numeric,
+153        check: bool = True,
+154    ):
+155        super().__init__(lower=lower, upper=upper)
+156        if check and np.any(a < 0):
+157            raise NegativeParameterError(
+158                "In ScaledBeta(a,b,lower,upper), `a` must be strictly positive!"
+159            )
+160        if check and np.any(b < 0):
+161            raise NegativeParameterError(
+162                "In ScaledBeta(a,b,lower,upper), `b` must be strictly positive!"
+163            )
+164
+165        self.a = a
+166        self.b = b
+167        self.base_dist = Beta(self.a, self.b, check=False)
+
+ + + + +
+
+
+ a + + +
+ + + + +
+
+
+ b + + +
+ + + + +
+
+
+ base_dist + + +
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
169    @cached_property
+170    def batch_shape(self) -> Shape:
+171        return np.broadcast(self.a, self.b, self.lower, self.upper).shape
+
+ + + + +
+
+ +
+ + def + cdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
188    def cdf(self, x: Numeric) -> Numeric:
+189        return self.base_dist.cdf(self._to_unit_interval(x))
+
+ + + + +
+
+ +
+ + def + logcdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
191    def logcdf(self, x: Numeric) -> Numeric:
+192        with np.errstate(divide="ignore"):
+193            return np.log(self.cdf(x))
+
+ + + + +
+
+ +
+ mean: float | numpy.ndarray + + + +
+ + 
200    @cached_property
+201    def mean(self) -> Numeric:
+202        return self._from_unit_interval(self.base_dist.mean)
+
+ + + + +
+
+ +
+ var: float | numpy.ndarray + + + +
+ + 
204    @cached_property
+205    def var(self) -> Numeric:
+206        return self.base_dist.var * self.range**2
+
+ + + + +
+
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + Gamma(arianna.distributions.abstract.Positive): + + + +
+ + 
209class Gamma(Positive):
+210    @classmethod
+211    def from_mean_std(cls, mean, std, check: bool = True):
+212        if check and np.any(mean < 0):
+213            raise NegativeParameterError(
+214                "In Gamma.from_mean_std(mean, std), `mean` must be strictly positive!"
+215            )
+216        if check and np.any(std < 0):
+217            raise NegativeParameterError(
+218                "In Gamma.from_mean_std(mean, std), `std` must be strictly positive!"
+219            )
+220
+221        var = std**2
+222        return cls(shape=mean**2 / var, scale=var / mean)
+223
+224    def __init__(self, shape: Numeric, scale: Numeric, check: bool = True):
+225        if check and np.any(shape < 0):
+226            raise NegativeParameterError(
+227                "In Gamma(shape, scale), `shape` must be strictly positive!"
+228            )
+229        if check and np.any(scale < 0):
+230            raise NegativeParameterError(
+231                "In Gamma(shape, scale), `scale` must be strictly positive!"
+232            )
+233
+234        self.shape = shape
+235        self.scale = scale
+236
+237    @cached_property
+238    def batch_shape(self) -> Shape:
+239        return np.broadcast(self.shape, self.scale).shape
+240
+241    def _logpdf(self, x: Numeric) -> Numeric:
+242        # Hide warnings if 0 * inf, which is nan. Should just return -inf.
+243        with np.errstate(invalid="ignore"):
+244            return (
+245                -gammaln(self.shape)
+246                - self.shape * np.log(self.scale)
+247                + (self.shape - 1) * np.log(x)
+248                - x / self.scale
+249            )
+250
+251    def logcdf(self, x: Numeric) -> Numeric:
+252        with np.errstate(divide="ignore"):
+253            return np.log(self.cdf(x))
+254
+255    def cdf(self, x: Numeric) -> Numeric:
+256        return gdtr(1 / self.scale, self.shape, np.maximum(0, x))
+257
+258    def survival(self, x: Numeric) -> Numeric:
+259        return gdtrc(1 / self.scale, self.shape, np.maximum(0, x))
+260
+261    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+262        return rng.gamma(shape=self.shape, scale=self.scale, size=size)
+263
+264    @cached_property
+265    def mean(self) -> Numeric:
+266        return self.shape * self.scale
+267
+268    @cached_property
+269    def var(self) -> Numeric:
+270        return self.shape * np.square(self.scale)
+271
+272    @cached_property
+273    def mode(self) -> Numeric:
+274        return np.where(self.shape > 1, self.scale * (self.shape - 1), 0.0)
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + Gamma( shape: float | numpy.ndarray, scale: float | numpy.ndarray, check: bool = True) + + + +
+ + 
224    def __init__(self, shape: Numeric, scale: Numeric, check: bool = True):
+225        if check and np.any(shape < 0):
+226            raise NegativeParameterError(
+227                "In Gamma(shape, scale), `shape` must be strictly positive!"
+228            )
+229        if check and np.any(scale < 0):
+230            raise NegativeParameterError(
+231                "In Gamma(shape, scale), `scale` must be strictly positive!"
+232            )
+233
+234        self.shape = shape
+235        self.scale = scale
+
+ + + + +
+
+ +
+
@classmethod
+ + def + from_mean_std(cls, mean, std, check: bool = True): + + + +
+ + 
210    @classmethod
+211    def from_mean_std(cls, mean, std, check: bool = True):
+212        if check and np.any(mean < 0):
+213            raise NegativeParameterError(
+214                "In Gamma.from_mean_std(mean, std), `mean` must be strictly positive!"
+215            )
+216        if check and np.any(std < 0):
+217            raise NegativeParameterError(
+218                "In Gamma.from_mean_std(mean, std), `std` must be strictly positive!"
+219            )
+220
+221        var = std**2
+222        return cls(shape=mean**2 / var, scale=var / mean)
+
+ + + + +
+
+
+ shape + + +
+ + + + +
+
+
+ scale + + +
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
237    @cached_property
+238    def batch_shape(self) -> Shape:
+239        return np.broadcast(self.shape, self.scale).shape
+
+ + + + +
+
+ +
+ + def + logcdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
251    def logcdf(self, x: Numeric) -> Numeric:
+252        with np.errstate(divide="ignore"):
+253            return np.log(self.cdf(x))
+
+ + + + +
+
+ +
+ + def + cdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
255    def cdf(self, x: Numeric) -> Numeric:
+256        return gdtr(1 / self.scale, self.shape, np.maximum(0, x))
+
+ + + + +
+
+ +
+ + def + survival(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
258    def survival(self, x: Numeric) -> Numeric:
+259        return gdtrc(1 / self.scale, self.shape, np.maximum(0, x))
+
+ + + + +
+
+ +
+ mean: float | numpy.ndarray + + + +
+ + 
264    @cached_property
+265    def mean(self) -> Numeric:
+266        return self.shape * self.scale
+
+ + + + +
+
+ +
+ var: float | numpy.ndarray + + + +
+ + 
268    @cached_property
+269    def var(self) -> Numeric:
+270        return self.shape * np.square(self.scale)
+
+ + + + +
+
+ +
+ mode: float | numpy.ndarray + + + +
+ + 
272    @cached_property
+273    def mode(self) -> Numeric:
+274        return np.where(self.shape > 1, self.scale * (self.shape - 1), 0.0)
+
+ + + + +
+
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + InverseGamma(arianna.distributions.abstract.Positive): + + + +
+ + 
278class InverseGamma(Positive):
+279    @classmethod
+280    def from_mean_std(cls, mean, std, check: bool = True):
+281        if check and np.any(mean < 0):
+282            raise NegativeParameterError(
+283                "In InverseGamma.from_mean_std(mean, mean), `mean` must be strictly positive!"
+284            )
+285        if check and np.any(std < 0):
+286            raise NegativeParameterError(
+287                "In InverseGamma.from_mean_std(mean, mean), `std` must be strictly positive!"
+288            )
+289
+290        shape = (mean / std) ** 2 + 2
+291        scale = mean * (shape - 1)
+292        return cls(shape, scale)
+293
+294    def __init__(self, shape: Numeric, scale: Numeric, check: bool = True):
+295        if check and np.any(shape < 0):
+296            raise NegativeParameterError(
+297                "In InverseGamma(shape, scale), `shape` must be strictly positive!"
+298            )
+299        if check and np.any(scale < 0):
+300            raise NegativeParameterError(
+301                "In InverseGamma(shape, scale), `scale` must be strictly positive!"
+302            )
+303
+304        self.shape = shape
+305        self.scale = scale
+306
+307    @cached_property
+308    def batch_shape(self) -> Shape:
+309        return np.broadcast(self.shape, self.scale).shape
+310
+311    @cached_property
+312    def mean(self) -> Numeric:
+313        return np.where(self.shape > 1, self.scale / (self.shape - 1), np.nan)
+314
+315    @cached_property
+316    def var(self) -> Numeric:
+317        return np.where(self.shape > 2, self.mean**2 / (self.shape - 2), np.nan)
+318
+319    @cached_property
+320    def mode(self) -> Numeric:
+321        return self.scale / (self.shape + 1)
+322
+323    def _logpdf(self, x: Numeric) -> Numeric:
+324        # Hide warnings if 0 * inf, which is nan. Should just return -inf.
+325        with np.errstate(invalid="ignore", divide="ignore"):
+326            return (
+327                self.shape * np.log(self.scale)
+328                - gammaln(self.shape)
+329                - (self.shape + 1) * np.log(x)
+330                - self.scale / x
+331            )
+332
+333    def logcdf(self, x: Numeric) -> Numeric:
+334        with np.errstate(divide="ignore"):
+335            return np.log(self.cdf(x))
+336
+337    def cdf(self, x: Numeric) -> Numeric:
+338        with np.errstate(divide="ignore"):
+339            x = np.maximum(0, x)
+340            return gdtrc(self.scale, self.shape, 1 / x)
+341
+342    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+343        return 1 / rng.gamma(shape=self.shape, scale=1 / self.scale, size=size)
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + InverseGamma( shape: float | numpy.ndarray, scale: float | numpy.ndarray, check: bool = True) + + + +
+ + 
294    def __init__(self, shape: Numeric, scale: Numeric, check: bool = True):
+295        if check and np.any(shape < 0):
+296            raise NegativeParameterError(
+297                "In InverseGamma(shape, scale), `shape` must be strictly positive!"
+298            )
+299        if check and np.any(scale < 0):
+300            raise NegativeParameterError(
+301                "In InverseGamma(shape, scale), `scale` must be strictly positive!"
+302            )
+303
+304        self.shape = shape
+305        self.scale = scale
+
+ + + + +
+
+ +
+
@classmethod
+ + def + from_mean_std(cls, mean, std, check: bool = True): + + + +
+ + 
279    @classmethod
+280    def from_mean_std(cls, mean, std, check: bool = True):
+281        if check and np.any(mean < 0):
+282            raise NegativeParameterError(
+283                "In InverseGamma.from_mean_std(mean, mean), `mean` must be strictly positive!"
+284            )
+285        if check and np.any(std < 0):
+286            raise NegativeParameterError(
+287                "In InverseGamma.from_mean_std(mean, mean), `std` must be strictly positive!"
+288            )
+289
+290        shape = (mean / std) ** 2 + 2
+291        scale = mean * (shape - 1)
+292        return cls(shape, scale)
+
+ + + + +
+
+
+ shape + + +
+ + + + +
+
+
+ scale + + +
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
307    @cached_property
+308    def batch_shape(self) -> Shape:
+309        return np.broadcast(self.shape, self.scale).shape
+
+ + + + +
+
+ +
+ mean: float | numpy.ndarray + + + +
+ + 
311    @cached_property
+312    def mean(self) -> Numeric:
+313        return np.where(self.shape > 1, self.scale / (self.shape - 1), np.nan)
+
+ + + + +
+
+ +
+ var: float | numpy.ndarray + + + +
+ + 
315    @cached_property
+316    def var(self) -> Numeric:
+317        return np.where(self.shape > 2, self.mean**2 / (self.shape - 2), np.nan)
+
+ + + + +
+
+ +
+ mode: float | numpy.ndarray + + + +
+ + 
319    @cached_property
+320    def mode(self) -> Numeric:
+321        return self.scale / (self.shape + 1)
+
+ + + + +
+
+ +
+ + def + logcdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
333    def logcdf(self, x: Numeric) -> Numeric:
+334        with np.errstate(divide="ignore"):
+335            return np.log(self.cdf(x))
+
+ + + + +
+
+ +
+ + def + cdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
337    def cdf(self, x: Numeric) -> Numeric:
+338        with np.errstate(divide="ignore"):
+339            x = np.maximum(0, x)
+340            return gdtrc(self.scale, self.shape, 1 / x)
+
+ + + + +
+
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + LogNormal(arianna.distributions.abstract.Positive): + + + +
+ + 
346class LogNormal(Positive):
+347    @classmethod
+348    def from_mean_std(cls, mean, std, check: bool = True):
+349        if check and np.any(mean < 0):
+350            raise NegativeParameterError(
+351                "In LogNormal.from_mean_std(mean, std), `mean` must be strictly positive!"
+352            )
+353        if check and np.any(std < 0):
+354            raise NegativeParameterError(
+355                "In LogNormal.from_mean_std(mean, std), `std` must be strictly positive!"
+356            )
+357        var = std**2
+358        sigma_squared = np.log1p(var / mean**2)
+359        mu = np.log(mean) - sigma_squared / 2
+360        sigma = np.sqrt(sigma_squared)
+361        return cls(mu, sigma)
+362
+363    def __init__(self, mu: Numeric, sigma: Numeric, check: bool = True):
+364        if check and np.any(sigma < 0):
+365            raise NegativeParameterError(
+366                "In LogNormal(mu, sigma), `sigma` must be strictly positive!"
+367            )
+368
+369        self.mu = mu
+370        self.sigma = sigma
+371
+372    @cached_property
+373    def batch_shape(self) -> Shape:
+374        return np.broadcast(self.mu, self.sigma).shape
+375
+376    @cached_property
+377    def mean(self) -> Numeric:
+378        return np.exp(self.mu + self.sigma**2 / 2)
+379
+380    @cached_property
+381    def var(self) -> Numeric:
+382        return (np.exp(self.sigma**2) - 1) * np.exp(2 * self.mu + self.sigma**2)
+383
+384    @cached_property
+385    def mode(self) -> Numeric:
+386        return np.exp(self.mu - self.sigma**2)
+387
+388    @cached_property
+389    def median(self) -> Numeric:
+390        return np.exp(self.mu)
+391
+392    def _logpdf(self, x: Numeric) -> Numeric:
+393        # Hide warnings if 0 * inf, which is nan. Should just return -inf.
+394        with np.errstate(divide="ignore", invalid="ignore"):
+395            z = (np.log(x) - self.mu) / self.sigma
+396            return -np.log(x * self.sigma * np.sqrt(2 * np.pi)) - z**2 / 2
+397
+398    def logcdf(self, x: Numeric) -> Numeric:
+399        x = np.maximum(0, x)
+400        with np.errstate(divide="ignore"):
+401            z = (np.log(x) - self.mu) / self.sigma
+402            return log_ndtr(z)
+403
+404    def cdf(self, x: Numeric) -> Numeric:
+405        x = np.maximum(0, x)
+406        with np.errstate(divide="ignore"):
+407            z = (np.log(x) - self.mu) / self.sigma
+408            return ndtr(z)
+409
+410    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+411        return rng.lognormal(self.mu, self.sigma, size=size)
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + LogNormal( mu: float | numpy.ndarray, sigma: float | numpy.ndarray, check: bool = True) + + + +
+ + 
363    def __init__(self, mu: Numeric, sigma: Numeric, check: bool = True):
+364        if check and np.any(sigma < 0):
+365            raise NegativeParameterError(
+366                "In LogNormal(mu, sigma), `sigma` must be strictly positive!"
+367            )
+368
+369        self.mu = mu
+370        self.sigma = sigma
+
+ + + + +
+
+ +
+
@classmethod
+ + def + from_mean_std(cls, mean, std, check: bool = True): + + + +
+ + 
347    @classmethod
+348    def from_mean_std(cls, mean, std, check: bool = True):
+349        if check and np.any(mean < 0):
+350            raise NegativeParameterError(
+351                "In LogNormal.from_mean_std(mean, std), `mean` must be strictly positive!"
+352            )
+353        if check and np.any(std < 0):
+354            raise NegativeParameterError(
+355                "In LogNormal.from_mean_std(mean, std), `std` must be strictly positive!"
+356            )
+357        var = std**2
+358        sigma_squared = np.log1p(var / mean**2)
+359        mu = np.log(mean) - sigma_squared / 2
+360        sigma = np.sqrt(sigma_squared)
+361        return cls(mu, sigma)
+
+ + + + +
+
+
+ mu + + +
+ + + + +
+
+
+ sigma + + +
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
372    @cached_property
+373    def batch_shape(self) -> Shape:
+374        return np.broadcast(self.mu, self.sigma).shape
+
+ + + + +
+
+ +
+ mean: float | numpy.ndarray + + + +
+ + 
376    @cached_property
+377    def mean(self) -> Numeric:
+378        return np.exp(self.mu + self.sigma**2 / 2)
+
+ + + + +
+
+ +
+ var: float | numpy.ndarray + + + +
+ + 
380    @cached_property
+381    def var(self) -> Numeric:
+382        return (np.exp(self.sigma**2) - 1) * np.exp(2 * self.mu + self.sigma**2)
+
+ + + + +
+
+ +
+ mode: float | numpy.ndarray + + + +
+ + 
384    @cached_property
+385    def mode(self) -> Numeric:
+386        return np.exp(self.mu - self.sigma**2)
+
+ + + + +
+
+ +
+ median: float | numpy.ndarray + + + +
+ + 
388    @cached_property
+389    def median(self) -> Numeric:
+390        return np.exp(self.mu)
+
+ + + + +
+
+ +
+ + def + logcdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
398    def logcdf(self, x: Numeric) -> Numeric:
+399        x = np.maximum(0, x)
+400        with np.errstate(divide="ignore"):
+401            z = (np.log(x) - self.mu) / self.sigma
+402            return log_ndtr(z)
+
+ + + + +
+
+ +
+ + def + cdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
404    def cdf(self, x: Numeric) -> Numeric:
+405        x = np.maximum(0, x)
+406        with np.errstate(divide="ignore"):
+407            z = (np.log(x) - self.mu) / self.sigma
+408            return ndtr(z)
+
+ + + + +
+
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + Weibull(arianna.distributions.abstract.Positive): + + + +
+ + 
414class Weibull(Positive): ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + Gumbel(arianna.distributions.abstract.UnivariateReal): + + + +
+ + 
417class Gumbel(UnivariateReal): ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + Logistic(arianna.distributions.abstract.Positive): + + + +
+ + 
420class Logistic(Positive): ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + LogLogistic(arianna.distributions.abstract.UnivariateReal): + + + +
+ + 
423class LogLogistic(UnivariateReal): ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + Normal(arianna.distributions.abstract.UnivariateReal): + + + +
+ + 
426class Normal(UnivariateReal):
+427    def __init__(
+428        self, loc: Numeric = 0.0, scale: Numeric = 1.0, check: bool = True
+429    ):
+430        if check and np.any(scale < 0):
+431            raise NegativeParameterError(
+432                "In Normal(loc, scale), `scale` must be strictly positive!"
+433            )
+434        self.loc = loc
+435        self.scale = scale
+436
+437    @cached_property
+438    def batch_shape(self) -> Shape:
+439        return np.broadcast(self.loc, self.scale).shape
+440
+441    def logpdf(self, x: Numeric) -> Numeric:
+442        z = (x - self.loc) / self.scale
+443        return -np.square(z) / 2 - np.log(2 * np.pi) / 2 - np.log(self.scale)
+444
+445    def logcdf(self, x: Numeric) -> Numeric:
+446        return log_ndtr((x - self.mean) / self.scale)
+447
+448    def cdf(self, x: Numeric) -> Numeric:
+449        return ndtr((x - self.mean) / self.scale)
+450
+451    def survival(self, x: Numeric) -> Numeric:
+452        return 1 - self.cdf(x)
+453
+454    def _sample(self, size: Shape, rng: RNG) -> ndarray:
+455        return rng.normal(loc=self.loc, scale=self.scale, size=size)
+456
+457    @cached_property
+458    def mean(self) -> Numeric:
+459        return np.broadcast_to(self.loc, self.batch_shape)
+460
+461    @cached_property
+462    def std(self) -> Numeric:
+463        return np.broadcast_to(self.scale, self.batch_shape)
+464
+465    @cached_property
+466    def var(self) -> Numeric:
+467        return np.square(self.std)
+468
+469    @cached_property
+470    def mode(self) -> Numeric:
+471        return self.mean
+472
+473    @cached_property
+474    def median(self) -> Numeric:
+475        return self.mean
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + Normal( loc: float | numpy.ndarray = 0.0, scale: float | numpy.ndarray = 1.0, check: bool = True) + + + +
+ + 
427    def __init__(
+428        self, loc: Numeric = 0.0, scale: Numeric = 1.0, check: bool = True
+429    ):
+430        if check and np.any(scale < 0):
+431            raise NegativeParameterError(
+432                "In Normal(loc, scale), `scale` must be strictly positive!"
+433            )
+434        self.loc = loc
+435        self.scale = scale
+
+ + + + +
+
+
+ loc + + +
+ + + + +
+
+
+ scale + + +
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
437    @cached_property
+438    def batch_shape(self) -> Shape:
+439        return np.broadcast(self.loc, self.scale).shape
+
+ + + + +
+
+ +
+ + def + logpdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
441    def logpdf(self, x: Numeric) -> Numeric:
+442        z = (x - self.loc) / self.scale
+443        return -np.square(z) / 2 - np.log(2 * np.pi) / 2 - np.log(self.scale)
+
+ + + + +
+
+ +
+ + def + logcdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
445    def logcdf(self, x: Numeric) -> Numeric:
+446        return log_ndtr((x - self.mean) / self.scale)
+
+ + + + +
+
+ +
+ + def + cdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
448    def cdf(self, x: Numeric) -> Numeric:
+449        return ndtr((x - self.mean) / self.scale)
+
+ + + + +
+
+ +
+ + def + survival(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
451    def survival(self, x: Numeric) -> Numeric:
+452        return 1 - self.cdf(x)
+
+ + + + +
+
+ +
+ mean: float | numpy.ndarray + + + +
+ + 
457    @cached_property
+458    def mean(self) -> Numeric:
+459        return np.broadcast_to(self.loc, self.batch_shape)
+
+ + + + +
+
+ +
+ std: float | numpy.ndarray + + + +
+ + 
461    @cached_property
+462    def std(self) -> Numeric:
+463        return np.broadcast_to(self.scale, self.batch_shape)
+
+ + + + +
+
+ +
+ var: float | numpy.ndarray + + + +
+ + 
465    @cached_property
+466    def var(self) -> Numeric:
+467        return np.square(self.std)
+
+ + + + +
+
+ +
+ mode: float | numpy.ndarray + + + +
+ + 
469    @cached_property
+470    def mode(self) -> Numeric:
+471        return self.mean
+
+ + + + +
+
+ +
+ median: float | numpy.ndarray + + + +
+ + 
473    @cached_property
+474    def median(self) -> Numeric:
+475        return self.mean
+
+ + + + +
+
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + MvNormal(arianna.distributions.abstract.MultivariateReal): + + + +
+ + 
478class MvNormal(MultivariateReal):
+479    def __init__(
+480        self,
+481        mean: Optional[ndarray] = None,
+482        cov: Optional[ndarray] = None,
+483        **kwargs,
+484    ):
+485        match mean, cov:
+486            case (None, None):
+487                raise ValueError("mean and cov cannot both be None!")
+488            case (None, _):
+489                mean = np.zeros(cov.shape[-1])
+490            case (_, None):
+491                cov = np.eye(mean.shape[-1])
+492
+493        super().__init__(**kwargs)
+494
+495        self._mean = mean
+496        self._cov = cov
+497
+498    @cached_property
+499    def mean(self) -> ndarray:
+500        return np.broadcast_to(self._mean, self.batch_plus_event_shape)
+501
+502    @cached_property
+503    def _icov(self) -> ndarray:
+504        return np.linalg.inv(self._cov)
+505
+506    @cached_property
+507    def cov(self) -> ndarray:
+508        return np.broadcast_to(
+509            self._cov, self.batch_plus_event_shape + self.event_shape
+510        )
+511
+512    @cached_property
+513    def cov_inv(self) -> ndarray:
+514        return np.broadcast_to(
+515            self._icov, self.batch_plus_event_shape + self.event_shape
+516        )
+517
+518    @cached_property
+519    def L(self) -> ndarray:
+520        return np.linalg.cholesky(self.cov)
+521
+522    @cached_property
+523    def event_shape(self) -> Shape:
+524        return self.mean.shape[-1:]
+525
+526    @cached_property
+527    def batch_shape(self) -> Shape:
+528        return self.batch_plus_event_shape[:-1]
+529
+530    @cached_property
+531    def batch_plus_event_shape(self) -> Shape:
+532        return np.broadcast_shapes(self._mean.shape, self._cov.shape[:-1])
+533
+534    @cached_property
+535    def log_det_cov(self) -> float | ndarray:
+536        _, ldc = np.linalg.slogdet(self.cov)
+537        return ldc
+538
+539    @cached_property
+540    def var(self) -> ndarray:
+541        return np.diagonal(self.cov, axis1=-2, axis2=-1)
+542
+543    def logpdf(self, x):
+544        d = x - self.mean
+545
+546        # Compute quadratic form
+547        quad_form = np.einsum("...i, ...ij, ...j -> ...", d, self.cov_inv, d)  # type: ignore
+548
+549        return -0.5 * (
+550            self.event_shape[0] * np.log(2 * np.pi)
+551            + self.log_det_cov
+552            + quad_form
+553        )
+554
+555    def sample(
+556        self, sample_shape: Shape = (), rng: RNG = default_rng()
+557    ) -> ndarray:
+558        shape = sample_shape + self.batch_shape + self.event_shape
+559        standard_normals = rng.standard_normal(shape)
+560        b = np.einsum("...ij,...j->...i", self.L, standard_normals)
+561        samples = self.mean + b
+562        return samples
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + MvNormal( mean: Optional[numpy.ndarray] = None, cov: Optional[numpy.ndarray] = None, **kwargs) + + + +
+ + 
479    def __init__(
+480        self,
+481        mean: Optional[ndarray] = None,
+482        cov: Optional[ndarray] = None,
+483        **kwargs,
+484    ):
+485        match mean, cov:
+486            case (None, None):
+487                raise ValueError("mean and cov cannot both be None!")
+488            case (None, _):
+489                mean = np.zeros(cov.shape[-1])
+490            case (_, None):
+491                cov = np.eye(mean.shape[-1])
+492
+493        super().__init__(**kwargs)
+494
+495        self._mean = mean
+496        self._cov = cov
+
+ + + + +
+
+ +
+ mean: numpy.ndarray + + + +
+ + 
498    @cached_property
+499    def mean(self) -> ndarray:
+500        return np.broadcast_to(self._mean, self.batch_plus_event_shape)
+
+ + + + +
+
+ +
+ cov: numpy.ndarray + + + +
+ + 
506    @cached_property
+507    def cov(self) -> ndarray:
+508        return np.broadcast_to(
+509            self._cov, self.batch_plus_event_shape + self.event_shape
+510        )
+
+ + + + +
+
+ +
+ cov_inv: numpy.ndarray + + + +
+ + 
512    @cached_property
+513    def cov_inv(self) -> ndarray:
+514        return np.broadcast_to(
+515            self._icov, self.batch_plus_event_shape + self.event_shape
+516        )
+
+ + + + +
+
+ +
+ L: numpy.ndarray + + + +
+ + 
518    @cached_property
+519    def L(self) -> ndarray:
+520        return np.linalg.cholesky(self.cov)
+
+ + + + +
+
+ +
+ event_shape: tuple[int, ...] + + + +
+ + 
522    @cached_property
+523    def event_shape(self) -> Shape:
+524        return self.mean.shape[-1:]
+
+ + + + +
+
+ +
+ batch_shape: tuple[int, ...] + + + +
+ + 
526    @cached_property
+527    def batch_shape(self) -> Shape:
+528        return self.batch_plus_event_shape[:-1]
+
+ + + + +
+
+ +
+ batch_plus_event_shape: tuple[int, ...] + + + +
+ + 
530    @cached_property
+531    def batch_plus_event_shape(self) -> Shape:
+532        return np.broadcast_shapes(self._mean.shape, self._cov.shape[:-1])
+
+ + + + +
+
+ +
+ log_det_cov: float | numpy.ndarray + + + +
+ + 
534    @cached_property
+535    def log_det_cov(self) -> float | ndarray:
+536        _, ldc = np.linalg.slogdet(self.cov)
+537        return ldc
+
+ + + + +
+
+ +
+ var: numpy.ndarray + + + +
+ + 
539    @cached_property
+540    def var(self) -> ndarray:
+541        return np.diagonal(self.cov, axis1=-2, axis2=-1)
+
+ + + + +
+
+ +
+ + def + logpdf(self, x): + + + +
+ + 
543    def logpdf(self, x):
+544        d = x - self.mean
+545
+546        # Compute quadratic form
+547        quad_form = np.einsum("...i, ...ij, ...j -> ...", d, self.cov_inv, d)  # type: ignore
+548
+549        return -0.5 * (
+550            self.event_shape[0] * np.log(2 * np.pi)
+551            + self.log_det_cov
+552            + quad_form
+553        )
+
+ + + + +
+
+ +
+ + def + sample( self, sample_shape: tuple[int, ...] = (), rng: numpy.random._generator.Generator = Generator(PCG64) at 0x103F8FD80) -> numpy.ndarray: + + + +
+ + 
555    def sample(
+556        self, sample_shape: Shape = (), rng: RNG = default_rng()
+557    ) -> ndarray:
+558        shape = sample_shape + self.batch_shape + self.event_shape
+559        standard_normals = rng.standard_normal(shape)
+560        b = np.einsum("...ij,...j->...i", self.L, standard_normals)
+561        samples = self.mean + b
+562        return samples
+
+ + + + +
+
+
Inherited Members
+
+ + + + +
+
+
+
+ +
+ + class + Dirichlet(arianna.distributions.abstract.MultivariateContinuous): + + + +
+ + 
565class Dirichlet(MultivariateContinuous):
+566    def __init__(self, concentration: ndarray, check: bool = True):
+567        if check and np.any(concentration < 0):
+568            raise NegativeParameterError(
+569                "In Dirichlet(concentration), `concentration` must be stricly positive!"
+570            )
+571        self.concentration = concentration
+572
+573    @cached_property
+574    def concentration_sum(self):
+575        return self.concentration.sum(-1, keepdims=True)
+576
+577    @cached_property
+578    def event_shape(self):
+579        return self.concentration.shape[-1]
+580
+581    @cached_property
+582    def batch_plus_event_shape(self):
+583        return self.concentration.shape
+584
+585    @cached_property
+586    def batch_shape(self):
+587        return self.batch_plus_event_shape[:-1]
+588
+589    def logpdf(self, x: ndarray) -> float | ndarray:
+590        # TODO: Test.
+591        return (
+592            np.sum((self.concentration - 1) * np.log(x), -1)
+593            + gammaln(self.concentration.sum(-1))
+594            - gammaln(self.concentration).sum(-1)
+595        )
+596
+597    def sample(
+598        self, sample_shape: Shape = (), rng: RNG = default_rng()
+599    ) -> ndarray:
+600        shape = sample_shape + self.batch_plus_event_shape
+601        alpha = rng.standard_gamma(shape)
+602        return alpha / alpha.sum(-1, keepdims=True)
+603
+604    def to_real(self, x: ndarray) -> float | ndarray:
+605        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+606        raise NotImplementedError
+607
+608    def to_native(self, z: ndarray) -> float | ndarray:
+609        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+610        raise NotImplementedError
+611
+612    def logdetjac(self, z: ndarray) -> float | ndarray:
+613        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+614        raise NotImplementedError
+615
+616    @cached_property
+617    def cov(self) -> ndarray:
+618        raise NotImplementedError
+619
+620    @cached_property
+621    def mean(self) -> ndarray:
+622        return self.concentration / self.concentration_sum
+623
+624    @cached_property
+625    def var(self) -> ndarray:
+626        m = self.mean
+627        return m * (1 - m) / (1 + self.concentration_sum)
+628
+629    @cached_property
+630    def std(self) -> ndarray:
+631        return np.sqrt(self.var)
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + Dirichlet(concentration: numpy.ndarray, check: bool = True) + + + +
+ + 
566    def __init__(self, concentration: ndarray, check: bool = True):
+567        if check and np.any(concentration < 0):
+568            raise NegativeParameterError(
+569                "In Dirichlet(concentration), `concentration` must be stricly positive!"
+570            )
+571        self.concentration = concentration
+
+ + + + +
+
+
+ concentration + + +
+ + + + +
+
+ +
+ concentration_sum + + + +
+ + 
573    @cached_property
+574    def concentration_sum(self):
+575        return self.concentration.sum(-1, keepdims=True)
+
+ + + + +
+
+ +
+ event_shape + + + +
+ + 
577    @cached_property
+578    def event_shape(self):
+579        return self.concentration.shape[-1]
+
+ + + + +
+
+ +
+ batch_plus_event_shape + + + +
+ + 
581    @cached_property
+582    def batch_plus_event_shape(self):
+583        return self.concentration.shape
+
+ + + + +
+
+ +
+ batch_shape + + + +
+ + 
585    @cached_property
+586    def batch_shape(self):
+587        return self.batch_plus_event_shape[:-1]
+
+ + + + +
+
+ +
+ + def + logpdf(self, x: numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
589    def logpdf(self, x: ndarray) -> float | ndarray:
+590        # TODO: Test.
+591        return (
+592            np.sum((self.concentration - 1) * np.log(x), -1)
+593            + gammaln(self.concentration.sum(-1))
+594            - gammaln(self.concentration).sum(-1)
+595        )
+
+ + + + +
+
+ +
+ + def + sample( self, sample_shape: tuple[int, ...] = (), rng: numpy.random._generator.Generator = Generator(PCG64) at 0x10401C040) -> numpy.ndarray: + + + +
+ + 
597    def sample(
+598        self, sample_shape: Shape = (), rng: RNG = default_rng()
+599    ) -> ndarray:
+600        shape = sample_shape + self.batch_plus_event_shape
+601        alpha = rng.standard_gamma(shape)
+602        return alpha / alpha.sum(-1, keepdims=True)
+
+ + + + +
+
+ +
+ + def + to_real(self, x: numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
604    def to_real(self, x: ndarray) -> float | ndarray:
+605        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+606        raise NotImplementedError
+
+ + + + +
+
+ +
+ + def + to_native(self, z: numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
608    def to_native(self, z: ndarray) -> float | ndarray:
+609        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+610        raise NotImplementedError
+
+ + + + +
+
+ +
+ + def + logdetjac(self, z: numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
612    def logdetjac(self, z: ndarray) -> float | ndarray:
+613        # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html
+614        raise NotImplementedError
+
+ + + + +
+
+ +
+ cov: numpy.ndarray + + + +
+ + 
616    @cached_property
+617    def cov(self) -> ndarray:
+618        raise NotImplementedError
+
+ + + + +
+
+ +
+ mean: numpy.ndarray + + + +
+ + 
620    @cached_property
+621    def mean(self) -> ndarray:
+622        return self.concentration / self.concentration_sum
+
+ + + + +
+
+ +
+ var: numpy.ndarray + + + +
+ + 
624    @cached_property
+625    def var(self) -> ndarray:
+626        m = self.mean
+627        return m * (1 - m) / (1 + self.concentration_sum)
+
+ + + + +
+
+ +
+ std: numpy.ndarray + + + +
+ + 
629    @cached_property
+630    def std(self) -> ndarray:
+631        return np.sqrt(self.var)
+
+ + + + +
+
+
Inherited Members
+
+ + +
+
+
+
+ + \ No newline at end of file diff --git a/docs/arianna/ppl.html b/docs/arianna/ppl.html new file mode 100644 index 0000000..6fc233a --- /dev/null +++ b/docs/arianna/ppl.html @@ -0,0 +1,262 @@ + + + + + + + arianna.ppl API documentation + + + + + + + + + + + + +
+
+

+arianna.ppl

+ + + + + +
+
+ + \ No newline at end of file diff --git a/docs/arianna/ppl/context.html b/docs/arianna/ppl/context.html new file mode 100644 index 0000000..ace9881 --- /dev/null +++ b/docs/arianna/ppl/context.html @@ -0,0 +1,2750 @@ + + + + + + + arianna.ppl.context API documentation + + + + + + + + + + + + +
+
+

+arianna.ppl.context

+ + + + + + + 
  1from abc import ABC, abstractmethod
+  2from typing import Any, Optional, Protocol
+  3
+  4import numpy as np
+  5from numpy import ndarray
+  6from numpy.random import Generator as RNG
+  7from numpy.random import default_rng
+  8
+  9from arianna.types import NegativeInfinityError, Numeric, Shape, State
+ 10
+ 11
+ 12class BasicDistribution(Protocol):
+ 13    def logpdf(self, x: Numeric) -> Numeric: ...
+ 14    def sample(
+ 15        self, sample_shape: Shape = (), rng: RNG = default_rng()
+ 16    ) -> ndarray: ...
+ 17
+ 18
+ 19class TransformableDistribution(BasicDistribution):
+ 20    def logdetjac(self, z: Numeric) -> Numeric: ...
+ 21
+ 22    def logpdf_plus_logdetjac(self, z: Numeric) -> Numeric: ...
+ 23
+ 24    def to_real(self, x: Numeric) -> Numeric:
+ 25        return np.log(x)
+ 26
+ 27    def to_native(self, z: Numeric) -> Numeric:
+ 28        return np.exp(z)
+ 29
+ 30    def logpdf(self, x: Numeric) -> Numeric: ...
+ 31
+ 32
+ 33# NOTE: Ideally, the name of a child Context class should be what its `run`
+ 34# method returns.  For example, the LogprobAndTrace Context's `run` method
+ 35# returns the model log probability and trace. (Note that a trace is the state
+ 36# in the native space and also includes cached values.)
+ 37class Context(ABC):
+ 38    result: Any
+ 39    state: State
+ 40
+ 41    @classmethod
+ 42    @abstractmethod
+ 43    def run(cls): ...
+ 44
+ 45    @abstractmethod
+ 46    def rv(
+ 47        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+ 48    ) -> Numeric: ...
+ 49
+ 50    @abstractmethod
+ 51    def cached(self, name: str, value: Numeric) -> Numeric: ...
+ 52
+ 53    def __call__(self):
+ 54        return self.result
+ 55
+ 56
+ 57class LogprobAndPriorSample(Context):
+ 58    @classmethod
+ 59    def run(
+ 60        cls, model, rng: Optional[RNG] = None, **data
+ 61    ) -> tuple[float, State]:
+ 62        """Get (logprob, trace)."""
+ 63        ctx = cls(rng=rng)
+ 64        model(ctx, **data)
+ 65        return ctx.result
+ 66
+ 67    def __init__(self, rng: Optional[RNG] = None):
+ 68        self.result = [0.0, {}]
+ 69        self.rng = rng or default_rng()
+ 70
+ 71    def rv(
+ 72        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+ 73    ):
+ 74        if obs is None:
+ 75            value = dist.sample()
+ 76            self.result[1][name] = value
+ 77        else:
+ 78            value = obs
+ 79
+ 80        self.result[0] += np.sum(dist.logpdf(value))
+ 81
+ 82        return value
+ 83
+ 84    def cached(self, name: str, value: Numeric) -> Numeric:
+ 85        self.result[1][name] = value
+ 86        return value
+ 87
+ 88
+ 89class LogprobAndTrace(Context):
+ 90    @classmethod
+ 91    def run(cls, model, state: State, **data) -> tuple[float, State]:
+ 92        """TODO.
+ 93
+ 94        Returns (logprob, trace). A trace is the state in the native space and
+ 95        the cached values.
+ 96
+ 97        Parameters
+ 98        ----------
+ 99        model : Any
+100            _description_
+101
+102        state : State
+103            _description_
+104
+105        Returns
+106        -------
+107        tuple[float, State]
+108            _description_
+109        """
+110        ctx = cls(state)
+111
+112        try:
+113            # Accumulate logprob.
+114            model(ctx, **data)
+115        except NegativeInfinityError:
+116            # If -inf anywhere during the accumulation, just end early and
+117            # return -inf and an empty trace.
+118            return -np.inf, {}
+119
+120        return ctx.result
+121
+122    def __init__(self, state: State):
+123        self.state = state
+124        self.result = [0.0, {}]
+125
+126    def rv(
+127        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+128    ):
+129        if obs is None:
+130            value = self.state[name]
+131            self.result[1][name] = value
+132        else:
+133            value = obs
+134
+135        self.result[0] += np.sum(dist.logpdf(value))
+136        if self.result[0] == -np.inf:
+137            raise NegativeInfinityError("Negative infinity in Logprob.")
+138
+139        return value
+140
+141    def cached(self, name: str, value: Numeric) -> Numeric:
+142        self.result[1][name] = value
+143        return value
+144
+145
+146class Predictive(Context):
+147    @classmethod
+148    def run(
+149        cls,
+150        model,
+151        state: Optional[State] = None,
+152        rng: Optional[RNG] = None,
+153        return_cached: bool = True,
+154        **data,
+155    ) -> State:
+156        ctx = cls(state=state, rng=rng, return_cached=return_cached)
+157        model(ctx, **data)
+158        return ctx.result
+159
+160    def __init__(
+161        self,
+162        state: Optional[State] = None,
+163        rng: Optional[RNG] = None,
+164        return_cached: bool = True,
+165    ):
+166        self.state = state or {}
+167        self.rng = rng or default_rng()
+168        self.return_cached = return_cached
+169        self.result = {}
+170
+171    def rv(
+172        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+173    ) -> Numeric:
+174        match self.state.get(name), obs:
+175            case None, None:
+176                self.result[name] = dist.sample(rng=self.rng)
+177                return self.result[name]
+178            case _, None:
+179                self.result[name] = self.state[name]
+180                return self.result[name]
+181            case None, _:
+182                return obs
+183            case _:
+184                raise RuntimeError("state and obs cannot both be defined.")
+185
+186    def cached(self, name: str, value: Numeric) -> Numeric:
+187        """Handle cached values.
+188
+189        Returns the value `value` and additionally stores `value` in
+190        `self.result[name]` if the `return_cached` attribute is True.
+191
+192        Parameters
+193        ----------
+194        name : str
+195            Name of value to cache.
+196        value : Numeric
+197            Value of the thing to cache.
+198
+199        Returns
+200        -------
+201        Numeric
+202            `value`, which is the second argument in `cached`.
+203        """
+204        if self.return_cached:
+205            self.result[name] = value
+206        return value
+207
+208
+209class TransformedLogprobAndTrace(Context):
+210    """TODO.
+211
+212    Calculates the transformed log probability for a given state (on the real
+213    space) and also returns the state in the native space.
+214
+215    Returns
+216    -------
+217    tuple[float, State]
+218        (logprob_plus_logdetjac, native_state_with_cached_items)
+219    """
+220
+221    @classmethod
+222    def run(cls, model, state: State, **data) -> tuple[float, State]:
+223        ctx = cls(state)
+224
+225        try:
+226            model(ctx, **data)
+227        except NegativeInfinityError:
+228            # In case of -inf, just return -inf and an empty trace ({}) early.
+229            # The trace doesn't matter, just need to return something.
+230            return -np.inf, {}
+231
+232        return ctx.result
+233
+234    def __init__(self, state: State):
+235        self.state = state
+236        self.result = [0.0, {}]  # logprob, native_state
+237
+238    def rv(
+239        self,
+240        name: str,
+241        dist: TransformableDistribution,
+242        obs: Optional[Numeric] = None,
+243    ):
+244        if obs is None:
+245            real_value = self.state[name]
+246            self.result[0] += np.sum(dist.logpdf_plus_logdetjac(real_value))
+247            value = dist.to_native(real_value)
+248            self.result[1][name] = value
+249        else:
+250            value = obs
+251            self.result[0] += np.sum(dist.logpdf(value))
+252
+253        if self.result[0] == -np.inf:
+254            raise NegativeInfinityError(
+255                "Negative infinity in TransformedLogprob."
+256            )
+257
+258        return value
+259
+260    def cached(self, name: str, value: Numeric) -> Numeric:
+261        self.result[1][name] = value
+262        return value
+263
+264
+265class TransformedPredictive(Context):
+266    """Get transformed predictive state.
+267
+268    Get transformed predictive state (i.e. state predictive in the real
+269    space) via the `run` method.
+270
+271    Parameters
+272    ----------
+273    state: Optional[State]
+274        Contains values on the native space. If a model parameter's
+275        value is not provided, it will be sampled from it's prior.
+276        Defaults to None.
+277    rng: Optional[RNG]
+278        Random number generator. Defaults to None.
+279    return_cached: bool
+280        Whether or not to return cached values. Defaults to True.
+281
+282    Attributes
+283    ----------
+284    state: State
+285        Contains values on the native space. If None was provided in the
+286        constructor, it's value will be an empty dictionary.
+287    rng: RNG
+288        Random number generator. If None was provided in the
+289        constructor, this will be `default_rng()`.
+290    return_cached: bool
+291        Whether or not to return cached values.
+292    """
+293
+294    @classmethod
+295    def run(
+296        cls,
+297        model,
+298        state: Optional[State] = None,
+299        rng: Optional[RNG] = None,
+300        return_cached: bool = True,
+301        **data,
+302    ):
+303        ctx = cls(state=state, rng=rng, return_cached=return_cached)
+304        model(ctx, **data)
+305        return ctx.result
+306
+307    def __init__(
+308        self,
+309        state: Optional[State] = None,
+310        rng: Optional[RNG] = None,
+311        return_cached: bool = True,
+312    ):
+313        self.state = state or {}
+314        self.rng = rng or default_rng()
+315        self.return_cached = return_cached
+316        self.result = {}
+317
+318    def rv(
+319        self,
+320        name: str,
+321        dist: TransformableDistribution,
+322        obs: Optional[Numeric] = None,
+323    ) -> Numeric:
+324        match self.state.get(name), obs:
+325            case None, None:
+326                # Sample from prior.
+327                native_value = dist.sample(rng=self.rng)
+328                self.result[name] = dist.to_real(native_value)
+329                return native_value
+330            case _, None:
+331                # provided state is in native space, so needs to be converted
+332                # to real space.
+333                self.result[name] = dist.to_real(self.state[name])
+334                return self.result[name]
+335            case None, _:
+336                # Observed values need no transformation.
+337                return obs
+338            case _:
+339                raise RuntimeError("state and obs cannot both be defined.")
+340
+341    def cached(self, name: str, value: Numeric) -> Numeric:
+342        """Handle cached values.
+343
+344        Returns the value `value` and additionally stores `value` in
+345        `self.result[name]` if the `return_cached` attribute is True.
+346
+347        Parameters
+348        ----------
+349        name : str
+350            Name of value to cache.
+351        value : Numeric
+352            Value of the thing to cache.
+353
+354        Returns
+355        -------
+356        Numeric
+357            `value`, which is the second argument in `cached`.
+358        """
+359        if self.return_cached:
+360            self.result[name] = value
+361        return value
+362
+363
+364class LogprobAndLogjacobianAndTrace(Context):
+365    @classmethod
+366    def run(cls, model, state: State, **data) -> tuple[float, float, State]:
+367        ctx = cls(state)
+368
+369        try:
+370            model(ctx, **data)
+371        except NegativeInfinityError:
+372            # In case of -inf, just return -inf and an empty trace ({}) early.
+373            # The trace doesn't matter, just need to return something.
+374            return -np.inf, -np.inf, {}
+375
+376        return ctx.result
+377
+378    def __init__(self, state: State):
+379        self.state = state
+380        self.result = [0.0, 0.0, {}]  # logprob, logdetjac, native_state
+381
+382    def rv(
+383        self,
+384        name: str,
+385        dist: TransformableDistribution,
+386        obs: Optional[Numeric] = None,
+387    ):
+388        if obs is None:
+389            real_value = self.state[name]
+390            value = dist.to_native(real_value)
+391            self.result[0] += np.sum(dist.logpdf(value))
+392            self.result[1] += np.sum(dist.logdetjac(real_value))
+393            self.result[2][name] = value
+394        else:
+395            value = obs
+396            self.result[0] += np.sum(dist.logpdf(value))
+397
+398        if self.result[0] == -np.inf:
+399            raise NegativeInfinityError(
+400                "Negative infinity in LogprobAndLogjacobianAndTrace."
+401            )
+402
+403        if self.result[1] == -np.inf:
+404            raise NegativeInfinityError(
+405                "Negative infinity in LogprobAndLogjacobianAndTrace."
+406            )
+407
+408        return value
+409
+410    def cached(self, name: str, value: Numeric) -> Numeric:
+411        self.result[2][name] = value
+412        return value
+
+ + +
+
+ +
+ + class + BasicDistribution(typing.Protocol): + + + +
+ + 
13class BasicDistribution(Protocol):
+14    def logpdf(self, x: Numeric) -> Numeric: ...
+15    def sample(
+16        self, sample_shape: Shape = (), rng: RNG = default_rng()
+17    ) -> ndarray: ...
+
+ + +

Base class for protocol classes.

+ +

Protocol classes are defined as::

+ +
class Proto(Protocol):
+    def meth(self) -> int:
+        ...
+
+ +

Such classes are primarily used with static type checkers that recognize +structural subtyping (static duck-typing), for example::

+ +
class C:
+    def meth(self) -> int:
+        return 0
+
+def func(x: Proto) -> int:
+    return x.meth()
+
+func(C())  # Passes static type check
+
+ +

See PEP 544 for details. Protocol classes decorated with +@typing.runtime_checkable act as simple-minded runtime protocols that check +only the presence of given attributes, ignoring their type signatures. +Protocol classes can be generic, they are defined as::

+ +
class GenProto(Protocol[T]):
+    def meth(self) -> T:
+        ...
+
+
+ + +
+ +
+ + BasicDistribution(*args, **kwargs) + + + +
+ + 
1431def _no_init_or_replace_init(self, *args, **kwargs):
+1432    cls = type(self)
+1433
+1434    if cls._is_protocol:
+1435        raise TypeError('Protocols cannot be instantiated')
+1436
+1437    # Already using a custom `__init__`. No need to calculate correct
+1438    # `__init__` to call. This can lead to RecursionError. See bpo-45121.
+1439    if cls.__init__ is not _no_init_or_replace_init:
+1440        return
+1441
+1442    # Initially, `__init__` of a protocol subclass is set to `_no_init_or_replace_init`.
+1443    # The first instantiation of the subclass will call `_no_init_or_replace_init` which
+1444    # searches for a proper new `__init__` in the MRO. The new `__init__`
+1445    # replaces the subclass' old `__init__` (ie `_no_init_or_replace_init`). Subsequent
+1446    # instantiation of the protocol subclass will thus use the new
+1447    # `__init__` and no longer call `_no_init_or_replace_init`.
+1448    for base in cls.__mro__:
+1449        init = base.__dict__.get('__init__', _no_init_or_replace_init)
+1450        if init is not _no_init_or_replace_init:
+1451            cls.__init__ = init
+1452            break
+1453    else:
+1454        # should not happen
+1455        cls.__init__ = object.__init__
+1456
+1457    cls.__init__(self, *args, **kwargs)
+
+ + + + +
+
+ +
+ + def + logpdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
14    def logpdf(self, x: Numeric) -> Numeric: ...
+
+ + + + +
+
+ +
+ + def + sample( self, sample_shape: tuple[int, ...] = (), rng: numpy.random._generator.Generator = Generator(PCG64) at 0x10401C3C0) -> numpy.ndarray: + + + +
+ + 
15    def sample(
+16        self, sample_shape: Shape = (), rng: RNG = default_rng()
+17    ) -> ndarray: ...
+
+ + + + +
+
+
+ +
+ + class + TransformableDistribution(BasicDistribution): + + + +
+ + 
20class TransformableDistribution(BasicDistribution):
+21    def logdetjac(self, z: Numeric) -> Numeric: ...
+22
+23    def logpdf_plus_logdetjac(self, z: Numeric) -> Numeric: ...
+24
+25    def to_real(self, x: Numeric) -> Numeric:
+26        return np.log(x)
+27
+28    def to_native(self, z: Numeric) -> Numeric:
+29        return np.exp(z)
+30
+31    def logpdf(self, x: Numeric) -> Numeric: ...
+
+ + +

Base class for protocol classes.

+ +

Protocol classes are defined as::

+ +
class Proto(Protocol):
+    def meth(self) -> int:
+        ...
+
+ +

Such classes are primarily used with static type checkers that recognize +structural subtyping (static duck-typing), for example::

+ +
class C:
+    def meth(self) -> int:
+        return 0
+
+def func(x: Proto) -> int:
+    return x.meth()
+
+func(C())  # Passes static type check
+
+ +

See PEP 544 for details. Protocol classes decorated with +@typing.runtime_checkable act as simple-minded runtime protocols that check +only the presence of given attributes, ignoring their type signatures. +Protocol classes can be generic, they are defined as::

+ +
class GenProto(Protocol[T]):
+    def meth(self) -> T:
+        ...
+
+
+ + +
+ +
+ + def + logdetjac(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
21    def logdetjac(self, z: Numeric) -> Numeric: ...
+
+ + + + +
+
+ +
+ + def + logpdf_plus_logdetjac(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
23    def logpdf_plus_logdetjac(self, z: Numeric) -> Numeric: ...
+
+ + + + +
+
+ +
+ + def + to_real(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
25    def to_real(self, x: Numeric) -> Numeric:
+26        return np.log(x)
+
+ + + + +
+
+ +
+ + def + to_native(self, z: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
28    def to_native(self, z: Numeric) -> Numeric:
+29        return np.exp(z)
+
+ + + + +
+
+ +
+ + def + logpdf(self, x: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
31    def logpdf(self, x: Numeric) -> Numeric: ...
+
+ + + + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + Context(abc.ABC): + + + +
+ + 
38class Context(ABC):
+39    result: Any
+40    state: State
+41
+42    @classmethod
+43    @abstractmethod
+44    def run(cls): ...
+45
+46    @abstractmethod
+47    def rv(
+48        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+49    ) -> Numeric: ...
+50
+51    @abstractmethod
+52    def cached(self, name: str, value: Numeric) -> Numeric: ...
+53
+54    def __call__(self):
+55        return self.result
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
+ result: Any + + +
+ + + + +
+
+
+ state: dict[str, float | numpy.ndarray] + + +
+ + + + +
+
+ +
+
@classmethod
+
@abstractmethod
+ + def + run(cls): + + + +
+ + 
42    @classmethod
+43    @abstractmethod
+44    def run(cls): ...
+
+ + + + +
+
+ +
+
@abstractmethod
+ + def + rv( self, name: str, dist: BasicDistribution, obs: Union[float, numpy.ndarray, NoneType] = None) -> float | numpy.ndarray: + + + +
+ + 
46    @abstractmethod
+47    def rv(
+48        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+49    ) -> Numeric: ...
+
+ + + + +
+
+ +
+
@abstractmethod
+ + def + cached(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
51    @abstractmethod
+52    def cached(self, name: str, value: Numeric) -> Numeric: ...
+
+ + + + +
+
+
+ +
+ + class + LogprobAndPriorSample(Context): + + + +
+ + 
58class LogprobAndPriorSample(Context):
+59    @classmethod
+60    def run(
+61        cls, model, rng: Optional[RNG] = None, **data
+62    ) -> tuple[float, State]:
+63        """Get (logprob, trace)."""
+64        ctx = cls(rng=rng)
+65        model(ctx, **data)
+66        return ctx.result
+67
+68    def __init__(self, rng: Optional[RNG] = None):
+69        self.result = [0.0, {}]
+70        self.rng = rng or default_rng()
+71
+72    def rv(
+73        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+74    ):
+75        if obs is None:
+76            value = dist.sample()
+77            self.result[1][name] = value
+78        else:
+79            value = obs
+80
+81        self.result[0] += np.sum(dist.logpdf(value))
+82
+83        return value
+84
+85    def cached(self, name: str, value: Numeric) -> Numeric:
+86        self.result[1][name] = value
+87        return value
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + LogprobAndPriorSample(rng: Optional[numpy.random._generator.Generator] = None) + + + +
+ + 
68    def __init__(self, rng: Optional[RNG] = None):
+69        self.result = [0.0, {}]
+70        self.rng = rng or default_rng()
+
+ + + + +
+
+ +
+
@classmethod
+ + def + run( cls, model, rng: Optional[numpy.random._generator.Generator] = None, **data) -> tuple[float, dict[str, float | numpy.ndarray]]: + + + +
+ + 
59    @classmethod
+60    def run(
+61        cls, model, rng: Optional[RNG] = None, **data
+62    ) -> tuple[float, State]:
+63        """Get (logprob, trace)."""
+64        ctx = cls(rng=rng)
+65        model(ctx, **data)
+66        return ctx.result
+
+ + +

Get (logprob, trace).

+
+ + +
+
+
+ result + + +
+ + + + +
+
+
+ rng + + +
+ + + + +
+
+ +
+ + def + rv( self, name: str, dist: BasicDistribution, obs: Union[float, numpy.ndarray, NoneType] = None): + + + +
+ + 
72    def rv(
+73        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+74    ):
+75        if obs is None:
+76            value = dist.sample()
+77            self.result[1][name] = value
+78        else:
+79            value = obs
+80
+81        self.result[0] += np.sum(dist.logpdf(value))
+82
+83        return value
+
+ + + + +
+
+ +
+ + def + cached(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
85    def cached(self, name: str, value: Numeric) -> Numeric:
+86        self.result[1][name] = value
+87        return value
+
+ + + + +
+
+
Inherited Members
+
+
Context
+
state
+ +
+
+
+
+
+ +
+ + class + LogprobAndTrace(Context): + + + +
+ + 
 90class LogprobAndTrace(Context):
+ 91    @classmethod
+ 92    def run(cls, model, state: State, **data) -> tuple[float, State]:
+ 93        """TODO.
+ 94
+ 95        Returns (logprob, trace). A trace is the state in the native space and
+ 96        the cached values.
+ 97
+ 98        Parameters
+ 99        ----------
+100        model : Any
+101            _description_
+102
+103        state : State
+104            _description_
+105
+106        Returns
+107        -------
+108        tuple[float, State]
+109            _description_
+110        """
+111        ctx = cls(state)
+112
+113        try:
+114            # Accumulate logprob.
+115            model(ctx, **data)
+116        except NegativeInfinityError:
+117            # If -inf anywhere during the accumulation, just end early and
+118            # return -inf and an empty trace.
+119            return -np.inf, {}
+120
+121        return ctx.result
+122
+123    def __init__(self, state: State):
+124        self.state = state
+125        self.result = [0.0, {}]
+126
+127    def rv(
+128        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+129    ):
+130        if obs is None:
+131            value = self.state[name]
+132            self.result[1][name] = value
+133        else:
+134            value = obs
+135
+136        self.result[0] += np.sum(dist.logpdf(value))
+137        if self.result[0] == -np.inf:
+138            raise NegativeInfinityError("Negative infinity in Logprob.")
+139
+140        return value
+141
+142    def cached(self, name: str, value: Numeric) -> Numeric:
+143        self.result[1][name] = value
+144        return value
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + LogprobAndTrace(state: dict[str, float | numpy.ndarray]) + + + +
+ + 
123    def __init__(self, state: State):
+124        self.state = state
+125        self.result = [0.0, {}]
+
+ + + + +
+
+ +
+
@classmethod
+ + def + run( cls, model, state: dict[str, float | numpy.ndarray], **data) -> tuple[float, dict[str, float | numpy.ndarray]]: + + + +
+ + 
 91    @classmethod
+ 92    def run(cls, model, state: State, **data) -> tuple[float, State]:
+ 93        """TODO.
+ 94
+ 95        Returns (logprob, trace). A trace is the state in the native space and
+ 96        the cached values.
+ 97
+ 98        Parameters
+ 99        ----------
+100        model : Any
+101            _description_
+102
+103        state : State
+104            _description_
+105
+106        Returns
+107        -------
+108        tuple[float, State]
+109            _description_
+110        """
+111        ctx = cls(state)
+112
+113        try:
+114            # Accumulate logprob.
+115            model(ctx, **data)
+116        except NegativeInfinityError:
+117            # If -inf anywhere during the accumulation, just end early and
+118            # return -inf and an empty trace.
+119            return -np.inf, {}
+120
+121        return ctx.result
+
+ + +

TODO.

+ +

Returns (logprob, trace). A trace is the state in the native space and +the cached values.

+ +
Parameters
+ +
    +
  • model (Any): +_description_
    • +
  • state (State): +_description_
    • +
+ +
Returns
+ +
    +
  • tuple[float, State]: _description_
    • +
+
+ + +
+
+
+ state + + +
+ + + + +
+
+
+ result + + +
+ + + + +
+
+ +
+ + def + rv( self, name: str, dist: BasicDistribution, obs: Union[float, numpy.ndarray, NoneType] = None): + + + +
+ + 
127    def rv(
+128        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+129    ):
+130        if obs is None:
+131            value = self.state[name]
+132            self.result[1][name] = value
+133        else:
+134            value = obs
+135
+136        self.result[0] += np.sum(dist.logpdf(value))
+137        if self.result[0] == -np.inf:
+138            raise NegativeInfinityError("Negative infinity in Logprob.")
+139
+140        return value
+
+ + + + +
+
+ +
+ + def + cached(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
142    def cached(self, name: str, value: Numeric) -> Numeric:
+143        self.result[1][name] = value
+144        return value
+
+ + + + +
+
+
+ +
+ + class + Predictive(Context): + + + +
+ + 
147class Predictive(Context):
+148    @classmethod
+149    def run(
+150        cls,
+151        model,
+152        state: Optional[State] = None,
+153        rng: Optional[RNG] = None,
+154        return_cached: bool = True,
+155        **data,
+156    ) -> State:
+157        ctx = cls(state=state, rng=rng, return_cached=return_cached)
+158        model(ctx, **data)
+159        return ctx.result
+160
+161    def __init__(
+162        self,
+163        state: Optional[State] = None,
+164        rng: Optional[RNG] = None,
+165        return_cached: bool = True,
+166    ):
+167        self.state = state or {}
+168        self.rng = rng or default_rng()
+169        self.return_cached = return_cached
+170        self.result = {}
+171
+172    def rv(
+173        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+174    ) -> Numeric:
+175        match self.state.get(name), obs:
+176            case None, None:
+177                self.result[name] = dist.sample(rng=self.rng)
+178                return self.result[name]
+179            case _, None:
+180                self.result[name] = self.state[name]
+181                return self.result[name]
+182            case None, _:
+183                return obs
+184            case _:
+185                raise RuntimeError("state and obs cannot both be defined.")
+186
+187    def cached(self, name: str, value: Numeric) -> Numeric:
+188        """Handle cached values.
+189
+190        Returns the value `value` and additionally stores `value` in
+191        `self.result[name]` if the `return_cached` attribute is True.
+192
+193        Parameters
+194        ----------
+195        name : str
+196            Name of value to cache.
+197        value : Numeric
+198            Value of the thing to cache.
+199
+200        Returns
+201        -------
+202        Numeric
+203            `value`, which is the second argument in `cached`.
+204        """
+205        if self.return_cached:
+206            self.result[name] = value
+207        return value
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + Predictive( state: Optional[dict[str, float | numpy.ndarray]] = None, rng: Optional[numpy.random._generator.Generator] = None, return_cached: bool = True) + + + +
+ + 
161    def __init__(
+162        self,
+163        state: Optional[State] = None,
+164        rng: Optional[RNG] = None,
+165        return_cached: bool = True,
+166    ):
+167        self.state = state or {}
+168        self.rng = rng or default_rng()
+169        self.return_cached = return_cached
+170        self.result = {}
+
+ + + + +
+
+ +
+
@classmethod
+ + def + run( cls, model, state: Optional[dict[str, float | numpy.ndarray]] = None, rng: Optional[numpy.random._generator.Generator] = None, return_cached: bool = True, **data) -> dict[str, float | numpy.ndarray]: + + + +
+ + 
148    @classmethod
+149    def run(
+150        cls,
+151        model,
+152        state: Optional[State] = None,
+153        rng: Optional[RNG] = None,
+154        return_cached: bool = True,
+155        **data,
+156    ) -> State:
+157        ctx = cls(state=state, rng=rng, return_cached=return_cached)
+158        model(ctx, **data)
+159        return ctx.result
+
+ + + + +
+
+
+ state + + +
+ + + + +
+
+
+ rng + + +
+ + + + +
+
+
+ return_cached + + +
+ + + + +
+
+
+ result + + +
+ + + + +
+
+ +
+ + def + rv( self, name: str, dist: BasicDistribution, obs: Union[float, numpy.ndarray, NoneType] = None) -> float | numpy.ndarray: + + + +
+ + 
172    def rv(
+173        self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None
+174    ) -> Numeric:
+175        match self.state.get(name), obs:
+176            case None, None:
+177                self.result[name] = dist.sample(rng=self.rng)
+178                return self.result[name]
+179            case _, None:
+180                self.result[name] = self.state[name]
+181                return self.result[name]
+182            case None, _:
+183                return obs
+184            case _:
+185                raise RuntimeError("state and obs cannot both be defined.")
+
+ + + + +
+
+ +
+ + def + cached(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
187    def cached(self, name: str, value: Numeric) -> Numeric:
+188        """Handle cached values.
+189
+190        Returns the value `value` and additionally stores `value` in
+191        `self.result[name]` if the `return_cached` attribute is True.
+192
+193        Parameters
+194        ----------
+195        name : str
+196            Name of value to cache.
+197        value : Numeric
+198            Value of the thing to cache.
+199
+200        Returns
+201        -------
+202        Numeric
+203            `value`, which is the second argument in `cached`.
+204        """
+205        if self.return_cached:
+206            self.result[name] = value
+207        return value
+
+ + +

Handle cached values.

+ +

Returns the value value and additionally stores value in +self.result[name] if the return_cached attribute is True.

+ +
Parameters
+ +
    +
  • name (str): +Name of value to cache.
    • +
  • value (Numeric): +Value of the thing to cache.
    • +
+ +
Returns
+ +
    +
  • Numeric: value, which is the second argument in cached.
    • +
+
+ + +
+
+
+ +
+ + class + TransformedLogprobAndTrace(Context): + + + +
+ + 
210class TransformedLogprobAndTrace(Context):
+211    """TODO.
+212
+213    Calculates the transformed log probability for a given state (on the real
+214    space) and also returns the state in the native space.
+215
+216    Returns
+217    -------
+218    tuple[float, State]
+219        (logprob_plus_logdetjac, native_state_with_cached_items)
+220    """
+221
+222    @classmethod
+223    def run(cls, model, state: State, **data) -> tuple[float, State]:
+224        ctx = cls(state)
+225
+226        try:
+227            model(ctx, **data)
+228        except NegativeInfinityError:
+229            # In case of -inf, just return -inf and an empty trace ({}) early.
+230            # The trace doesn't matter, just need to return something.
+231            return -np.inf, {}
+232
+233        return ctx.result
+234
+235    def __init__(self, state: State):
+236        self.state = state
+237        self.result = [0.0, {}]  # logprob, native_state
+238
+239    def rv(
+240        self,
+241        name: str,
+242        dist: TransformableDistribution,
+243        obs: Optional[Numeric] = None,
+244    ):
+245        if obs is None:
+246            real_value = self.state[name]
+247            self.result[0] += np.sum(dist.logpdf_plus_logdetjac(real_value))
+248            value = dist.to_native(real_value)
+249            self.result[1][name] = value
+250        else:
+251            value = obs
+252            self.result[0] += np.sum(dist.logpdf(value))
+253
+254        if self.result[0] == -np.inf:
+255            raise NegativeInfinityError(
+256                "Negative infinity in TransformedLogprob."
+257            )
+258
+259        return value
+260
+261    def cached(self, name: str, value: Numeric) -> Numeric:
+262        self.result[1][name] = value
+263        return value
+
+ + +

TODO.

+ +

Calculates the transformed log probability for a given state (on the real +space) and also returns the state in the native space.

+ +
Returns
+ +
    +
  • tuple[float, State]: (logprob_plus_logdetjac, native_state_with_cached_items)
    • +
+
+ + +
+ +
+ + TransformedLogprobAndTrace(state: dict[str, float | numpy.ndarray]) + + + +
+ + 
235    def __init__(self, state: State):
+236        self.state = state
+237        self.result = [0.0, {}]  # logprob, native_state
+
+ + + + +
+
+ +
+
@classmethod
+ + def + run( cls, model, state: dict[str, float | numpy.ndarray], **data) -> tuple[float, dict[str, float | numpy.ndarray]]: + + + +
+ + 
222    @classmethod
+223    def run(cls, model, state: State, **data) -> tuple[float, State]:
+224        ctx = cls(state)
+225
+226        try:
+227            model(ctx, **data)
+228        except NegativeInfinityError:
+229            # In case of -inf, just return -inf and an empty trace ({}) early.
+230            # The trace doesn't matter, just need to return something.
+231            return -np.inf, {}
+232
+233        return ctx.result
+
+ + + + +
+
+
+ state + + +
+ + + + +
+
+
+ result + + +
+ + + + +
+
+ +
+ + def + rv( self, name: str, dist: TransformableDistribution, obs: Union[float, numpy.ndarray, NoneType] = None): + + + +
+ + 
239    def rv(
+240        self,
+241        name: str,
+242        dist: TransformableDistribution,
+243        obs: Optional[Numeric] = None,
+244    ):
+245        if obs is None:
+246            real_value = self.state[name]
+247            self.result[0] += np.sum(dist.logpdf_plus_logdetjac(real_value))
+248            value = dist.to_native(real_value)
+249            self.result[1][name] = value
+250        else:
+251            value = obs
+252            self.result[0] += np.sum(dist.logpdf(value))
+253
+254        if self.result[0] == -np.inf:
+255            raise NegativeInfinityError(
+256                "Negative infinity in TransformedLogprob."
+257            )
+258
+259        return value
+
+ + + + +
+
+ +
+ + def + cached(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
261    def cached(self, name: str, value: Numeric) -> Numeric:
+262        self.result[1][name] = value
+263        return value
+
+ + + + +
+
+
+ +
+ + class + TransformedPredictive(Context): + + + +
+ + 
266class TransformedPredictive(Context):
+267    """Get transformed predictive state.
+268
+269    Get transformed predictive state (i.e. state predictive in the real
+270    space) via the `run` method.
+271
+272    Parameters
+273    ----------
+274    state: Optional[State]
+275        Contains values on the native space. If a model parameter's
+276        value is not provided, it will be sampled from it's prior.
+277        Defaults to None.
+278    rng: Optional[RNG]
+279        Random number generator. Defaults to None.
+280    return_cached: bool
+281        Whether or not to return cached values. Defaults to True.
+282
+283    Attributes
+284    ----------
+285    state: State
+286        Contains values on the native space. If None was provided in the
+287        constructor, it's value will be an empty dictionary.
+288    rng: RNG
+289        Random number generator. If None was provided in the
+290        constructor, this will be `default_rng()`.
+291    return_cached: bool
+292        Whether or not to return cached values.
+293    """
+294
+295    @classmethod
+296    def run(
+297        cls,
+298        model,
+299        state: Optional[State] = None,
+300        rng: Optional[RNG] = None,
+301        return_cached: bool = True,
+302        **data,
+303    ):
+304        ctx = cls(state=state, rng=rng, return_cached=return_cached)
+305        model(ctx, **data)
+306        return ctx.result
+307
+308    def __init__(
+309        self,
+310        state: Optional[State] = None,
+311        rng: Optional[RNG] = None,
+312        return_cached: bool = True,
+313    ):
+314        self.state = state or {}
+315        self.rng = rng or default_rng()
+316        self.return_cached = return_cached
+317        self.result = {}
+318
+319    def rv(
+320        self,
+321        name: str,
+322        dist: TransformableDistribution,
+323        obs: Optional[Numeric] = None,
+324    ) -> Numeric:
+325        match self.state.get(name), obs:
+326            case None, None:
+327                # Sample from prior.
+328                native_value = dist.sample(rng=self.rng)
+329                self.result[name] = dist.to_real(native_value)
+330                return native_value
+331            case _, None:
+332                # provided state is in native space, so needs to be converted
+333                # to real space.
+334                self.result[name] = dist.to_real(self.state[name])
+335                return self.result[name]
+336            case None, _:
+337                # Observed values need no transformation.
+338                return obs
+339            case _:
+340                raise RuntimeError("state and obs cannot both be defined.")
+341
+342    def cached(self, name: str, value: Numeric) -> Numeric:
+343        """Handle cached values.
+344
+345        Returns the value `value` and additionally stores `value` in
+346        `self.result[name]` if the `return_cached` attribute is True.
+347
+348        Parameters
+349        ----------
+350        name : str
+351            Name of value to cache.
+352        value : Numeric
+353            Value of the thing to cache.
+354
+355        Returns
+356        -------
+357        Numeric
+358            `value`, which is the second argument in `cached`.
+359        """
+360        if self.return_cached:
+361            self.result[name] = value
+362        return value
+
+ + +

Get transformed predictive state.

+ +

Get transformed predictive state (i.e. state predictive in the real +space) via the run method.

+ +
Parameters
+ +
    +
  • state (Optional[State]): +Contains values on the native space. If a model parameter's +value is not provided, it will be sampled from it's prior. +Defaults to None.
    • +
  • rng (Optional[RNG]): +Random number generator. Defaults to None.
    • +
  • return_cached (bool): +Whether or not to return cached values. Defaults to True.
    • +
+ +
Attributes
+ +
    +
  • state (State): +Contains values on the native space. If None was provided in the +constructor, it's value will be an empty dictionary.
    • +
  • rng (RNG): +Random number generator. If None was provided in the +constructor, this will be default_rng().
    • +
  • return_cached (bool): +Whether or not to return cached values.
    • +
+
+ + +
+ +
+ + TransformedPredictive( state: Optional[dict[str, float | numpy.ndarray]] = None, rng: Optional[numpy.random._generator.Generator] = None, return_cached: bool = True) + + + +
+ + 
308    def __init__(
+309        self,
+310        state: Optional[State] = None,
+311        rng: Optional[RNG] = None,
+312        return_cached: bool = True,
+313    ):
+314        self.state = state or {}
+315        self.rng = rng or default_rng()
+316        self.return_cached = return_cached
+317        self.result = {}
+
+ + + + +
+
+ +
+
@classmethod
+ + def + run( cls, model, state: Optional[dict[str, float | numpy.ndarray]] = None, rng: Optional[numpy.random._generator.Generator] = None, return_cached: bool = True, **data): + + + +
+ + 
295    @classmethod
+296    def run(
+297        cls,
+298        model,
+299        state: Optional[State] = None,
+300        rng: Optional[RNG] = None,
+301        return_cached: bool = True,
+302        **data,
+303    ):
+304        ctx = cls(state=state, rng=rng, return_cached=return_cached)
+305        model(ctx, **data)
+306        return ctx.result
+
+ + + + +
+
+
+ state + + +
+ + + + +
+
+
+ rng + + +
+ + + + +
+
+
+ return_cached + + +
+ + + + +
+
+
+ result + + +
+ + + + +
+
+ +
+ + def + rv( self, name: str, dist: TransformableDistribution, obs: Union[float, numpy.ndarray, NoneType] = None) -> float | numpy.ndarray: + + + +
+ + 
319    def rv(
+320        self,
+321        name: str,
+322        dist: TransformableDistribution,
+323        obs: Optional[Numeric] = None,
+324    ) -> Numeric:
+325        match self.state.get(name), obs:
+326            case None, None:
+327                # Sample from prior.
+328                native_value = dist.sample(rng=self.rng)
+329                self.result[name] = dist.to_real(native_value)
+330                return native_value
+331            case _, None:
+332                # provided state is in native space, so needs to be converted
+333                # to real space.
+334                self.result[name] = dist.to_real(self.state[name])
+335                return self.result[name]
+336            case None, _:
+337                # Observed values need no transformation.
+338                return obs
+339            case _:
+340                raise RuntimeError("state and obs cannot both be defined.")
+
+ + + + +
+
+ +
+ + def + cached(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
342    def cached(self, name: str, value: Numeric) -> Numeric:
+343        """Handle cached values.
+344
+345        Returns the value `value` and additionally stores `value` in
+346        `self.result[name]` if the `return_cached` attribute is True.
+347
+348        Parameters
+349        ----------
+350        name : str
+351            Name of value to cache.
+352        value : Numeric
+353            Value of the thing to cache.
+354
+355        Returns
+356        -------
+357        Numeric
+358            `value`, which is the second argument in `cached`.
+359        """
+360        if self.return_cached:
+361            self.result[name] = value
+362        return value
+
+ + +

Handle cached values.

+ +

Returns the value value and additionally stores value in +self.result[name] if the return_cached attribute is True.

+ +
Parameters
+ +
    +
  • name (str): +Name of value to cache.
    • +
  • value (Numeric): +Value of the thing to cache.
    • +
+ +
Returns
+ +
    +
  • Numeric: value, which is the second argument in cached.
    • +
+
+ + +
+
+
+ +
+ + class + LogprobAndLogjacobianAndTrace(Context): + + + +
+ + 
365class LogprobAndLogjacobianAndTrace(Context):
+366    @classmethod
+367    def run(cls, model, state: State, **data) -> tuple[float, float, State]:
+368        ctx = cls(state)
+369
+370        try:
+371            model(ctx, **data)
+372        except NegativeInfinityError:
+373            # In case of -inf, just return -inf and an empty trace ({}) early.
+374            # The trace doesn't matter, just need to return something.
+375            return -np.inf, -np.inf, {}
+376
+377        return ctx.result
+378
+379    def __init__(self, state: State):
+380        self.state = state
+381        self.result = [0.0, 0.0, {}]  # logprob, logdetjac, native_state
+382
+383    def rv(
+384        self,
+385        name: str,
+386        dist: TransformableDistribution,
+387        obs: Optional[Numeric] = None,
+388    ):
+389        if obs is None:
+390            real_value = self.state[name]
+391            value = dist.to_native(real_value)
+392            self.result[0] += np.sum(dist.logpdf(value))
+393            self.result[1] += np.sum(dist.logdetjac(real_value))
+394            self.result[2][name] = value
+395        else:
+396            value = obs
+397            self.result[0] += np.sum(dist.logpdf(value))
+398
+399        if self.result[0] == -np.inf:
+400            raise NegativeInfinityError(
+401                "Negative infinity in LogprobAndLogjacobianAndTrace."
+402            )
+403
+404        if self.result[1] == -np.inf:
+405            raise NegativeInfinityError(
+406                "Negative infinity in LogprobAndLogjacobianAndTrace."
+407            )
+408
+409        return value
+410
+411    def cached(self, name: str, value: Numeric) -> Numeric:
+412        self.result[2][name] = value
+413        return value
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+ + LogprobAndLogjacobianAndTrace(state: dict[str, float | numpy.ndarray]) + + + +
+ + 
379    def __init__(self, state: State):
+380        self.state = state
+381        self.result = [0.0, 0.0, {}]  # logprob, logdetjac, native_state
+
+ + + + +
+
+ +
+
@classmethod
+ + def + run( cls, model, state: dict[str, float | numpy.ndarray], **data) -> tuple[float, float, dict[str, float | numpy.ndarray]]: + + + +
+ + 
366    @classmethod
+367    def run(cls, model, state: State, **data) -> tuple[float, float, State]:
+368        ctx = cls(state)
+369
+370        try:
+371            model(ctx, **data)
+372        except NegativeInfinityError:
+373            # In case of -inf, just return -inf and an empty trace ({}) early.
+374            # The trace doesn't matter, just need to return something.
+375            return -np.inf, -np.inf, {}
+376
+377        return ctx.result
+
+ + + + +
+
+
+ state + + +
+ + + + +
+
+
+ result + + +
+ + + + +
+
+ +
+ + def + rv( self, name: str, dist: TransformableDistribution, obs: Union[float, numpy.ndarray, NoneType] = None): + + + +
+ + 
383    def rv(
+384        self,
+385        name: str,
+386        dist: TransformableDistribution,
+387        obs: Optional[Numeric] = None,
+388    ):
+389        if obs is None:
+390            real_value = self.state[name]
+391            value = dist.to_native(real_value)
+392            self.result[0] += np.sum(dist.logpdf(value))
+393            self.result[1] += np.sum(dist.logdetjac(real_value))
+394            self.result[2][name] = value
+395        else:
+396            value = obs
+397            self.result[0] += np.sum(dist.logpdf(value))
+398
+399        if self.result[0] == -np.inf:
+400            raise NegativeInfinityError(
+401                "Negative infinity in LogprobAndLogjacobianAndTrace."
+402            )
+403
+404        if self.result[1] == -np.inf:
+405            raise NegativeInfinityError(
+406                "Negative infinity in LogprobAndLogjacobianAndTrace."
+407            )
+408
+409        return value
+
+ + + + +
+
+ +
+ + def + cached(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray: + + + +
+ + 
411    def cached(self, name: str, value: Numeric) -> Numeric:
+412        self.result[2][name] = value
+413        return value
+
+ + + + +
+
+
+ + \ No newline at end of file diff --git a/docs/arianna/ppl/diagnostics.html b/docs/arianna/ppl/diagnostics.html new file mode 100644 index 0000000..e5a6e6f --- /dev/null +++ b/docs/arianna/ppl/diagnostics.html @@ -0,0 +1,323 @@ + + + + + + + arianna.ppl.diagnostics API documentation + + + + + + + + + + + + +
+
+

+arianna.ppl.diagnostics

+ + + + + + + 
 1import numpy as np
+ 2
+ 3
+ 4def ess_kish(w: np.ndarray, log: bool = True) -> float:
+ 5    """Kish Effective Sample Size.
+ 6
+ 7    Kish's effective sample size. Used for weighted samples. (e.g. importance
+ 8    sampling, sequential monte carlo, particle filters.)
+ 9
+10    https://en.wikipedia.org/wiki/Effective_sample_size
+11
+12    If log is True, then the w are log weights.
+13    """
+14    if log:
+15        return ess_kish(np.exp(w - np.max(w)), log=False)
+16    else:
+17        return sum(w) ** 2 / sum(w**2)
+
+ + +
+
+ +
+ + def + ess_kish(w: numpy.ndarray, log: bool = True) -> float: + + + +
+ + 
 5def ess_kish(w: np.ndarray, log: bool = True) -> float:
+ 6    """Kish Effective Sample Size.
+ 7
+ 8    Kish's effective sample size. Used for weighted samples. (e.g. importance
+ 9    sampling, sequential monte carlo, particle filters.)
+10
+11    https://en.wikipedia.org/wiki/Effective_sample_size
+12
+13    If log is True, then the w are log weights.
+14    """
+15    if log:
+16        return ess_kish(np.exp(w - np.max(w)), log=False)
+17    else:
+18        return sum(w) ** 2 / sum(w**2)
+
+ + +

Kish Effective Sample Size.

+ +

Kish's effective sample size. Used for weighted samples. (e.g. importance +sampling, sequential monte carlo, particle filters.)

+ +

https://en.wikipedia.org/wiki/Effective_sample_size

+ +

If log is True, then the w are log weights.

+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/arianna/ppl/inference.html b/docs/arianna/ppl/inference.html new file mode 100644 index 0000000..7695801 --- /dev/null +++ b/docs/arianna/ppl/inference.html @@ -0,0 +1,4440 @@ + + + + + + + arianna.ppl.inference API documentation + + + + + + + + + + + + +
+
+

+arianna.ppl.inference

+ + + + + + + 
  1from abc import ABC, abstractmethod
+  2from concurrent.futures import Executor
+  3from copy import deepcopy
+  4from functools import cached_property
+  5from typing import (
+  6    Any,
+  7    Callable,
+  8    Concatenate,
+  9    Generator,
+ 10    Iterable,
+ 11    Optional,
+ 12    ParamSpec,
+ 13)
+ 14
+ 15import numpy as np
+ 16from numpy import ndarray
+ 17from numpy.random import Generator as RNG
+ 18from numpy.random import default_rng
+ 19from scipy.optimize import minimize
+ 20from scipy.special import log_softmax, softmax
+ 21from tqdm import tqdm, trange
+ 22
+ 23from arianna.distributions import MvNormal
+ 24from arianna.ppl.context import (
+ 25    Context,
+ 26    LogprobAndLogjacobianAndTrace,
+ 27    LogprobAndPriorSample,
+ 28    LogprobAndTrace,
+ 29    Predictive,
+ 30    State,
+ 31    TransformedLogprobAndTrace,
+ 32    TransformedPredictive,
+ 33)
+ 34from arianna.ppl.shaper import Shaper
+ 35
+ 36P = ParamSpec("P")
+ 37Model = Callable[Concatenate[Context, P], None]
+ 38Logprob = Callable[[State], tuple[float, State]]
+ 39
+ 40
+ 41class Chain:
+ 42    """Chain MCMC samples.
+ 43
+ 44    Parameters
+ 45    ----------
+ 46    states : Iterable[State]
+ 47        MCMC states.
+ 48
+ 49    Attributes
+ 50    ----------
+ 51    chain : list[State]
+ 52        MCMC states in list format.
+ 53    """
+ 54
+ 55    def __init__(self, states: Iterable[State]):
+ 56        self.states = list(states)
+ 57        self.names = list(self.states[0].keys())
+ 58
+ 59    def __iter__(self):
+ 60        """Iterate over states.
+ 61
+ 62        Yields
+ 63        ------
+ 64        State
+ 65            MCMC state within chain.
+ 66        """
+ 67        for state in self.states:
+ 68            yield state
+ 69
+ 70    def __len__(self) -> int:
+ 71        """Return the number of states."""
+ 72        return len(self.states)
+ 73
+ 74    def get(self, name: str) -> ndarray:
+ 75        """Get all MCMC samples for one variable or cached value by name.
+ 76
+ 77        Parameters
+ 78        ----------
+ 79        name : str
+ 80            Name of model parameter or cached value.
+ 81
+ 82        Returns
+ 83        -------
+ 84        ndarray
+ 85            MCMC samples for the variable or cached value named.
+ 86        """
+ 87        return np.stack([c[name] for c in self.states])
+ 88
+ 89    @cached_property
+ 90    def bundle(self) -> dict[str, ndarray]:
+ 91        """Bundle MCMC values into a dictionary.
+ 92
+ 93        Returns
+ 94        -------
+ 95        dict[str, ndarray]
+ 96            Dictionary bundle of MCMC samples.
+ 97        """
+ 98        return {name: self.get(name) for name in self.names}
+ 99
+100    def subset(self, burn: int = 0, thin: int = 1):
+101        """Return subset of the states.
+102
+103        Parameters
+104        ----------
+105        burn : int, optional
+106            Number of initial samples to discard, by default 0.
+107        thin : int, optional
+108            Take only every `thin`-th sample, by default 1.
+109
+110        Returns
+111        -------
+112        Chain
+113            A whole new chain, with the first `burn` removed, and taking only
+114            every `thin`-th sample.
+115        """
+116        return Chain(self.states[burn::thin])
+117
+118
+119class InferenceEngine(ABC):
+120    """Abstract inference engine class."""
+121
+122    rng: RNG
+123
+124    @abstractmethod
+125    def fit(self):
+126        """Fit model."""
+127        pass
+128
+129
+130class MCMC(InferenceEngine):
+131    """Abstract class for MCMC."""
+132
+133    model: Model
+134    model_data: dict[str, Any]
+135    nsamples: int
+136    burn: int
+137    thin: int
+138    mcmc_iteration: int
+139    transform: bool
+140    logprob_history: list[float]
+141
+142    @abstractmethod
+143    def _fit(self, *args, **kwargs) -> Generator[State, None, None]:
+144        pass
+145
+146    @abstractmethod
+147    def step(self):
+148        """Update model state in one MCMC iteration."""
+149        pass
+150
+151    def fit(self, *args, **kwargs) -> Chain:
+152        """Run MCMC.
+153
+154        Returns
+155        -------
+156        Chain
+157            Chain of MCMC samples.
+158        """
+159        return Chain(self._fit(*args, **kwargs))
+160
+161    def logprob(self, state: State) -> tuple[float, State]:
+162        """Compute log density.
+163
+164        Parameters
+165        ----------
+166        state : State
+167            Dictionary containing random variables to model.
+168
+169        Returns
+170        -------
+171        tuple[float, State]
+172            (Log density (float), native state and cached values (dict))
+173        """
+174        if self.transform:
+175            # state is real.
+176            # Returns logprob + log_det_jacobian, native_state.
+177            return TransformedLogprobAndTrace.run(
+178                self.model, state, **self.model_data
+179            )
+180        else:
+181            # state is native.
+182            # Returns logprob, state (which is already native).
+183            return LogprobAndTrace.run(self.model, state, **self.model_data)
+184
+185
+186class SingleWalkerMCMC(MCMC):
+187    """Markov Chain Monte Carlo."""
+188
+189    init_state: State
+190    mcmc_state: State
+191    transform: bool
+192
+193    @abstractmethod
+194    def step(self) -> tuple[float, State]:
+195        """Update mcmc_state and return logprob and native_state_and_cache.
+196
+197        Returns
+198        -------
+199        float, State
+200            Logprob and native state and cache dictionary.
+201        """
+202        pass
+203
+204    def _fit(
+205        self, nsamples: int, burn: int = 0, thin: int = 1
+206    ) -> Generator[State, None, None]:
+207        self.nsamples = nsamples
+208        self.burn = burn
+209        self.thin = thin
+210        self.mcmc_state = deepcopy(self.init_state)
+211        self.logprob_history = []
+212
+213        for i in trange(nsamples * thin + burn):
+214            self.mcmc_iteration = i
+215            # NOTE: mcmc_state may not be the returned state, but the state
+216            # that is used in the MCMC (e.g., for computational efficiency).
+217            # trace is the state in its native space appended with any cached
+218            # values.
+219            logprob, trace = self.step()
+220            if i >= burn and (i + 1) % thin == 0:
+221                self.logprob_history.append(logprob)
+222                yield trace
+223
+224
+225class RandomWalkMetropolis(SingleWalkerMCMC):
+226    """Random walk Metropolis.
+227
+228    Parameters
+229    ----------
+230    model: Model
+231        model function.
+232    init_state: Optional[State]
+233        Initial state for MCMC. If `transform=True` then `init_state` should
+234        contain values in the real space; if `transform=False`, then
+235        `init_state` should contain values in the native space. If not
+236        provided, `init_state` is sampled from the prior predictive.
+237        Defaults to None.
+238    proposal: Optional[dict[str, Any]]
+239        Dictionary containing proposal functions, dependent on the current
+240        value. Defaults to None.
+241    transform: bool
+242        Whether or not to sample parameters into the real space. If False,
+243        samples parameters in the native space. Regardless, returned samples
+244        are in the native space and will include cached values. Defaults to
+245        True.
+246    rng: Optional[RNG]
+247        Numpy random number generator. Defaults to None.
+248
+249    Attributes
+250    ----------
+251    model: Model
+252        See Parameters.
+253    init_state: State
+254        If the constructor received None, `init_state` will be an empty
+255        dictionary.
+256    proposal: dict[str, Any]
+257        If None is received in the constructor, an empty dictionary is first
+258        created. In addition, any model parameters unnamed in the constructor
+259        will have a value of
+260        `lambda value, rng, mcmc_iteration: rng.normal(value, 0.1)`.
+261        Thus, if you supplied in the constructor
+262        `dict(mu=lambda value, rng, mcmc_iteration: rng.normal(value, 1))`
+263        and your model is
+264        ```python
+265        def model(ctx, y=None):
+266            mu = ctx.rv("mu", Normal(0, 10))
+267            sigma = ctx.rv("sigma", Gamma(1, 1))
+268            ctx.rv("y", Normal(mu, sigma), obs=y)
+269        ```
+270        then the value for sigma will be
+271        `lambda value, rng, _: rng.normal(value, 0.1)`.
+272    transform: bool
+273        See Parameters.
+274    rng: RNG
+275        If `None` was supplied in the constructor, then rng will be set to
+276        `np.random.default_rng()`.
+277    """
+278
+279    mcmc_state: State
+280    init_state: State
+281
+282    def __init__(
+283        self,
+284        model: Model,
+285        init_state: Optional[State] = None,
+286        proposal: Optional[dict[str, Any]] = None,
+287        transform: bool = True,
+288        rng: Optional[RNG] = None,
+289        **model_data,
+290    ):
+291        self.model = model
+292        self.model_data = model_data
+293        self.transform = transform
+294        self.rng = rng or default_rng()
+295
+296        match init_state, transform:
+297            case None, True:
+298                self.init_state = TransformedPredictive.run(
+299                    model, rng=rng, return_cached=False, **model_data
+300                )
+301            case None, False:
+302                self.init_state = Predictive.run(
+303                    model, rng=rng, return_cached=False, **model_data
+304                )
+305            case _:  # init_state is provided.
+306                self.init_state = init_state
+307
+308        self.proposal = proposal or {}
+309        for name in self.init_state:  # should not have cached values.
+310            self.proposal.setdefault(
+311                name, lambda value, rng, _: rng.normal(value, 0.1)
+312            )
+313
+314    def step(self) -> tuple[float, State]:
+315        """Update mcmc_state and return native state and cached values.
+316
+317        Returns
+318        -------
+319        State
+320            Native state and cached values.
+321        """
+322        proposed_state = {
+323            name: propose(self.mcmc_state[name], self.rng, self.mcmc_iteration)
+324            for name, propose in self.proposal.items()
+325        }
+326        # NOTE: A trace contains the state (i.e., result of rv) in the native
+327        # space AND cached values (i.e., result of cached).
+328        logprob_proposed, proposed_trace = self.logprob(proposed_state)
+329        logprob_current, current_trace = self.logprob(self.mcmc_state)
+330        if logprob_proposed - logprob_current > np.log(self.rng.uniform()):
+331            self.mcmc_state = proposed_state
+332            return logprob_proposed, proposed_trace
+333        else:
+334            return logprob_current, current_trace
+335
+336
+337class AffineInvariantMCMC(MCMC):
+338    """Affine Invariant MCMC."""
+339
+340    nsteps: int
+341    init_state: list[State]
+342    mcmc_state: list[State]
+343    accept_rate: ndarray
+344    accept: list[int]
+345    nwalkers: int
+346    rng: RNG
+347    a: float
+348
+349    @cached_property
+350    def dim(self) -> int:
+351        """Number of model parameters."""
+352        return int(
+353            sum(
+354                np.prod(np.shape(value))
+355                for value in self.init_state[0].values()
+356            )
+357        )
+358
+359    def logprob(self, state: State) -> tuple[float, float, State]:
+360        """Compute log density.
+361
+362        Parameters
+363        ----------
+364        state : State
+365            Dictionary containing random variables to model.
+366
+367        Returns
+368        -------
+369        tuple[float, float, State]
+370            (
+371                Log density in native space,
+372                Log determinant of jacobian,
+373                native state and cached values (dict)
+374            )
+375        """
+376        if self.transform:
+377            # state is real.
+378            # Returns logprob, log_det_jacobian, native_state.
+379            return LogprobAndLogjacobianAndTrace.run(
+380                self.model, state, **self.model_data
+381            )
+382        else:
+383            # state is native.
+384            # Returns logprob, logprob, state (which is already native).
+385            lp, trace = LogprobAndTrace.run(
+386                self.model, state, **self.model_data
+387            )
+388            return lp, 0, trace
+389
+390    @abstractmethod
+391    def step(self) -> tuple[list[float], list[State]]:
+392        """Update mcmc_state and return list of native_state_and_cache.
+393
+394        Returns
+395        -------
+396        list[State]
+397            List of native state and cache dictionary.
+398        """
+399        pass
+400
+401    def _update_walker(self, i: int) -> tuple[float, State]:
+402        this_walker = self.mcmc_state[i]
+403        z = self._draw_z(i)
+404        other_walker = self._draw_walker(i)
+405
+406        candidate = {
+407            name: value + (this_walker[name] - value) * z
+408            for name, value in other_walker.items()
+409        }
+410
+411        cand_logprob, cand_ldj, cand_trace = self.logprob(candidate)
+412        this_logprob, this_ldj, this_trace = self.logprob(this_walker)
+413        log_accept_prob = cand_logprob + cand_ldj - this_logprob - this_ldj
+414        log_accept_prob += (self.dim - 1) * np.log(z)
+415        if log_accept_prob > np.log(self._draw_u(i)):
+416            if self.mcmc_iteration >= self.burn:
+417                self.accept[i] += 1
+418            for key, value in candidate.items():
+419                this_walker[key] = value
+420            trace = cand_trace
+421            lp = cand_logprob
+422        else:
+423            trace = this_trace
+424            lp = this_logprob
+425
+426        return lp, trace
+427
+428    def fit(
+429        self, *args, rebalanced_samples: Optional[int] = None, **kwargs
+430    ) -> Chain:
+431        """Fit model with AIES."""
+432        chain = Chain(self._fit(*args, **kwargs))
+433
+434        if rebalanced_samples is None:
+435            rebalanced_samples = self.nsteps
+436
+437        if rebalanced_samples > 0:
+438            # Reweight with importance sampling.
+439            weights = softmax(self.logprob_history)
+440            index = self.rng.choice(
+441                len(weights), rebalanced_samples, replace=True, p=weights
+442            )
+443            self.resampled_logprob_history = np.array(
+444                [self.logprob_history[i] for i in index]
+445            )
+446            chain = Chain(chain.states[i] for i in index)
+447
+448        return chain
+449
+450    def _fit(
+451        self, nsteps: int, burn: int = 0, thin: int = 1
+452    ) -> Generator[State, None, None]:
+453        self.nsteps = nsteps
+454        self.nsamples = nsteps * self.nwalkers
+455        self.burn = burn
+456        self.thin = thin
+457        self.mcmc_state = deepcopy(self.init_state)
+458        self.logprob_history = []
+459
+460        for i in trange(nsteps * thin + burn):
+461            self.mcmc_iteration = i
+462            # NOTE: mcmc_state may not be the returned state, but the state
+463            # that is used in the MCMC (e.g., for computational efficiency).
+464            # trace is the state in its native space appended with any cached
+465            # values.
+466            logprob, trace = self.step()
+467            if i >= burn and (i + 1) % thin == 0:
+468                self.logprob_history.extend(logprob)
+469                yield from trace
+470
+471        self.accept_rate = np.array(self.accept) / (self.nsteps * self.thin)
+472
+473    @cached_property
+474    def _root_a(self) -> float:
+475        return np.sqrt(self.a)
+476
+477    @cached_property
+478    def _invroot_a(self) -> float:
+479        return 1 / self._root_a
+480
+481    @abstractmethod
+482    def _draw_walker(self, i: int) -> State: ...
+483
+484    @abstractmethod
+485    def _draw_u(self, i: int) -> float: ...
+486
+487    def _compute_z_given_u(self, u: float) -> float:
+488        return (u * (self._root_a - self._invroot_a) + self._invroot_a) ** 2
+489
+490    def _draw_z(self, i: int) -> float:
+491        u = self._draw_u(i)
+492        return self._compute_z_given_u(u)
+493
+494
+495# https://arxiv.org/abs/1202.3665
+496class AIES(AffineInvariantMCMC):
+497    """Sequential Affine Invariant Ensemble Sampler.
+498
+499    This sampler is good for target distributions that are not multimodal and
+500    separated by large low density regions. You should use as many walkers as
+501    you can afford. Whereas this sampler employs walkers that are sequeutnailly
+502    updated.  there is a parallel analog that updates walkers in parallel.
+503
+504    Parameters
+505    ----------
+506    model : Model
+507        A model function of the form `def model(ctx: Context, **data)`.
+508    num_walkers : int, optional
+509        Number of walkers. Defaults to 10.
+510    transform : bool, optional
+511        Whether or not to transform parameters into the real space, by default
+512        True.
+513    rng : RNG, optional
+514        Random number generator, by default default_rng()
+515    a : float, optional
+516        Tuning parameter that is set, by default, to 2.0, which is good for many
+517        cases.
+518    temperature_fn : Optional[Callable[[int], float]], optional
+519        A temperature function for annealing, by default None.
+520
+521    References
+522    ----------
+523    - [emcee: The MCMC Hammer](https://arxiv.org/pdf/1202.3665)
+524    - [Ensemble Samplers with Affine Invariance](https://msp.org/camcos/2010/5-1/camcos-v5-n1-p04-s.pdf)
+525    """
+526
+527    @staticmethod
+528    def default_temperature_fn(iter: int) -> float:
+529        """Return 1."""
+530        return 1.0
+531
+532    def __init__(
+533        self,
+534        model: Model,
+535        nwalkers: int = 10,
+536        transform: bool = True,
+537        rng: RNG = default_rng(),
+538        a: float = 2.0,
+539        temperature_fn: Optional[Callable[[int], float]] = None,
+540        init_state: Optional[list[State]] = None,
+541        **model_data,
+542    ):
+543        self.model: Model = model
+544        self.nwalkers: int = nwalkers
+545        self.transform: bool = transform
+546        self.rng = rng
+547        self.accept = [0] * nwalkers
+548        if a <= 1:
+549            raise ValueError("Tuning parameter `a` must be larger than 1.")
+550
+551        self.a: float = a
+552        self.model_data = model_data
+553        self.temperature_fn: Callable[[int], float] = (
+554            temperature_fn or self.default_temperature_fn
+555        )
+556        predictive = TransformedPredictive if transform else Predictive
+557        if init_state is None:
+558            init_state = [
+559                predictive.run(
+560                    model, rng=rng, return_cached=False, **model_data
+561                )
+562                for _ in range(self.nwalkers)
+563            ]
+564        self.init_state = init_state
+565
+566    def step(self) -> tuple[list[float], list[State]]:
+567        """Update mcmc_state and return list of native_state_and_cache.
+568
+569        Returns
+570        -------
+571        list[float], list[State]
+572            List of logprobs and list of native state and cache dictionary.
+573        """
+574        trace = []
+575        lp = []
+576        for i, _ in enumerate(self.mcmc_state):
+577            lp_i, trace_i = self._update_walker(i)
+578            lp.append(lp_i)
+579            trace.append(trace_i)
+580
+581        return lp, trace
+582
+583    def _draw_u(self, _: int) -> float:
+584        return self.rng.uniform()
+585
+586    def _draw_walker(self, i: int) -> State:
+587        # Draw anything but the current walker (i).
+588        if (j := self.rng.integers(self.nwalkers)) == i:
+589            return self._draw_walker(i)
+590        else:
+591            return self.mcmc_state[j]
+592
+593
+594class ParallelAIES(AffineInvariantMCMC):
+595    """Parallel Affine Invariant MCMC (or Parallel AIES).
+596
+597    References
+598    ----------
+599    - [emcee: The MCMC Hammer](https://arxiv.org/pdf/1202.3665)
+600    - [Ensemble Samplers with Affine Invariance](https://msp.org/camcos/2010/5-1/camcos-v5-n1-p04-s.pdf)
+601    """
+602
+603    def __init__(
+604        self,
+605        model: Model,
+606        executor: Executor,
+607        nwalkers: int = 10,
+608        transform: bool = True,
+609        rng: RNG = default_rng(),
+610        a: float = 2.0,
+611        init_state: Optional[list[State]] = None,
+612        **model_data,
+613    ):
+614        if nwalkers < 4 or nwalkers % 2 == 1:
+615            raise ValueError(
+616                "num_walkers needs to be an even integer greater than 3, "
+617                f"but got {nwalkers}!"
+618            )
+619
+620        self.executor = executor
+621        self.model: Model = model
+622        self.nwalkers: int = nwalkers
+623        self.transform: bool = transform
+624        self.rng = rng
+625        self.rngs = self.rng.spawn(self.nwalkers)
+626        self.accept = [0] * nwalkers
+627        if a <= 1:
+628            raise ValueError("Tuning parameter `a` must be larger than 1.")
+629
+630        self.a: float = a
+631        self.model_data = model_data
+632        predictive = TransformedPredictive if transform else Predictive
+633        if init_state is None:
+634            init_state = [
+635                predictive.run(
+636                    model, rng=self.rng, return_cached=False, **model_data
+637                )
+638                for _ in range(self.nwalkers)
+639            ]
+640        self.init_state = init_state
+641
+642    def _draw_u(self, i: int) -> float:
+643        return self.rngs[i].uniform()
+644
+645    def step(self) -> tuple[list[float], list[State]]:
+646        """Update mcmc_state and return list of native_state_and_cache.
+647
+648        Returns
+649        -------
+650        list[float], list[State]
+651            Tuple in which the first element is a list of logprobs, and the
+652            second element is a list of traces (i.e., native state and cache
+653            dictionary).
+654        """
+655        mid = self.nwalkers // 2
+656        out_first_half = list(
+657            self.executor.map(self._update_walker, range(mid))
+658        )
+659        out_second_half = list(
+660            self.executor.map(self._update_walker, range(mid, self.nwalkers))
+661        )
+662        logprob_first_half, trace_first_half = zip(*out_first_half)
+663        logprob_second_half, trace_second_half = zip(*out_second_half)
+664
+665        logprob = logprob_first_half + logprob_second_half
+666        trace = trace_first_half + trace_second_half
+667        return logprob, trace
+668
+669    def _draw_walker(self, i: int) -> State:
+670        other_walkers = self._get_other_walkers(i)
+671        j = self.rngs[i].integers(len(other_walkers))
+672        return other_walkers[j]
+673
+674    def _get_other_walkers(self, i: int) -> list[State]:
+675        mid = self.nwalkers // 2
+676        if i < mid:
+677            return self.mcmc_state[mid:]
+678        else:
+679            return self.mcmc_state[:mid]
+680
+681
+682class ImportanceSampling(InferenceEngine):
+683    """Importance Sampling."""
+684
+685    particles: list[State]
+686
+687    def __init__(
+688        self,
+689        model: Model,
+690        rng: Optional[RNG] = None,
+691        particles: Optional[list[State]] = None,
+692        nparticles: Optional[int] = None,
+693        temperature: float = 1.0,
+694        **model_data,
+695    ):
+696        self.model = model
+697        self.model_data = model_data
+698        self.temperature = temperature
+699        self.rng = rng or default_rng()
+700        match nparticles, particles:
+701            case None, None:
+702                raise ValueError(
+703                    "nparticles and particles cannot both be None!"
+704                )
+705            case _, None:
+706                self.nparticles = nparticles
+707                logprobs_and_samples = [
+708                    LogprobAndPriorSample.run(
+709                        model=self.model, rng=self.rng, **self.model_data
+710                    )
+711                    for _ in trange(self.nparticles)
+712                ]
+713                self.logprobs, self.particles = zip(*logprobs_and_samples)
+714            case None, _:
+715                self.particles = particles
+716                self.nparticles = len(particles)
+717                self.logprobs = [
+718                    LogprobAndTrace.run(
+719                        model=self.model, state=particle, **self.model_data
+720                    )[0]
+721                    for particle in tqdm(self.particles)
+722                ]
+723            case _:
+724                raise ValueError(
+725                    "nparticles and particles cannot both be specified!"
+726                )
+727
+728        self.log_weights = log_softmax(self.logprobs)
+729        self.weights = softmax(self.logprobs)
+730        # self.ess = ess_kish(self.weights)
+731
+732    def fit(self, nsamples: int) -> Chain:
+733        """Sample."""
+734        indices = self.rng.choice(self.nparticles, nsamples, p=self.weights)
+735        return Chain(self.particles[i] for i in indices)
+736
+737
+738class LaplaceApproximation(InferenceEngine):
+739    """Laplace Approximation of Posterior."""
+740
+741    rng: RNG
+742
+743    def __init__(
+744        self,
+745        model: Model,
+746        transform: bool = True,
+747        rng: Optional[RNG] = None,
+748        **model_data,
+749    ):
+750        self.model = model
+751        self.model_data = model_data
+752        self.rng = rng or default_rng()
+753        self.transform = transform
+754
+755        if self.transform:
+756            self.init_state = TransformedPredictive.run(
+757                model, rng=rng, return_cached=False, **self.model_data
+758            )
+759        else:
+760            self.init_state = Predictive.run(
+761                model, rng=rng, return_cached=False, **self.model_data
+762            )
+763
+764        self.shaper = Shaper.from_state(self.init_state)
+765        self.init_vec_state = self.shaper.vec(self.init_state)
+766
+767    def logprob(self, vec_state: np.ndarray) -> float:
+768        """Compute log density.
+769
+770        Parameters
+771        ----------
+772        state : State
+773            Dictionary containing random variables to model.
+774
+775        Returns
+776        -------
+777        tuple[float, State]
+778            (Log density (float), native state and cached values (dict))
+779        """
+780        state = self.shaper.unvec(vec_state)
+781        if self.transform:
+782            # state is real.
+783            # Returns logprob + log_det_jacobian, native_state.
+784            return TransformedLogprobAndTrace.run(
+785                self.model, state, **self.model_data
+786            )[0]
+787        else:
+788            # state is native.
+789            # Returns logprob, state (which is already native).
+790            return LogprobAndTrace.run(self.model, state, **self.model_data)[0]
+791
+792    def _negative_logprob(self, vec_state) -> float:
+793        return -self.logprob(vec_state)
+794
+795    def fit(self, nsamples: int, **minimize_kwargs):
+796        """Fit model with laplace approx."""
+797        self.result = minimize(
+798            self._negative_logprob, x0=self.init_vec_state, **minimize_kwargs
+799        )
+800        mean = self.result.x
+801        cov = self.result.hess_inv
+802        samples = MvNormal(mean, cov).sample((nsamples,), rng=self.rng)
+803
+804        # Return native state and cache.
+805        if self.transform:
+806            return Chain(
+807                TransformedLogprobAndTrace.run(
+808                    self.model,
+809                    self.shaper.unvec(vec_state),
+810                    **self.model_data,
+811                )[1]
+812                for vec_state in samples
+813            )
+814        else:
+815            return Chain(
+816                Predictive.run(
+817                    self.model,
+818                    self.shaper.unvec(vec_state),
+819                    return_cached=True,
+820                    **self.model_data,
+821                )
+822                for vec_state in samples
+823            )
+824
+825
+826class BayesianOptimization(InferenceEngine):
+827    """Bayesian Optimization."""
+828
+829    ...
+830
+831
+832class AdaptiveRandomWalkMetropolis(SingleWalkerMCMC):
+833    """Adaptive Random Walk Metropolis.
+834
+835    Resources
+836    ---------
+837    - https://probability.ca/jeff/ftpdir/adaptex.pdf
+838    """
+839
+840    ...
+
+ + +
+
+
+ P = +~P + + +
+ + + + +
+
+
+ Model = +typing.Callable[typing.Concatenate[arianna.ppl.context.Context, ~P], NoneType] + + +
+ + + + +
+
+
+ Logprob = +typing.Callable[[dict[str, float | numpy.ndarray]], tuple[float, dict[str, float | numpy.ndarray]]] + + +
+ + + + +
+
+ +
+ + class + Chain: + + + +
+ + 
 42class Chain:
+ 43    """Chain MCMC samples.
+ 44
+ 45    Parameters
+ 46    ----------
+ 47    states : Iterable[State]
+ 48        MCMC states.
+ 49
+ 50    Attributes
+ 51    ----------
+ 52    chain : list[State]
+ 53        MCMC states in list format.
+ 54    """
+ 55
+ 56    def __init__(self, states: Iterable[State]):
+ 57        self.states = list(states)
+ 58        self.names = list(self.states[0].keys())
+ 59
+ 60    def __iter__(self):
+ 61        """Iterate over states.
+ 62
+ 63        Yields
+ 64        ------
+ 65        State
+ 66            MCMC state within chain.
+ 67        """
+ 68        for state in self.states:
+ 69            yield state
+ 70
+ 71    def __len__(self) -> int:
+ 72        """Return the number of states."""
+ 73        return len(self.states)
+ 74
+ 75    def get(self, name: str) -> ndarray:
+ 76        """Get all MCMC samples for one variable or cached value by name.
+ 77
+ 78        Parameters
+ 79        ----------
+ 80        name : str
+ 81            Name of model parameter or cached value.
+ 82
+ 83        Returns
+ 84        -------
+ 85        ndarray
+ 86            MCMC samples for the variable or cached value named.
+ 87        """
+ 88        return np.stack([c[name] for c in self.states])
+ 89
+ 90    @cached_property
+ 91    def bundle(self) -> dict[str, ndarray]:
+ 92        """Bundle MCMC values into a dictionary.
+ 93
+ 94        Returns
+ 95        -------
+ 96        dict[str, ndarray]
+ 97            Dictionary bundle of MCMC samples.
+ 98        """
+ 99        return {name: self.get(name) for name in self.names}
+100
+101    def subset(self, burn: int = 0, thin: int = 1):
+102        """Return subset of the states.
+103
+104        Parameters
+105        ----------
+106        burn : int, optional
+107            Number of initial samples to discard, by default 0.
+108        thin : int, optional
+109            Take only every `thin`-th sample, by default 1.
+110
+111        Returns
+112        -------
+113        Chain
+114            A whole new chain, with the first `burn` removed, and taking only
+115            every `thin`-th sample.
+116        """
+117        return Chain(self.states[burn::thin])
+
+ + +

Chain MCMC samples.

+ +
Parameters
+ +
    +
  • states (Iterable[State]): +MCMC states.
    • +
+ +
Attributes
+ +
    +
  • chain (list[State]): +MCMC states in list format.
    • +
+
+ + +
+ +
+ + Chain(states: Iterable[dict[str, float | numpy.ndarray]]) + + + +
+ + 
56    def __init__(self, states: Iterable[State]):
+57        self.states = list(states)
+58        self.names = list(self.states[0].keys())
+
+ + + + +
+
+
+ states + + +
+ + + + +
+
+
+ names + + +
+ + + + +
+
+ +
+ + def + get(self, name: str) -> numpy.ndarray: + + + +
+ + 
75    def get(self, name: str) -> ndarray:
+76        """Get all MCMC samples for one variable or cached value by name.
+77
+78        Parameters
+79        ----------
+80        name : str
+81            Name of model parameter or cached value.
+82
+83        Returns
+84        -------
+85        ndarray
+86            MCMC samples for the variable or cached value named.
+87        """
+88        return np.stack([c[name] for c in self.states])
+
+ + +

Get all MCMC samples for one variable or cached value by name.

+ +
Parameters
+ +
    +
  • name (str): +Name of model parameter or cached value.
    • +
+ +
Returns
+ +
    +
  • ndarray: MCMC samples for the variable or cached value named.
    • +
+
+ + +
+
+ +
+ bundle: dict[str, numpy.ndarray] + + + +
+ + 
90    @cached_property
+91    def bundle(self) -> dict[str, ndarray]:
+92        """Bundle MCMC values into a dictionary.
+93
+94        Returns
+95        -------
+96        dict[str, ndarray]
+97            Dictionary bundle of MCMC samples.
+98        """
+99        return {name: self.get(name) for name in self.names}
+
+ + +

Bundle MCMC values into a dictionary.

+ +
Returns
+ +
    +
  • dict[str, ndarray]: Dictionary bundle of MCMC samples.
    • +
+
+ + +
+
+ +
+ + def + subset(self, burn: int = 0, thin: int = 1): + + + +
+ + 
101    def subset(self, burn: int = 0, thin: int = 1):
+102        """Return subset of the states.
+103
+104        Parameters
+105        ----------
+106        burn : int, optional
+107            Number of initial samples to discard, by default 0.
+108        thin : int, optional
+109            Take only every `thin`-th sample, by default 1.
+110
+111        Returns
+112        -------
+113        Chain
+114            A whole new chain, with the first `burn` removed, and taking only
+115            every `thin`-th sample.
+116        """
+117        return Chain(self.states[burn::thin])
+
+ + +

Return subset of the states.

+ +
Parameters
+ +
    +
  • burn (int, optional): +Number of initial samples to discard, by default 0.
    • +
  • thin (int, optional): +Take only every thin-th sample, by default 1.
    • +
+ +
Returns
+ +
    +
  • Chain: A whole new chain, with the first burn removed, and taking only +every thin-th sample.
    • +
+
+ + +
+
+
+ +
+ + class + InferenceEngine(abc.ABC): + + + +
+ + 
120class InferenceEngine(ABC):
+121    """Abstract inference engine class."""
+122
+123    rng: RNG
+124
+125    @abstractmethod
+126    def fit(self):
+127        """Fit model."""
+128        pass
+
+ + +

Abstract inference engine class.

+
+ + +
+
+ rng: numpy.random._generator.Generator + + +
+ + + + +
+
+ +
+
@abstractmethod
+ + def + fit(self): + + + +
+ + 
125    @abstractmethod
+126    def fit(self):
+127        """Fit model."""
+128        pass
+
+ + +

Fit model.

+
+ + +
+
+
+ +
+ + class + MCMC(InferenceEngine): + + + +
+ + 
131class MCMC(InferenceEngine):
+132    """Abstract class for MCMC."""
+133
+134    model: Model
+135    model_data: dict[str, Any]
+136    nsamples: int
+137    burn: int
+138    thin: int
+139    mcmc_iteration: int
+140    transform: bool
+141    logprob_history: list[float]
+142
+143    @abstractmethod
+144    def _fit(self, *args, **kwargs) -> Generator[State, None, None]:
+145        pass
+146
+147    @abstractmethod
+148    def step(self):
+149        """Update model state in one MCMC iteration."""
+150        pass
+151
+152    def fit(self, *args, **kwargs) -> Chain:
+153        """Run MCMC.
+154
+155        Returns
+156        -------
+157        Chain
+158            Chain of MCMC samples.
+159        """
+160        return Chain(self._fit(*args, **kwargs))
+161
+162    def logprob(self, state: State) -> tuple[float, State]:
+163        """Compute log density.
+164
+165        Parameters
+166        ----------
+167        state : State
+168            Dictionary containing random variables to model.
+169
+170        Returns
+171        -------
+172        tuple[float, State]
+173            (Log density (float), native state and cached values (dict))
+174        """
+175        if self.transform:
+176            # state is real.
+177            # Returns logprob + log_det_jacobian, native_state.
+178            return TransformedLogprobAndTrace.run(
+179                self.model, state, **self.model_data
+180            )
+181        else:
+182            # state is native.
+183            # Returns logprob, state (which is already native).
+184            return LogprobAndTrace.run(self.model, state, **self.model_data)
+
+ + +

Abstract class for MCMC.

+
+ + +
+
+ model: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType] + + +
+ + + + +
+
+
+ model_data: dict[str, typing.Any] + + +
+ + + + +
+
+
+ nsamples: int + + +
+ + + + +
+
+
+ burn: int + + +
+ + + + +
+
+
+ thin: int + + +
+ + + + +
+
+
+ mcmc_iteration: int + + +
+ + + + +
+
+
+ transform: bool + + +
+ + + + +
+
+
+ logprob_history: list[float] + + +
+ + + + +
+
+ +
+
@abstractmethod
+ + def + step(self): + + + +
+ + 
147    @abstractmethod
+148    def step(self):
+149        """Update model state in one MCMC iteration."""
+150        pass
+
+ + +

Update model state in one MCMC iteration.

+
+ + +
+
+ +
+ + def + fit(self, *args, **kwargs) -> Chain: + + + +
+ + 
152    def fit(self, *args, **kwargs) -> Chain:
+153        """Run MCMC.
+154
+155        Returns
+156        -------
+157        Chain
+158            Chain of MCMC samples.
+159        """
+160        return Chain(self._fit(*args, **kwargs))
+
+ + +

Run MCMC.

+ +
Returns
+ +
    +
  • Chain: Chain of MCMC samples.
    • +
+
+ + +
+
+ +
+ + def + logprob( self, state: dict[str, float | numpy.ndarray]) -> tuple[float, dict[str, float | numpy.ndarray]]: + + + +
+ + 
162    def logprob(self, state: State) -> tuple[float, State]:
+163        """Compute log density.
+164
+165        Parameters
+166        ----------
+167        state : State
+168            Dictionary containing random variables to model.
+169
+170        Returns
+171        -------
+172        tuple[float, State]
+173            (Log density (float), native state and cached values (dict))
+174        """
+175        if self.transform:
+176            # state is real.
+177            # Returns logprob + log_det_jacobian, native_state.
+178            return TransformedLogprobAndTrace.run(
+179                self.model, state, **self.model_data
+180            )
+181        else:
+182            # state is native.
+183            # Returns logprob, state (which is already native).
+184            return LogprobAndTrace.run(self.model, state, **self.model_data)
+
+ + +

Compute log density.

+ +
Parameters
+ +
    +
  • state (State): +Dictionary containing random variables to model.
    • +
+ +
Returns
+ +
    +
  • tuple[float, State]: (Log density (float), native state and cached values (dict))
    • +
+
+ + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + SingleWalkerMCMC(MCMC): + + + +
+ + 
187class SingleWalkerMCMC(MCMC):
+188    """Markov Chain Monte Carlo."""
+189
+190    init_state: State
+191    mcmc_state: State
+192    transform: bool
+193
+194    @abstractmethod
+195    def step(self) -> tuple[float, State]:
+196        """Update mcmc_state and return logprob and native_state_and_cache.
+197
+198        Returns
+199        -------
+200        float, State
+201            Logprob and native state and cache dictionary.
+202        """
+203        pass
+204
+205    def _fit(
+206        self, nsamples: int, burn: int = 0, thin: int = 1
+207    ) -> Generator[State, None, None]:
+208        self.nsamples = nsamples
+209        self.burn = burn
+210        self.thin = thin
+211        self.mcmc_state = deepcopy(self.init_state)
+212        self.logprob_history = []
+213
+214        for i in trange(nsamples * thin + burn):
+215            self.mcmc_iteration = i
+216            # NOTE: mcmc_state may not be the returned state, but the state
+217            # that is used in the MCMC (e.g., for computational efficiency).
+218            # trace is the state in its native space appended with any cached
+219            # values.
+220            logprob, trace = self.step()
+221            if i >= burn and (i + 1) % thin == 0:
+222                self.logprob_history.append(logprob)
+223                yield trace
+
+ + +

Markov Chain Monte Carlo.

+
+ + +
+
+ init_state: dict[str, float | numpy.ndarray] + + +
+ + + + +
+
+
+ mcmc_state: dict[str, float | numpy.ndarray] + + +
+ + + + +
+
+
+ transform: bool + + +
+ + + + +
+
+ +
+
@abstractmethod
+ + def + step(self) -> tuple[float, dict[str, float | numpy.ndarray]]: + + + +
+ + 
194    @abstractmethod
+195    def step(self) -> tuple[float, State]:
+196        """Update mcmc_state and return logprob and native_state_and_cache.
+197
+198        Returns
+199        -------
+200        float, State
+201            Logprob and native state and cache dictionary.
+202        """
+203        pass
+
+ + +

Update mcmc_state and return logprob and native_state_and_cache.

+ +
Returns
+ +
    +
  • float, State: Logprob and native state and cache dictionary.
    • +
+
+ + +
+
+
Inherited Members
+
+ + +
+
+
+
+ +
+ + class + RandomWalkMetropolis(SingleWalkerMCMC): + + + +
+ + 
226class RandomWalkMetropolis(SingleWalkerMCMC):
+227    """Random walk Metropolis.
+228
+229    Parameters
+230    ----------
+231    model: Model
+232        model function.
+233    init_state: Optional[State]
+234        Initial state for MCMC. If `transform=True` then `init_state` should
+235        contain values in the real space; if `transform=False`, then
+236        `init_state` should contain values in the native space. If not
+237        provided, `init_state` is sampled from the prior predictive.
+238        Defaults to None.
+239    proposal: Optional[dict[str, Any]]
+240        Dictionary containing proposal functions, dependent on the current
+241        value. Defaults to None.
+242    transform: bool
+243        Whether or not to sample parameters into the real space. If False,
+244        samples parameters in the native space. Regardless, returned samples
+245        are in the native space and will include cached values. Defaults to
+246        True.
+247    rng: Optional[RNG]
+248        Numpy random number generator. Defaults to None.
+249
+250    Attributes
+251    ----------
+252    model: Model
+253        See Parameters.
+254    init_state: State
+255        If the constructor received None, `init_state` will be an empty
+256        dictionary.
+257    proposal: dict[str, Any]
+258        If None is received in the constructor, an empty dictionary is first
+259        created. In addition, any model parameters unnamed in the constructor
+260        will have a value of
+261        `lambda value, rng, mcmc_iteration: rng.normal(value, 0.1)`.
+262        Thus, if you supplied in the constructor
+263        `dict(mu=lambda value, rng, mcmc_iteration: rng.normal(value, 1))`
+264        and your model is
+265        ```python
+266        def model(ctx, y=None):
+267            mu = ctx.rv("mu", Normal(0, 10))
+268            sigma = ctx.rv("sigma", Gamma(1, 1))
+269            ctx.rv("y", Normal(mu, sigma), obs=y)
+270        ```
+271        then the value for sigma will be
+272        `lambda value, rng, _: rng.normal(value, 0.1)`.
+273    transform: bool
+274        See Parameters.
+275    rng: RNG
+276        If `None` was supplied in the constructor, then rng will be set to
+277        `np.random.default_rng()`.
+278    """
+279
+280    mcmc_state: State
+281    init_state: State
+282
+283    def __init__(
+284        self,
+285        model: Model,
+286        init_state: Optional[State] = None,
+287        proposal: Optional[dict[str, Any]] = None,
+288        transform: bool = True,
+289        rng: Optional[RNG] = None,
+290        **model_data,
+291    ):
+292        self.model = model
+293        self.model_data = model_data
+294        self.transform = transform
+295        self.rng = rng or default_rng()
+296
+297        match init_state, transform:
+298            case None, True:
+299                self.init_state = TransformedPredictive.run(
+300                    model, rng=rng, return_cached=False, **model_data
+301                )
+302            case None, False:
+303                self.init_state = Predictive.run(
+304                    model, rng=rng, return_cached=False, **model_data
+305                )
+306            case _:  # init_state is provided.
+307                self.init_state = init_state
+308
+309        self.proposal = proposal or {}
+310        for name in self.init_state:  # should not have cached values.
+311            self.proposal.setdefault(
+312                name, lambda value, rng, _: rng.normal(value, 0.1)
+313            )
+314
+315    def step(self) -> tuple[float, State]:
+316        """Update mcmc_state and return native state and cached values.
+317
+318        Returns
+319        -------
+320        State
+321            Native state and cached values.
+322        """
+323        proposed_state = {
+324            name: propose(self.mcmc_state[name], self.rng, self.mcmc_iteration)
+325            for name, propose in self.proposal.items()
+326        }
+327        # NOTE: A trace contains the state (i.e., result of rv) in the native
+328        # space AND cached values (i.e., result of cached).
+329        logprob_proposed, proposed_trace = self.logprob(proposed_state)
+330        logprob_current, current_trace = self.logprob(self.mcmc_state)
+331        if logprob_proposed - logprob_current > np.log(self.rng.uniform()):
+332            self.mcmc_state = proposed_state
+333            return logprob_proposed, proposed_trace
+334        else:
+335            return logprob_current, current_trace
+
+ + +

Random walk Metropolis.

+ +
Parameters
+ +
    +
  • model (Model): +model function.
    • +
  • init_state (Optional[State]): +Initial state for MCMC. If transform=True then init_state should +contain values in the real space; if transform=False, then +init_state should contain values in the native space. If not +provided, init_state is sampled from the prior predictive. +Defaults to None.
    • +
  • proposal (Optional[dict[str, Any]]): +Dictionary containing proposal functions, dependent on the current +value. Defaults to None.
    • +
  • transform (bool): +Whether or not to sample parameters into the real space. If False, +samples parameters in the native space. Regardless, returned samples +are in the native space and will include cached values. Defaults to +True.
    • +
  • rng (Optional[RNG]): +Numpy random number generator. Defaults to None.
    • +
+ +
Attributes
+ +
    +
  • model (Model): +See Parameters.
    • +
  • init_state (State): +If the constructor received None, init_state will be an empty +dictionary.
    • +

  • proposal (dict[str, Any]): +If None is received in the constructor, an empty dictionary is first +created. In addition, any model parameters unnamed in the constructor +will have a value of +lambda value, rng, mcmc_iteration: rng.normal(value, 0.1). +Thus, if you supplied in the constructor +dict(mu=lambda value, rng, mcmc_iteration: rng.normal(value, 1)) +and your model is

    + +
    +
    def model(ctx, y=None):
+    mu = ctx.rv("mu", Normal(0, 10))
+    sigma = ctx.rv("sigma", Gamma(1, 1))
+    ctx.rv("y", Normal(mu, sigma), obs=y)
+
    +
    + +

    then the value for sigma will be +lambda value, rng, _: rng.normal(value, 0.1).

    • +
  • transform (bool): +See Parameters.
    • +
  • rng (RNG): +If None was supplied in the constructor, then rng will be set to +np.random.default_rng().
    • +
+
+ + +
+ +
+ + RandomWalkMetropolis( model: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType], init_state: Optional[dict[str, float | numpy.ndarray]] = None, proposal: Optional[dict[str, Any]] = None, transform: bool = True, rng: Optional[numpy.random._generator.Generator] = None, **model_data) + + + +
+ + 
283    def __init__(
+284        self,
+285        model: Model,
+286        init_state: Optional[State] = None,
+287        proposal: Optional[dict[str, Any]] = None,
+288        transform: bool = True,
+289        rng: Optional[RNG] = None,
+290        **model_data,
+291    ):
+292        self.model = model
+293        self.model_data = model_data
+294        self.transform = transform
+295        self.rng = rng or default_rng()
+296
+297        match init_state, transform:
+298            case None, True:
+299                self.init_state = TransformedPredictive.run(
+300                    model, rng=rng, return_cached=False, **model_data
+301                )
+302            case None, False:
+303                self.init_state = Predictive.run(
+304                    model, rng=rng, return_cached=False, **model_data
+305                )
+306            case _:  # init_state is provided.
+307                self.init_state = init_state
+308
+309        self.proposal = proposal or {}
+310        for name in self.init_state:  # should not have cached values.
+311            self.proposal.setdefault(
+312                name, lambda value, rng, _: rng.normal(value, 0.1)
+313            )
+
+ + + + +
+
+
+ mcmc_state: dict[str, float | numpy.ndarray] + + +
+ + + + +
+
+
+ init_state: dict[str, float | numpy.ndarray] + + +
+ + + + +
+
+
+ model + + +
+ + + + +
+
+
+ model_data + + +
+ + + + +
+
+
+ transform + + +
+ + + + +
+
+
+ rng + + +
+ + + + +
+
+
+ proposal + + +
+ + + + +
+
+ +
+ + def + step(self) -> tuple[float, dict[str, float | numpy.ndarray]]: + + + +
+ + 
315    def step(self) -> tuple[float, State]:
+316        """Update mcmc_state and return native state and cached values.
+317
+318        Returns
+319        -------
+320        State
+321            Native state and cached values.
+322        """
+323        proposed_state = {
+324            name: propose(self.mcmc_state[name], self.rng, self.mcmc_iteration)
+325            for name, propose in self.proposal.items()
+326        }
+327        # NOTE: A trace contains the state (i.e., result of rv) in the native
+328        # space AND cached values (i.e., result of cached).
+329        logprob_proposed, proposed_trace = self.logprob(proposed_state)
+330        logprob_current, current_trace = self.logprob(self.mcmc_state)
+331        if logprob_proposed - logprob_current > np.log(self.rng.uniform()):
+332            self.mcmc_state = proposed_state
+333            return logprob_proposed, proposed_trace
+334        else:
+335            return logprob_current, current_trace
+
+ + +

Update mcmc_state and return native state and cached values.

+ +
Returns
+ +
    +
  • State: Native state and cached values.
    • +
+
+ + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + AffineInvariantMCMC(MCMC): + + + +
+ + 
338class AffineInvariantMCMC(MCMC):
+339    """Affine Invariant MCMC."""
+340
+341    nsteps: int
+342    init_state: list[State]
+343    mcmc_state: list[State]
+344    accept_rate: ndarray
+345    accept: list[int]
+346    nwalkers: int
+347    rng: RNG
+348    a: float
+349
+350    @cached_property
+351    def dim(self) -> int:
+352        """Number of model parameters."""
+353        return int(
+354            sum(
+355                np.prod(np.shape(value))
+356                for value in self.init_state[0].values()
+357            )
+358        )
+359
+360    def logprob(self, state: State) -> tuple[float, float, State]:
+361        """Compute log density.
+362
+363        Parameters
+364        ----------
+365        state : State
+366            Dictionary containing random variables to model.
+367
+368        Returns
+369        -------
+370        tuple[float, float, State]
+371            (
+372                Log density in native space,
+373                Log determinant of jacobian,
+374                native state and cached values (dict)
+375            )
+376        """
+377        if self.transform:
+378            # state is real.
+379            # Returns logprob, log_det_jacobian, native_state.
+380            return LogprobAndLogjacobianAndTrace.run(
+381                self.model, state, **self.model_data
+382            )
+383        else:
+384            # state is native.
+385            # Returns logprob, logprob, state (which is already native).
+386            lp, trace = LogprobAndTrace.run(
+387                self.model, state, **self.model_data
+388            )
+389            return lp, 0, trace
+390
+391    @abstractmethod
+392    def step(self) -> tuple[list[float], list[State]]:
+393        """Update mcmc_state and return list of native_state_and_cache.
+394
+395        Returns
+396        -------
+397        list[State]
+398            List of native state and cache dictionary.
+399        """
+400        pass
+401
+402    def _update_walker(self, i: int) -> tuple[float, State]:
+403        this_walker = self.mcmc_state[i]
+404        z = self._draw_z(i)
+405        other_walker = self._draw_walker(i)
+406
+407        candidate = {
+408            name: value + (this_walker[name] - value) * z
+409            for name, value in other_walker.items()
+410        }
+411
+412        cand_logprob, cand_ldj, cand_trace = self.logprob(candidate)
+413        this_logprob, this_ldj, this_trace = self.logprob(this_walker)
+414        log_accept_prob = cand_logprob + cand_ldj - this_logprob - this_ldj
+415        log_accept_prob += (self.dim - 1) * np.log(z)
+416        if log_accept_prob > np.log(self._draw_u(i)):
+417            if self.mcmc_iteration >= self.burn:
+418                self.accept[i] += 1
+419            for key, value in candidate.items():
+420                this_walker[key] = value
+421            trace = cand_trace
+422            lp = cand_logprob
+423        else:
+424            trace = this_trace
+425            lp = this_logprob
+426
+427        return lp, trace
+428
+429    def fit(
+430        self, *args, rebalanced_samples: Optional[int] = None, **kwargs
+431    ) -> Chain:
+432        """Fit model with AIES."""
+433        chain = Chain(self._fit(*args, **kwargs))
+434
+435        if rebalanced_samples is None:
+436            rebalanced_samples = self.nsteps
+437
+438        if rebalanced_samples > 0:
+439            # Reweight with importance sampling.
+440            weights = softmax(self.logprob_history)
+441            index = self.rng.choice(
+442                len(weights), rebalanced_samples, replace=True, p=weights
+443            )
+444            self.resampled_logprob_history = np.array(
+445                [self.logprob_history[i] for i in index]
+446            )
+447            chain = Chain(chain.states[i] for i in index)
+448
+449        return chain
+450
+451    def _fit(
+452        self, nsteps: int, burn: int = 0, thin: int = 1
+453    ) -> Generator[State, None, None]:
+454        self.nsteps = nsteps
+455        self.nsamples = nsteps * self.nwalkers
+456        self.burn = burn
+457        self.thin = thin
+458        self.mcmc_state = deepcopy(self.init_state)
+459        self.logprob_history = []
+460
+461        for i in trange(nsteps * thin + burn):
+462            self.mcmc_iteration = i
+463            # NOTE: mcmc_state may not be the returned state, but the state
+464            # that is used in the MCMC (e.g., for computational efficiency).
+465            # trace is the state in its native space appended with any cached
+466            # values.
+467            logprob, trace = self.step()
+468            if i >= burn and (i + 1) % thin == 0:
+469                self.logprob_history.extend(logprob)
+470                yield from trace
+471
+472        self.accept_rate = np.array(self.accept) / (self.nsteps * self.thin)
+473
+474    @cached_property
+475    def _root_a(self) -> float:
+476        return np.sqrt(self.a)
+477
+478    @cached_property
+479    def _invroot_a(self) -> float:
+480        return 1 / self._root_a
+481
+482    @abstractmethod
+483    def _draw_walker(self, i: int) -> State: ...
+484
+485    @abstractmethod
+486    def _draw_u(self, i: int) -> float: ...
+487
+488    def _compute_z_given_u(self, u: float) -> float:
+489        return (u * (self._root_a - self._invroot_a) + self._invroot_a) ** 2
+490
+491    def _draw_z(self, i: int) -> float:
+492        u = self._draw_u(i)
+493        return self._compute_z_given_u(u)
+
+ + +

Affine Invariant MCMC.

+
+ + +
+
+ nsteps: int + + +
+ + + + +
+
+
+ init_state: list[dict[str, float | numpy.ndarray]] + + +
+ + + + +
+
+
+ mcmc_state: list[dict[str, float | numpy.ndarray]] + + +
+ + + + +
+
+
+ accept_rate: numpy.ndarray + + +
+ + + + +
+
+
+ accept: list[int] + + +
+ + + + +
+
+
+ nwalkers: int + + +
+ + + + +
+
+
+ rng: numpy.random._generator.Generator + + +
+ + + + +
+
+
+ a: float + + +
+ + + + +
+
+ +
+ dim: int + + + +
+ + 
350    @cached_property
+351    def dim(self) -> int:
+352        """Number of model parameters."""
+353        return int(
+354            sum(
+355                np.prod(np.shape(value))
+356                for value in self.init_state[0].values()
+357            )
+358        )
+
+ + +

Number of model parameters.

+
+ + +
+
+ +
+ + def + logprob( self, state: dict[str, float | numpy.ndarray]) -> tuple[float, float, dict[str, float | numpy.ndarray]]: + + + +
+ + 
360    def logprob(self, state: State) -> tuple[float, float, State]:
+361        """Compute log density.
+362
+363        Parameters
+364        ----------
+365        state : State
+366            Dictionary containing random variables to model.
+367
+368        Returns
+369        -------
+370        tuple[float, float, State]
+371            (
+372                Log density in native space,
+373                Log determinant of jacobian,
+374                native state and cached values (dict)
+375            )
+376        """
+377        if self.transform:
+378            # state is real.
+379            # Returns logprob, log_det_jacobian, native_state.
+380            return LogprobAndLogjacobianAndTrace.run(
+381                self.model, state, **self.model_data
+382            )
+383        else:
+384            # state is native.
+385            # Returns logprob, logprob, state (which is already native).
+386            lp, trace = LogprobAndTrace.run(
+387                self.model, state, **self.model_data
+388            )
+389            return lp, 0, trace
+
+ + +

Compute log density.

+ +
Parameters
+ +
    +
  • state (State): +Dictionary containing random variables to model.
    • +
+ +
Returns
+ +
    +
  • tuple[float, float, State]: ( +Log density in native space, +Log determinant of jacobian, +native state and cached values (dict) +)
    • +
+
+ + +
+
+ +
+
@abstractmethod
+ + def + step(self) -> tuple[list[float], list[dict[str, float | numpy.ndarray]]]: + + + +
+ + 
391    @abstractmethod
+392    def step(self) -> tuple[list[float], list[State]]:
+393        """Update mcmc_state and return list of native_state_and_cache.
+394
+395        Returns
+396        -------
+397        list[State]
+398            List of native state and cache dictionary.
+399        """
+400        pass
+
+ + +

Update mcmc_state and return list of native_state_and_cache.

+ +
Returns
+ +
    +
  • list[State]: List of native state and cache dictionary.
    • +
+
+ + +
+
+ +
+ + def + fit( self, *args, rebalanced_samples: Optional[int] = None, **kwargs) -> Chain: + + + +
+ + 
429    def fit(
+430        self, *args, rebalanced_samples: Optional[int] = None, **kwargs
+431    ) -> Chain:
+432        """Fit model with AIES."""
+433        chain = Chain(self._fit(*args, **kwargs))
+434
+435        if rebalanced_samples is None:
+436            rebalanced_samples = self.nsteps
+437
+438        if rebalanced_samples > 0:
+439            # Reweight with importance sampling.
+440            weights = softmax(self.logprob_history)
+441            index = self.rng.choice(
+442                len(weights), rebalanced_samples, replace=True, p=weights
+443            )
+444            self.resampled_logprob_history = np.array(
+445                [self.logprob_history[i] for i in index]
+446            )
+447            chain = Chain(chain.states[i] for i in index)
+448
+449        return chain
+
+ + +

Fit model with AIES.

+
+ + +
+
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + AIES(AffineInvariantMCMC): + + + +
+ + 
497class AIES(AffineInvariantMCMC):
+498    """Sequential Affine Invariant Ensemble Sampler.
+499
+500    This sampler is good for target distributions that are not multimodal and
+501    separated by large low density regions. You should use as many walkers as
+502    you can afford. Whereas this sampler employs walkers that are sequeutnailly
+503    updated.  there is a parallel analog that updates walkers in parallel.
+504
+505    Parameters
+506    ----------
+507    model : Model
+508        A model function of the form `def model(ctx: Context, **data)`.
+509    num_walkers : int, optional
+510        Number of walkers. Defaults to 10.
+511    transform : bool, optional
+512        Whether or not to transform parameters into the real space, by default
+513        True.
+514    rng : RNG, optional
+515        Random number generator, by default default_rng()
+516    a : float, optional
+517        Tuning parameter that is set, by default, to 2.0, which is good for many
+518        cases.
+519    temperature_fn : Optional[Callable[[int], float]], optional
+520        A temperature function for annealing, by default None.
+521
+522    References
+523    ----------
+524    - [emcee: The MCMC Hammer](https://arxiv.org/pdf/1202.3665)
+525    - [Ensemble Samplers with Affine Invariance](https://msp.org/camcos/2010/5-1/camcos-v5-n1-p04-s.pdf)
+526    """
+527
+528    @staticmethod
+529    def default_temperature_fn(iter: int) -> float:
+530        """Return 1."""
+531        return 1.0
+532
+533    def __init__(
+534        self,
+535        model: Model,
+536        nwalkers: int = 10,
+537        transform: bool = True,
+538        rng: RNG = default_rng(),
+539        a: float = 2.0,
+540        temperature_fn: Optional[Callable[[int], float]] = None,
+541        init_state: Optional[list[State]] = None,
+542        **model_data,
+543    ):
+544        self.model: Model = model
+545        self.nwalkers: int = nwalkers
+546        self.transform: bool = transform
+547        self.rng = rng
+548        self.accept = [0] * nwalkers
+549        if a <= 1:
+550            raise ValueError("Tuning parameter `a` must be larger than 1.")
+551
+552        self.a: float = a
+553        self.model_data = model_data
+554        self.temperature_fn: Callable[[int], float] = (
+555            temperature_fn or self.default_temperature_fn
+556        )
+557        predictive = TransformedPredictive if transform else Predictive
+558        if init_state is None:
+559            init_state = [
+560                predictive.run(
+561                    model, rng=rng, return_cached=False, **model_data
+562                )
+563                for _ in range(self.nwalkers)
+564            ]
+565        self.init_state = init_state
+566
+567    def step(self) -> tuple[list[float], list[State]]:
+568        """Update mcmc_state and return list of native_state_and_cache.
+569
+570        Returns
+571        -------
+572        list[float], list[State]
+573            List of logprobs and list of native state and cache dictionary.
+574        """
+575        trace = []
+576        lp = []
+577        for i, _ in enumerate(self.mcmc_state):
+578            lp_i, trace_i = self._update_walker(i)
+579            lp.append(lp_i)
+580            trace.append(trace_i)
+581
+582        return lp, trace
+583
+584    def _draw_u(self, _: int) -> float:
+585        return self.rng.uniform()
+586
+587    def _draw_walker(self, i: int) -> State:
+588        # Draw anything but the current walker (i).
+589        if (j := self.rng.integers(self.nwalkers)) == i:
+590            return self._draw_walker(i)
+591        else:
+592            return self.mcmc_state[j]
+
+ + +

Sequential Affine Invariant Ensemble Sampler.

+ +

This sampler is good for target distributions that are not multimodal and +separated by large low density regions. You should use as many walkers as +you can afford. Whereas this sampler employs walkers that are sequeutnailly +updated. there is a parallel analog that updates walkers in parallel.

+ +
Parameters
+ +
    +
  • model (Model): +A model function of the form def model(ctx: Context, **data).
    • +
  • num_walkers (int, optional): +Number of walkers. Defaults to 10.
    • +
  • transform (bool, optional): +Whether or not to transform parameters into the real space, by default +True.
    • +
  • rng (RNG, optional): +Random number generator, by default default_rng()
    • +
  • a (float, optional): +Tuning parameter that is set, by default, to 2.0, which is good for many +cases.
    • +
  • temperature_fn (Optional[Callable[[int], float]], optional): +A temperature function for annealing, by default None.
    • +
+ +
References
+ + +
+ + +
+ +
+ + AIES( model: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType], nwalkers: int = 10, transform: bool = True, rng: numpy.random._generator.Generator = Generator(PCG64) at 0x105861000, a: float = 2.0, temperature_fn: Optional[Callable[[int], float]] = None, init_state: Optional[list[dict[str, float | numpy.ndarray]]] = None, **model_data) + + + +
+ + 
533    def __init__(
+534        self,
+535        model: Model,
+536        nwalkers: int = 10,
+537        transform: bool = True,
+538        rng: RNG = default_rng(),
+539        a: float = 2.0,
+540        temperature_fn: Optional[Callable[[int], float]] = None,
+541        init_state: Optional[list[State]] = None,
+542        **model_data,
+543    ):
+544        self.model: Model = model
+545        self.nwalkers: int = nwalkers
+546        self.transform: bool = transform
+547        self.rng = rng
+548        self.accept = [0] * nwalkers
+549        if a <= 1:
+550            raise ValueError("Tuning parameter `a` must be larger than 1.")
+551
+552        self.a: float = a
+553        self.model_data = model_data
+554        self.temperature_fn: Callable[[int], float] = (
+555            temperature_fn or self.default_temperature_fn
+556        )
+557        predictive = TransformedPredictive if transform else Predictive
+558        if init_state is None:
+559            init_state = [
+560                predictive.run(
+561                    model, rng=rng, return_cached=False, **model_data
+562                )
+563                for _ in range(self.nwalkers)
+564            ]
+565        self.init_state = init_state
+
+ + + + +
+
+ +
+
@staticmethod
+ + def + default_temperature_fn(iter: int) -> float: + + + +
+ + 
528    @staticmethod
+529    def default_temperature_fn(iter: int) -> float:
+530        """Return 1."""
+531        return 1.0
+
+ + +

Return 1.

+
+ + +
+
+
+ model: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType] + + +
+ + + + +
+
+
+ nwalkers: int + + +
+ + + + +
+
+
+ transform: bool + + +
+ + + + +
+
+
+ rng + + +
+ + + + +
+
+
+ accept + + +
+ + + + +
+
+
+ a: float + + +
+ + + + +
+
+
+ model_data + + +
+ + + + +
+
+
+ temperature_fn: Callable[[int], float] + + +
+ + + + +
+
+
+ init_state + + +
+ + + + +
+
+ +
+ + def + step(self) -> tuple[list[float], list[dict[str, float | numpy.ndarray]]]: + + + +
+ + 
567    def step(self) -> tuple[list[float], list[State]]:
+568        """Update mcmc_state and return list of native_state_and_cache.
+569
+570        Returns
+571        -------
+572        list[float], list[State]
+573            List of logprobs and list of native state and cache dictionary.
+574        """
+575        trace = []
+576        lp = []
+577        for i, _ in enumerate(self.mcmc_state):
+578            lp_i, trace_i = self._update_walker(i)
+579            lp.append(lp_i)
+580            trace.append(trace_i)
+581
+582        return lp, trace
+
+ + +

Update mcmc_state and return list of native_state_and_cache.

+ +
Returns
+ +
    +
  • list[float], list[State]: List of logprobs and list of native state and cache dictionary.
    • +
+
+ + +
+
+
Inherited Members
+
+ + +
+
+
+
+ +
+ + class + ParallelAIES(AffineInvariantMCMC): + + + +
+ + 
595class ParallelAIES(AffineInvariantMCMC):
+596    """Parallel Affine Invariant MCMC (or Parallel AIES).
+597
+598    References
+599    ----------
+600    - [emcee: The MCMC Hammer](https://arxiv.org/pdf/1202.3665)
+601    - [Ensemble Samplers with Affine Invariance](https://msp.org/camcos/2010/5-1/camcos-v5-n1-p04-s.pdf)
+602    """
+603
+604    def __init__(
+605        self,
+606        model: Model,
+607        executor: Executor,
+608        nwalkers: int = 10,
+609        transform: bool = True,
+610        rng: RNG = default_rng(),
+611        a: float = 2.0,
+612        init_state: Optional[list[State]] = None,
+613        **model_data,
+614    ):
+615        if nwalkers < 4 or nwalkers % 2 == 1:
+616            raise ValueError(
+617                "num_walkers needs to be an even integer greater than 3, "
+618                f"but got {nwalkers}!"
+619            )
+620
+621        self.executor = executor
+622        self.model: Model = model
+623        self.nwalkers: int = nwalkers
+624        self.transform: bool = transform
+625        self.rng = rng
+626        self.rngs = self.rng.spawn(self.nwalkers)
+627        self.accept = [0] * nwalkers
+628        if a <= 1:
+629            raise ValueError("Tuning parameter `a` must be larger than 1.")
+630
+631        self.a: float = a
+632        self.model_data = model_data
+633        predictive = TransformedPredictive if transform else Predictive
+634        if init_state is None:
+635            init_state = [
+636                predictive.run(
+637                    model, rng=self.rng, return_cached=False, **model_data
+638                )
+639                for _ in range(self.nwalkers)
+640            ]
+641        self.init_state = init_state
+642
+643    def _draw_u(self, i: int) -> float:
+644        return self.rngs[i].uniform()
+645
+646    def step(self) -> tuple[list[float], list[State]]:
+647        """Update mcmc_state and return list of native_state_and_cache.
+648
+649        Returns
+650        -------
+651        list[float], list[State]
+652            Tuple in which the first element is a list of logprobs, and the
+653            second element is a list of traces (i.e., native state and cache
+654            dictionary).
+655        """
+656        mid = self.nwalkers // 2
+657        out_first_half = list(
+658            self.executor.map(self._update_walker, range(mid))
+659        )
+660        out_second_half = list(
+661            self.executor.map(self._update_walker, range(mid, self.nwalkers))
+662        )
+663        logprob_first_half, trace_first_half = zip(*out_first_half)
+664        logprob_second_half, trace_second_half = zip(*out_second_half)
+665
+666        logprob = logprob_first_half + logprob_second_half
+667        trace = trace_first_half + trace_second_half
+668        return logprob, trace
+669
+670    def _draw_walker(self, i: int) -> State:
+671        other_walkers = self._get_other_walkers(i)
+672        j = self.rngs[i].integers(len(other_walkers))
+673        return other_walkers[j]
+674
+675    def _get_other_walkers(self, i: int) -> list[State]:
+676        mid = self.nwalkers // 2
+677        if i < mid:
+678            return self.mcmc_state[mid:]
+679        else:
+680            return self.mcmc_state[:mid]
+
+ + +

Parallel Affine Invariant MCMC (or Parallel AIES).

+ +
References
+ + +
+ + +
+ +
+ + ParallelAIES( model: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType], executor: concurrent.futures._base.Executor, nwalkers: int = 10, transform: bool = True, rng: numpy.random._generator.Generator = Generator(PCG64) at 0x1058611C0, a: float = 2.0, init_state: Optional[list[dict[str, float | numpy.ndarray]]] = None, **model_data) + + + +
+ + 
604    def __init__(
+605        self,
+606        model: Model,
+607        executor: Executor,
+608        nwalkers: int = 10,
+609        transform: bool = True,
+610        rng: RNG = default_rng(),
+611        a: float = 2.0,
+612        init_state: Optional[list[State]] = None,
+613        **model_data,
+614    ):
+615        if nwalkers < 4 or nwalkers % 2 == 1:
+616            raise ValueError(
+617                "num_walkers needs to be an even integer greater than 3, "
+618                f"but got {nwalkers}!"
+619            )
+620
+621        self.executor = executor
+622        self.model: Model = model
+623        self.nwalkers: int = nwalkers
+624        self.transform: bool = transform
+625        self.rng = rng
+626        self.rngs = self.rng.spawn(self.nwalkers)
+627        self.accept = [0] * nwalkers
+628        if a <= 1:
+629            raise ValueError("Tuning parameter `a` must be larger than 1.")
+630
+631        self.a: float = a
+632        self.model_data = model_data
+633        predictive = TransformedPredictive if transform else Predictive
+634        if init_state is None:
+635            init_state = [
+636                predictive.run(
+637                    model, rng=self.rng, return_cached=False, **model_data
+638                )
+639                for _ in range(self.nwalkers)
+640            ]
+641        self.init_state = init_state
+
+ + + + +
+
+
+ executor + + +
+ + + + +
+
+
+ model: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType] + + +
+ + + + +
+
+
+ nwalkers: int + + +
+ + + + +
+
+
+ transform: bool + + +
+ + + + +
+
+
+ rng + + +
+ + + + +
+
+
+ rngs + + +
+ + + + +
+
+
+ accept + + +
+ + + + +
+
+
+ a: float + + +
+ + + + +
+
+
+ model_data + + +
+ + + + +
+
+
+ init_state + + +
+ + + + +
+
+ +
+ + def + step(self) -> tuple[list[float], list[dict[str, float | numpy.ndarray]]]: + + + +
+ + 
646    def step(self) -> tuple[list[float], list[State]]:
+647        """Update mcmc_state and return list of native_state_and_cache.
+648
+649        Returns
+650        -------
+651        list[float], list[State]
+652            Tuple in which the first element is a list of logprobs, and the
+653            second element is a list of traces (i.e., native state and cache
+654            dictionary).
+655        """
+656        mid = self.nwalkers // 2
+657        out_first_half = list(
+658            self.executor.map(self._update_walker, range(mid))
+659        )
+660        out_second_half = list(
+661            self.executor.map(self._update_walker, range(mid, self.nwalkers))
+662        )
+663        logprob_first_half, trace_first_half = zip(*out_first_half)
+664        logprob_second_half, trace_second_half = zip(*out_second_half)
+665
+666        logprob = logprob_first_half + logprob_second_half
+667        trace = trace_first_half + trace_second_half
+668        return logprob, trace
+
+ + +

Update mcmc_state and return list of native_state_and_cache.

+ +
Returns
+ +
    +
  • list[float], list[State]: Tuple in which the first element is a list of logprobs, and the +second element is a list of traces (i.e., native state and cache +dictionary).
    • +
+
+ + +
+
+
Inherited Members
+
+ + +
+
+
+
+ +
+ + class + ImportanceSampling(InferenceEngine): + + + +
+ + 
683class ImportanceSampling(InferenceEngine):
+684    """Importance Sampling."""
+685
+686    particles: list[State]
+687
+688    def __init__(
+689        self,
+690        model: Model,
+691        rng: Optional[RNG] = None,
+692        particles: Optional[list[State]] = None,
+693        nparticles: Optional[int] = None,
+694        temperature: float = 1.0,
+695        **model_data,
+696    ):
+697        self.model = model
+698        self.model_data = model_data
+699        self.temperature = temperature
+700        self.rng = rng or default_rng()
+701        match nparticles, particles:
+702            case None, None:
+703                raise ValueError(
+704                    "nparticles and particles cannot both be None!"
+705                )
+706            case _, None:
+707                self.nparticles = nparticles
+708                logprobs_and_samples = [
+709                    LogprobAndPriorSample.run(
+710                        model=self.model, rng=self.rng, **self.model_data
+711                    )
+712                    for _ in trange(self.nparticles)
+713                ]
+714                self.logprobs, self.particles = zip(*logprobs_and_samples)
+715            case None, _:
+716                self.particles = particles
+717                self.nparticles = len(particles)
+718                self.logprobs = [
+719                    LogprobAndTrace.run(
+720                        model=self.model, state=particle, **self.model_data
+721                    )[0]
+722                    for particle in tqdm(self.particles)
+723                ]
+724            case _:
+725                raise ValueError(
+726                    "nparticles and particles cannot both be specified!"
+727                )
+728
+729        self.log_weights = log_softmax(self.logprobs)
+730        self.weights = softmax(self.logprobs)
+731        # self.ess = ess_kish(self.weights)
+732
+733    def fit(self, nsamples: int) -> Chain:
+734        """Sample."""
+735        indices = self.rng.choice(self.nparticles, nsamples, p=self.weights)
+736        return Chain(self.particles[i] for i in indices)
+
+ + +

Importance Sampling.

+
+ + +
+ +
+ + ImportanceSampling( model: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType], rng: Optional[numpy.random._generator.Generator] = None, particles: Optional[list[dict[str, float | numpy.ndarray]]] = None, nparticles: Optional[int] = None, temperature: float = 1.0, **model_data) + + + +
+ + 
688    def __init__(
+689        self,
+690        model: Model,
+691        rng: Optional[RNG] = None,
+692        particles: Optional[list[State]] = None,
+693        nparticles: Optional[int] = None,
+694        temperature: float = 1.0,
+695        **model_data,
+696    ):
+697        self.model = model
+698        self.model_data = model_data
+699        self.temperature = temperature
+700        self.rng = rng or default_rng()
+701        match nparticles, particles:
+702            case None, None:
+703                raise ValueError(
+704                    "nparticles and particles cannot both be None!"
+705                )
+706            case _, None:
+707                self.nparticles = nparticles
+708                logprobs_and_samples = [
+709                    LogprobAndPriorSample.run(
+710                        model=self.model, rng=self.rng, **self.model_data
+711                    )
+712                    for _ in trange(self.nparticles)
+713                ]
+714                self.logprobs, self.particles = zip(*logprobs_and_samples)
+715            case None, _:
+716                self.particles = particles
+717                self.nparticles = len(particles)
+718                self.logprobs = [
+719                    LogprobAndTrace.run(
+720                        model=self.model, state=particle, **self.model_data
+721                    )[0]
+722                    for particle in tqdm(self.particles)
+723                ]
+724            case _:
+725                raise ValueError(
+726                    "nparticles and particles cannot both be specified!"
+727                )
+728
+729        self.log_weights = log_softmax(self.logprobs)
+730        self.weights = softmax(self.logprobs)
+731        # self.ess = ess_kish(self.weights)
+
+ + + + +
+
+
+ particles: list[dict[str, float | numpy.ndarray]] + + +
+ + + + +
+
+
+ model + + +
+ + + + +
+
+
+ model_data + + +
+ + + + +
+
+
+ temperature + + +
+ + + + +
+
+
+ rng + + +
+ + + + +
+
+
+ log_weights + + +
+ + + + +
+
+
+ weights + + +
+ + + + +
+
+ +
+ + def + fit(self, nsamples: int) -> Chain: + + + +
+ + 
733    def fit(self, nsamples: int) -> Chain:
+734        """Sample."""
+735        indices = self.rng.choice(self.nparticles, nsamples, p=self.weights)
+736        return Chain(self.particles[i] for i in indices)
+
+ + +

Sample.

+
+ + +
+
+
+ +
+ + class + LaplaceApproximation(InferenceEngine): + + + +
+ + 
739class LaplaceApproximation(InferenceEngine):
+740    """Laplace Approximation of Posterior."""
+741
+742    rng: RNG
+743
+744    def __init__(
+745        self,
+746        model: Model,
+747        transform: bool = True,
+748        rng: Optional[RNG] = None,
+749        **model_data,
+750    ):
+751        self.model = model
+752        self.model_data = model_data
+753        self.rng = rng or default_rng()
+754        self.transform = transform
+755
+756        if self.transform:
+757            self.init_state = TransformedPredictive.run(
+758                model, rng=rng, return_cached=False, **self.model_data
+759            )
+760        else:
+761            self.init_state = Predictive.run(
+762                model, rng=rng, return_cached=False, **self.model_data
+763            )
+764
+765        self.shaper = Shaper.from_state(self.init_state)
+766        self.init_vec_state = self.shaper.vec(self.init_state)
+767
+768    def logprob(self, vec_state: np.ndarray) -> float:
+769        """Compute log density.
+770
+771        Parameters
+772        ----------
+773        state : State
+774            Dictionary containing random variables to model.
+775
+776        Returns
+777        -------
+778        tuple[float, State]
+779            (Log density (float), native state and cached values (dict))
+780        """
+781        state = self.shaper.unvec(vec_state)
+782        if self.transform:
+783            # state is real.
+784            # Returns logprob + log_det_jacobian, native_state.
+785            return TransformedLogprobAndTrace.run(
+786                self.model, state, **self.model_data
+787            )[0]
+788        else:
+789            # state is native.
+790            # Returns logprob, state (which is already native).
+791            return LogprobAndTrace.run(self.model, state, **self.model_data)[0]
+792
+793    def _negative_logprob(self, vec_state) -> float:
+794        return -self.logprob(vec_state)
+795
+796    def fit(self, nsamples: int, **minimize_kwargs):
+797        """Fit model with laplace approx."""
+798        self.result = minimize(
+799            self._negative_logprob, x0=self.init_vec_state, **minimize_kwargs
+800        )
+801        mean = self.result.x
+802        cov = self.result.hess_inv
+803        samples = MvNormal(mean, cov).sample((nsamples,), rng=self.rng)
+804
+805        # Return native state and cache.
+806        if self.transform:
+807            return Chain(
+808                TransformedLogprobAndTrace.run(
+809                    self.model,
+810                    self.shaper.unvec(vec_state),
+811                    **self.model_data,
+812                )[1]
+813                for vec_state in samples
+814            )
+815        else:
+816            return Chain(
+817                Predictive.run(
+818                    self.model,
+819                    self.shaper.unvec(vec_state),
+820                    return_cached=True,
+821                    **self.model_data,
+822                )
+823                for vec_state in samples
+824            )
+
+ + +

Laplace Approximation of Posterior.

+
+ + +
+ +
+ + LaplaceApproximation( model: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType], transform: bool = True, rng: Optional[numpy.random._generator.Generator] = None, **model_data) + + + +
+ + 
744    def __init__(
+745        self,
+746        model: Model,
+747        transform: bool = True,
+748        rng: Optional[RNG] = None,
+749        **model_data,
+750    ):
+751        self.model = model
+752        self.model_data = model_data
+753        self.rng = rng or default_rng()
+754        self.transform = transform
+755
+756        if self.transform:
+757            self.init_state = TransformedPredictive.run(
+758                model, rng=rng, return_cached=False, **self.model_data
+759            )
+760        else:
+761            self.init_state = Predictive.run(
+762                model, rng=rng, return_cached=False, **self.model_data
+763            )
+764
+765        self.shaper = Shaper.from_state(self.init_state)
+766        self.init_vec_state = self.shaper.vec(self.init_state)
+
+ + + + +
+
+
+ rng: numpy.random._generator.Generator + + +
+ + + + +
+
+
+ model + + +
+ + + + +
+
+
+ model_data + + +
+ + + + +
+
+
+ transform + + +
+ + + + +
+
+
+ shaper + + +
+ + + + +
+
+
+ init_vec_state + + +
+ + + + +
+
+ +
+ + def + logprob(self, vec_state: numpy.ndarray) -> float: + + + +
+ + 
768    def logprob(self, vec_state: np.ndarray) -> float:
+769        """Compute log density.
+770
+771        Parameters
+772        ----------
+773        state : State
+774            Dictionary containing random variables to model.
+775
+776        Returns
+777        -------
+778        tuple[float, State]
+779            (Log density (float), native state and cached values (dict))
+780        """
+781        state = self.shaper.unvec(vec_state)
+782        if self.transform:
+783            # state is real.
+784            # Returns logprob + log_det_jacobian, native_state.
+785            return TransformedLogprobAndTrace.run(
+786                self.model, state, **self.model_data
+787            )[0]
+788        else:
+789            # state is native.
+790            # Returns logprob, state (which is already native).
+791            return LogprobAndTrace.run(self.model, state, **self.model_data)[0]
+
+ + +

Compute log density.

+ +
Parameters
+ +
    +
  • state (State): +Dictionary containing random variables to model.
    • +
+ +
Returns
+ +
    +
  • tuple[float, State]: (Log density (float), native state and cached values (dict))
    • +
+
+ + +
+
+ +
+ + def + fit(self, nsamples: int, **minimize_kwargs): + + + +
+ + 
796    def fit(self, nsamples: int, **minimize_kwargs):
+797        """Fit model with laplace approx."""
+798        self.result = minimize(
+799            self._negative_logprob, x0=self.init_vec_state, **minimize_kwargs
+800        )
+801        mean = self.result.x
+802        cov = self.result.hess_inv
+803        samples = MvNormal(mean, cov).sample((nsamples,), rng=self.rng)
+804
+805        # Return native state and cache.
+806        if self.transform:
+807            return Chain(
+808                TransformedLogprobAndTrace.run(
+809                    self.model,
+810                    self.shaper.unvec(vec_state),
+811                    **self.model_data,
+812                )[1]
+813                for vec_state in samples
+814            )
+815        else:
+816            return Chain(
+817                Predictive.run(
+818                    self.model,
+819                    self.shaper.unvec(vec_state),
+820                    return_cached=True,
+821                    **self.model_data,
+822                )
+823                for vec_state in samples
+824            )
+
+ + +

Fit model with laplace approx.

+
+ + +
+
+
+ +
+ + class + BayesianOptimization(InferenceEngine): + + + +
+ + 
827class BayesianOptimization(InferenceEngine):
+828    """Bayesian Optimization."""
+829
+830    ...
+
+ + +

Bayesian Optimization.

+
+ + +
+
Inherited Members
+
+ +
+
+
+
+ +
+ + class + AdaptiveRandomWalkMetropolis(SingleWalkerMCMC): + + + +
+ + 
833class AdaptiveRandomWalkMetropolis(SingleWalkerMCMC):
+834    """Adaptive Random Walk Metropolis.
+835
+836    Resources
+837    ---------
+838    - https://probability.ca/jeff/ftpdir/adaptex.pdf
+839    """
+840
+841    ...
+
+ + +

Adaptive Random Walk Metropolis.

+ +
Resources
+ + +
+ + +
+
Inherited Members
+
+ + + +
+
+
+
+ + \ No newline at end of file diff --git a/docs/arianna/ppl/shaper.html b/docs/arianna/ppl/shaper.html new file mode 100644 index 0000000..45594fa --- /dev/null +++ b/docs/arianna/ppl/shaper.html @@ -0,0 +1,491 @@ + + + + + + + arianna.ppl.shaper API documentation + + + + + + + + + + + + +
+
+

+arianna.ppl.shaper

+ + + + + + + 
 1import numpy as np
+ 2
+ 3from arianna.types import State
+ 4
+ 5
+ 6class Shaper:
+ 7    """Shapes dict of numeric values into np.array and back."""
+ 8
+ 9    @classmethod
+10    def from_state(cls, state: State):
+11        """Construct a Shaper from a state."""
+12        return cls({name: np.shape(value) for name, value in state.items()})
+13
+14    def __init__(self, shape: dict[str, tuple[int, ...]]):
+15        self.shape = shape
+16        self.dim = int(sum(np.prod(s) for s in self.shape.values()))
+17
+18    def vec(self, state: State) -> np.ndarray:
+19        """Convert a state dict into a np.ndarray."""
+20        flat_state = []
+21        for _, value in state.items():
+22            value = np.array(value)
+23            flat_state.extend(value.flatten())
+24        return np.array(flat_state)
+25
+26    def unvec(self, flat_state: np.ndarray) -> State:
+27        """Convert a np.ndarray back to a state dict."""
+28        state = {}
+29        start = 0
+30        for name, shapes in self.shape.items():
+31            num_elems = int(np.prod(shapes))
+32            value = np.reshape(flat_state[start : start + num_elems], shapes)
+33            state[name] = value
+34            start += num_elems
+35        return state
+
+ + +
+
+ +
+ + class + Shaper: + + + +
+ + 
 7class Shaper:
+ 8    """Shapes dict of numeric values into np.array and back."""
+ 9
+10    @classmethod
+11    def from_state(cls, state: State):
+12        """Construct a Shaper from a state."""
+13        return cls({name: np.shape(value) for name, value in state.items()})
+14
+15    def __init__(self, shape: dict[str, tuple[int, ...]]):
+16        self.shape = shape
+17        self.dim = int(sum(np.prod(s) for s in self.shape.values()))
+18
+19    def vec(self, state: State) -> np.ndarray:
+20        """Convert a state dict into a np.ndarray."""
+21        flat_state = []
+22        for _, value in state.items():
+23            value = np.array(value)
+24            flat_state.extend(value.flatten())
+25        return np.array(flat_state)
+26
+27    def unvec(self, flat_state: np.ndarray) -> State:
+28        """Convert a np.ndarray back to a state dict."""
+29        state = {}
+30        start = 0
+31        for name, shapes in self.shape.items():
+32            num_elems = int(np.prod(shapes))
+33            value = np.reshape(flat_state[start : start + num_elems], shapes)
+34            state[name] = value
+35            start += num_elems
+36        return state
+
+ + +

Shapes dict of numeric values into np.array and back.

+
+ + +
+ +
+ + Shaper(shape: dict[str, tuple[int, ...]]) + + + +
+ + 
15    def __init__(self, shape: dict[str, tuple[int, ...]]):
+16        self.shape = shape
+17        self.dim = int(sum(np.prod(s) for s in self.shape.values()))
+
+ + + + +
+
+ +
+
@classmethod
+ + def + from_state(cls, state: dict[str, float | numpy.ndarray]): + + + +
+ + 
10    @classmethod
+11    def from_state(cls, state: State):
+12        """Construct a Shaper from a state."""
+13        return cls({name: np.shape(value) for name, value in state.items()})
+
+ + +

Construct a Shaper from a state.

+
+ + +
+
+
+ shape + + +
+ + + + +
+
+
+ dim + + +
+ + + + +
+
+ +
+ + def + vec(self, state: dict[str, float | numpy.ndarray]) -> numpy.ndarray: + + + +
+ + 
19    def vec(self, state: State) -> np.ndarray:
+20        """Convert a state dict into a np.ndarray."""
+21        flat_state = []
+22        for _, value in state.items():
+23            value = np.array(value)
+24            flat_state.extend(value.flatten())
+25        return np.array(flat_state)
+
+ + +

Convert a state dict into a np.ndarray.

+
+ + +
+
+ +
+ + def + unvec(self, flat_state: numpy.ndarray) -> dict[str, float | numpy.ndarray]: + + + +
+ + 
27    def unvec(self, flat_state: np.ndarray) -> State:
+28        """Convert a np.ndarray back to a state dict."""
+29        state = {}
+30        start = 0
+31        for name, shapes in self.shape.items():
+32            num_elems = int(np.prod(shapes))
+33            value = np.reshape(flat_state[start : start + num_elems], shapes)
+34            state[name] = value
+35            start += num_elems
+36        return state
+
+ + +

Convert a np.ndarray back to a state dict.

+
+ + +
+
+
+ + \ No newline at end of file diff --git a/docs/arianna/types.html b/docs/arianna/types.html new file mode 100644 index 0000000..407bb47 --- /dev/null +++ b/docs/arianna/types.html @@ -0,0 +1,402 @@ + + + + + + + arianna.types API documentation + + + + + + + + + + + + +
+
+

+arianna.types

+ + + + + + + 
 1from numpy import ndarray
+ 2
+ 3Numeric = float | ndarray
+ 4Shape = tuple[int, ...]
+ 5State = dict[str, Numeric]
+ 6
+ 7
+ 8class NegativeInfinityError(Exception):
+ 9    pass
+10
+11
+12class NegativeParameterError(Exception): ...
+13
+14
+15class InvalidBoundsError(Exception): ...
+
+ + +
+
+
+ Numeric = +float | numpy.ndarray + + +
+ + + + +
+
+
+ Shape = +tuple[int, ...] + + +
+ + + + +
+
+
+ State = +dict[str, float | numpy.ndarray] + + +
+ + + + +
+
+ +
+ + class + NegativeInfinityError(builtins.Exception): + + + +
+ + 
 9class NegativeInfinityError(Exception):
+10    pass
+
+ + +

Common base class for all non-exit exceptions.

+
+ + +
+
+ +
+ + class + NegativeParameterError(builtins.Exception): + + + +
+ + 
13class NegativeParameterError(Exception): ...
+
+ + +

Common base class for all non-exit exceptions.

+
+ + +
+
+ +
+ + class + InvalidBoundsError(builtins.Exception): + + + +
+ + 
16class InvalidBoundsError(Exception): ...
+
+ + +

Common base class for all non-exit exceptions.

+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/index.html b/docs/index.html new file mode 100644 index 0000000..3495c30 --- /dev/null +++ b/docs/index.html @@ -0,0 +1,7 @@ + + + + + + + diff --git a/docs/search.js b/docs/search.js new file mode 100644 index 0000000..2efa26d --- /dev/null +++ b/docs/search.js @@ -0,0 +1,46 @@ +window.pdocSearch = (function(){ +/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();o

\n"}, "arianna.distributions": {"fullname": "arianna.distributions", "modulename": "arianna.distributions", "kind": "module", "doc": "

\n"}, "arianna.distributions.abstract": {"fullname": "arianna.distributions.abstract", "modulename": "arianna.distributions.abstract", "kind": "module", "doc": "

\n"}, "arianna.distributions.abstract.Distribution": {"fullname": "arianna.distributions.abstract.Distribution", "modulename": "arianna.distributions.abstract", "qualname": "Distribution", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "abc.ABC"}, "arianna.distributions.abstract.Distribution.event_shape": {"fullname": "arianna.distributions.abstract.Distribution.event_shape", "modulename": "arianna.distributions.abstract", "qualname": "Distribution.event_shape", "kind": "variable", "doc": "

\n"}, "arianna.distributions.abstract.Distribution.batch_shape": {"fullname": "arianna.distributions.abstract.Distribution.batch_shape", "modulename": "arianna.distributions.abstract", "qualname": "Distribution.batch_shape", "kind": "variable", "doc": "

\n"}, "arianna.distributions.abstract.Distribution.logpdf": {"fullname": "arianna.distributions.abstract.Distribution.logpdf", "modulename": "arianna.distributions.abstract", "qualname": "Distribution.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Distribution.sample": {"fullname": "arianna.distributions.abstract.Distribution.sample", "modulename": "arianna.distributions.abstract", "qualname": "Distribution.sample", "kind": "function", "doc": "

\n", "signature": "(\tself,\tsample_shape: tuple[int, ...] = (),\trng: numpy.random._generator.Generator = Generator(PCG64) at 0x103F8E960) -> numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Distribution.pdf": {"fullname": "arianna.distributions.abstract.Distribution.pdf", "modulename": "arianna.distributions.abstract", "qualname": "Distribution.pdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Distribution.mean": {"fullname": "arianna.distributions.abstract.Distribution.mean", "modulename": "arianna.distributions.abstract", "qualname": "Distribution.mean", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.abstract.Distribution.std": {"fullname": "arianna.distributions.abstract.Distribution.std", "modulename": "arianna.distributions.abstract", "qualname": "Distribution.std", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.abstract.Distribution.var": {"fullname": "arianna.distributions.abstract.Distribution.var", "modulename": "arianna.distributions.abstract", "qualname": "Distribution.var", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.abstract.Continuous": {"fullname": "arianna.distributions.abstract.Continuous", "modulename": "arianna.distributions.abstract", "qualname": "Continuous", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Distribution"}, "arianna.distributions.abstract.Continuous.to_real": {"fullname": "arianna.distributions.abstract.Continuous.to_real", "modulename": "arianna.distributions.abstract", "qualname": "Continuous.to_real", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Continuous.to_native": {"fullname": "arianna.distributions.abstract.Continuous.to_native", "modulename": "arianna.distributions.abstract", "qualname": "Continuous.to_native", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Continuous.logdetjac": {"fullname": "arianna.distributions.abstract.Continuous.logdetjac", "modulename": "arianna.distributions.abstract", "qualname": "Continuous.logdetjac", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Discrete": {"fullname": "arianna.distributions.abstract.Discrete", "modulename": "arianna.distributions.abstract", "qualname": "Discrete", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Distribution"}, "arianna.distributions.abstract.Multivariate": {"fullname": "arianna.distributions.abstract.Multivariate", "modulename": "arianna.distributions.abstract", "qualname": "Multivariate", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Distribution"}, "arianna.distributions.abstract.Multivariate.mean": {"fullname": "arianna.distributions.abstract.Multivariate.mean", "modulename": "arianna.distributions.abstract", "qualname": "Multivariate.mean", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.abstract.Multivariate.std": {"fullname": "arianna.distributions.abstract.Multivariate.std", "modulename": "arianna.distributions.abstract", "qualname": "Multivariate.std", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.abstract.Multivariate.var": {"fullname": "arianna.distributions.abstract.Multivariate.var", "modulename": "arianna.distributions.abstract", "qualname": "Multivariate.var", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.abstract.Univariate": {"fullname": "arianna.distributions.abstract.Univariate", "modulename": "arianna.distributions.abstract", "qualname": "Univariate", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Distribution"}, "arianna.distributions.abstract.Univariate.event_shape": {"fullname": "arianna.distributions.abstract.Univariate.event_shape", "modulename": "arianna.distributions.abstract", "qualname": "Univariate.event_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.abstract.Univariate.batch_shape": {"fullname": "arianna.distributions.abstract.Univariate.batch_shape", "modulename": "arianna.distributions.abstract", "qualname": "Univariate.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.abstract.Univariate.sample": {"fullname": "arianna.distributions.abstract.Univariate.sample", "modulename": "arianna.distributions.abstract", "qualname": "Univariate.sample", "kind": "function", "doc": "

\n", "signature": "(\tself,\tsample_shape: tuple[int, ...] = (),\trng: numpy.random._generator.Generator = Generator(PCG64) at 0x103F8EDC0) -> numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.UnivariateContinuous": {"fullname": "arianna.distributions.abstract.UnivariateContinuous", "modulename": "arianna.distributions.abstract", "qualname": "UnivariateContinuous", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Univariate, Continuous"}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"fullname": "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac", "modulename": "arianna.distributions.abstract", "qualname": "UnivariateContinuous.logpdf_plus_logdetjac", "kind": "function", "doc": "

Logpdf plus the log absolute determinant of the jacobian.

\n\n

Logpdf plus the log absolute determinant of the jacobian, evaluated at\nparameter on the transformed (real) space.

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"fullname": "arianna.distributions.abstract.UnivariateContinuous.logcdf", "modulename": "arianna.distributions.abstract", "qualname": "UnivariateContinuous.logcdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"fullname": "arianna.distributions.abstract.UnivariateContinuous.cdf", "modulename": "arianna.distributions.abstract", "qualname": "UnivariateContinuous.cdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"fullname": "arianna.distributions.abstract.UnivariateContinuous.survival", "modulename": "arianna.distributions.abstract", "qualname": "UnivariateContinuous.survival", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"fullname": "arianna.distributions.abstract.UnivariateContinuous.logsurvival", "modulename": "arianna.distributions.abstract", "qualname": "UnivariateContinuous.logsurvival", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Positive": {"fullname": "arianna.distributions.abstract.Positive", "modulename": "arianna.distributions.abstract", "qualname": "Positive", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "UnivariateContinuous"}, "arianna.distributions.abstract.Positive.to_real": {"fullname": "arianna.distributions.abstract.Positive.to_real", "modulename": "arianna.distributions.abstract", "qualname": "Positive.to_real", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Positive.to_native": {"fullname": "arianna.distributions.abstract.Positive.to_native", "modulename": "arianna.distributions.abstract", "qualname": "Positive.to_native", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Positive.logdetjac": {"fullname": "arianna.distributions.abstract.Positive.logdetjac", "modulename": "arianna.distributions.abstract", "qualname": "Positive.logdetjac", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Positive.logpdf": {"fullname": "arianna.distributions.abstract.Positive.logpdf", "modulename": "arianna.distributions.abstract", "qualname": "Positive.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.LowerUpperBounded": {"fullname": "arianna.distributions.abstract.LowerUpperBounded", "modulename": "arianna.distributions.abstract", "qualname": "LowerUpperBounded", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "UnivariateContinuous, abc.ABC"}, "arianna.distributions.abstract.LowerUpperBounded.lower": {"fullname": "arianna.distributions.abstract.LowerUpperBounded.lower", "modulename": "arianna.distributions.abstract", "qualname": "LowerUpperBounded.lower", "kind": "variable", "doc": "

\n"}, "arianna.distributions.abstract.LowerUpperBounded.upper": {"fullname": "arianna.distributions.abstract.LowerUpperBounded.upper", "modulename": "arianna.distributions.abstract", "qualname": "LowerUpperBounded.upper", "kind": "variable", "doc": "

\n"}, "arianna.distributions.abstract.LowerUpperBounded.range": {"fullname": "arianna.distributions.abstract.LowerUpperBounded.range", "modulename": "arianna.distributions.abstract", "qualname": "LowerUpperBounded.range", "kind": "variable", "doc": "

\n"}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"fullname": "arianna.distributions.abstract.LowerUpperBounded.to_real", "modulename": "arianna.distributions.abstract", "qualname": "LowerUpperBounded.to_real", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"fullname": "arianna.distributions.abstract.LowerUpperBounded.to_native", "modulename": "arianna.distributions.abstract", "qualname": "LowerUpperBounded.to_native", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"fullname": "arianna.distributions.abstract.LowerUpperBounded.logdetjac", "modulename": "arianna.distributions.abstract", "qualname": "LowerUpperBounded.logdetjac", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"fullname": "arianna.distributions.abstract.LowerUpperBounded.logpdf", "modulename": "arianna.distributions.abstract", "qualname": "LowerUpperBounded.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.MultivariateContinuous": {"fullname": "arianna.distributions.abstract.MultivariateContinuous", "modulename": "arianna.distributions.abstract", "qualname": "MultivariateContinuous", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Multivariate, Continuous"}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"fullname": "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac", "modulename": "arianna.distributions.abstract", "qualname": "MultivariateContinuous.logpdf_plus_logdetjac", "kind": "function", "doc": "

Logpdf plus the log absolute determinant of the jacobian.

\n\n

Logpdf plus the log absolute determinant of the jacobian, evaluated at\nparameter on the transformed (real) space.

\n", "signature": "(self, z: numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"fullname": "arianna.distributions.abstract.MultivariateContinuous.cov", "modulename": "arianna.distributions.abstract", "qualname": "MultivariateContinuous.cov", "kind": "function", "doc": "

\n", "signature": "(self) -> numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"fullname": "arianna.distributions.abstract.MultivariateContinuous.mean", "modulename": "arianna.distributions.abstract", "qualname": "MultivariateContinuous.mean", "kind": "function", "doc": "

\n", "signature": "(self) -> numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Real": {"fullname": "arianna.distributions.abstract.Real", "modulename": "arianna.distributions.abstract", "qualname": "Real", "kind": "class", "doc": "

\n"}, "arianna.distributions.abstract.Real.to_real": {"fullname": "arianna.distributions.abstract.Real.to_real", "modulename": "arianna.distributions.abstract", "qualname": "Real.to_real", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Real.to_native": {"fullname": "arianna.distributions.abstract.Real.to_native", "modulename": "arianna.distributions.abstract", "qualname": "Real.to_native", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.Real.logdetjac": {"fullname": "arianna.distributions.abstract.Real.logdetjac", "modulename": "arianna.distributions.abstract", "qualname": "Real.logdetjac", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.abstract.UnivariateReal": {"fullname": "arianna.distributions.abstract.UnivariateReal", "modulename": "arianna.distributions.abstract", "qualname": "UnivariateReal", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Real, UnivariateContinuous"}, "arianna.distributions.abstract.MultivariateReal": {"fullname": "arianna.distributions.abstract.MultivariateReal", "modulename": "arianna.distributions.abstract", "qualname": "MultivariateReal", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Real, MultivariateContinuous"}, "arianna.distributions.distributions": {"fullname": "arianna.distributions.distributions", "modulename": "arianna.distributions.distributions", "kind": "module", "doc": "

\n"}, "arianna.distributions.distributions.IndependentRagged": {"fullname": "arianna.distributions.distributions.IndependentRagged", "modulename": "arianna.distributions.distributions", "qualname": "IndependentRagged", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.Distribution"}, "arianna.distributions.distributions.Independent": {"fullname": "arianna.distributions.distributions.Independent", "modulename": "arianna.distributions.distributions", "qualname": "Independent", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.Distribution"}, "arianna.distributions.distributions.Independent.__init__": {"fullname": "arianna.distributions.distributions.Independent.__init__", "modulename": "arianna.distributions.distributions", "qualname": "Independent.__init__", "kind": "function", "doc": "

\n", "signature": "(dists: list[arianna.distributions.abstract.Distribution])"}, "arianna.distributions.distributions.Independent.dists": {"fullname": "arianna.distributions.distributions.Independent.dists", "modulename": "arianna.distributions.distributions", "qualname": "Independent.dists", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Independent.is_same_family": {"fullname": "arianna.distributions.distributions.Independent.is_same_family", "modulename": "arianna.distributions.distributions", "qualname": "Independent.is_same_family", "kind": "function", "doc": "

\n", "signature": "(self, dists: list[arianna.distributions.abstract.Distribution]) -> bool:", "funcdef": "def"}, "arianna.distributions.distributions.Independent.logpdf": {"fullname": "arianna.distributions.distributions.Independent.logpdf", "modulename": "arianna.distributions.distributions", "qualname": "Independent.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x: list[float | numpy.ndarray]) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Independent.sample": {"fullname": "arianna.distributions.distributions.Independent.sample", "modulename": "arianna.distributions.distributions", "qualname": "Independent.sample", "kind": "function", "doc": "

\n", "signature": "(self, sample_shape=[]) -> numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Uniform": {"fullname": "arianna.distributions.distributions.Uniform", "modulename": "arianna.distributions.distributions", "qualname": "Uniform", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.LowerUpperBounded"}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"fullname": "arianna.distributions.distributions.Uniform.from_mean_shift", "modulename": "arianna.distributions.distributions", "qualname": "Uniform.from_mean_shift", "kind": "function", "doc": "

\n", "signature": "(cls, mean, shift):", "funcdef": "def"}, "arianna.distributions.distributions.Uniform.batch_shape": {"fullname": "arianna.distributions.distributions.Uniform.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "Uniform.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.Uniform.logcdf": {"fullname": "arianna.distributions.distributions.Uniform.logcdf", "modulename": "arianna.distributions.distributions", "qualname": "Uniform.logcdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Uniform.cdf": {"fullname": "arianna.distributions.distributions.Uniform.cdf", "modulename": "arianna.distributions.distributions", "qualname": "Uniform.cdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Uniform.mode": {"fullname": "arianna.distributions.distributions.Uniform.mode", "modulename": "arianna.distributions.distributions", "qualname": "Uniform.mode", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Uniform.median": {"fullname": "arianna.distributions.distributions.Uniform.median", "modulename": "arianna.distributions.distributions", "qualname": "Uniform.median", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Uniform.mean": {"fullname": "arianna.distributions.distributions.Uniform.mean", "modulename": "arianna.distributions.distributions", "qualname": "Uniform.mean", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Uniform.var": {"fullname": "arianna.distributions.distributions.Uniform.var", "modulename": "arianna.distributions.distributions", "qualname": "Uniform.var", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Beta": {"fullname": "arianna.distributions.distributions.Beta", "modulename": "arianna.distributions.distributions", "qualname": "Beta", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.LowerUpperBounded"}, "arianna.distributions.distributions.Beta.__init__": {"fullname": "arianna.distributions.distributions.Beta.__init__", "modulename": "arianna.distributions.distributions", "qualname": "Beta.__init__", "kind": "function", "doc": "

\n", "signature": "(\ta: float | numpy.ndarray,\tb: float | numpy.ndarray,\tcheck: bool = True)"}, "arianna.distributions.distributions.Beta.a": {"fullname": "arianna.distributions.distributions.Beta.a", "modulename": "arianna.distributions.distributions", "qualname": "Beta.a", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Beta.b": {"fullname": "arianna.distributions.distributions.Beta.b", "modulename": "arianna.distributions.distributions", "qualname": "Beta.b", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Beta.mode": {"fullname": "arianna.distributions.distributions.Beta.mode", "modulename": "arianna.distributions.distributions", "qualname": "Beta.mode", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Beta.batch_shape": {"fullname": "arianna.distributions.distributions.Beta.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "Beta.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.Beta.logcdf": {"fullname": "arianna.distributions.distributions.Beta.logcdf", "modulename": "arianna.distributions.distributions", "qualname": "Beta.logcdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Beta.cdf": {"fullname": "arianna.distributions.distributions.Beta.cdf", "modulename": "arianna.distributions.distributions", "qualname": "Beta.cdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Beta.mean": {"fullname": "arianna.distributions.distributions.Beta.mean", "modulename": "arianna.distributions.distributions", "qualname": "Beta.mean", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Beta.var": {"fullname": "arianna.distributions.distributions.Beta.var", "modulename": "arianna.distributions.distributions", "qualname": "Beta.var", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.ScaledBeta": {"fullname": "arianna.distributions.distributions.ScaledBeta", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.LowerUpperBounded"}, "arianna.distributions.distributions.ScaledBeta.__init__": {"fullname": "arianna.distributions.distributions.ScaledBeta.__init__", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.__init__", "kind": "function", "doc": "

\n", "signature": "(\ta: float | numpy.ndarray,\tb: float | numpy.ndarray,\tlower: float | numpy.ndarray,\tupper: float | numpy.ndarray,\tcheck: bool = True)"}, "arianna.distributions.distributions.ScaledBeta.a": {"fullname": "arianna.distributions.distributions.ScaledBeta.a", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.a", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.ScaledBeta.b": {"fullname": "arianna.distributions.distributions.ScaledBeta.b", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.b", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.ScaledBeta.base_dist": {"fullname": "arianna.distributions.distributions.ScaledBeta.base_dist", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.base_dist", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"fullname": "arianna.distributions.distributions.ScaledBeta.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.ScaledBeta.cdf": {"fullname": "arianna.distributions.distributions.ScaledBeta.cdf", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.cdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"fullname": "arianna.distributions.distributions.ScaledBeta.logcdf", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.logcdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.ScaledBeta.mean": {"fullname": "arianna.distributions.distributions.ScaledBeta.mean", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.mean", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.ScaledBeta.var": {"fullname": "arianna.distributions.distributions.ScaledBeta.var", "modulename": "arianna.distributions.distributions", "qualname": "ScaledBeta.var", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Gamma": {"fullname": "arianna.distributions.distributions.Gamma", "modulename": "arianna.distributions.distributions", "qualname": "Gamma", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.Positive"}, "arianna.distributions.distributions.Gamma.__init__": {"fullname": "arianna.distributions.distributions.Gamma.__init__", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.__init__", "kind": "function", "doc": "

\n", "signature": "(\tshape: float | numpy.ndarray,\tscale: float | numpy.ndarray,\tcheck: bool = True)"}, "arianna.distributions.distributions.Gamma.from_mean_std": {"fullname": "arianna.distributions.distributions.Gamma.from_mean_std", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.from_mean_std", "kind": "function", "doc": "

\n", "signature": "(cls, mean, std, check: bool = True):", "funcdef": "def"}, "arianna.distributions.distributions.Gamma.shape": {"fullname": "arianna.distributions.distributions.Gamma.shape", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.shape", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Gamma.scale": {"fullname": "arianna.distributions.distributions.Gamma.scale", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.scale", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Gamma.batch_shape": {"fullname": "arianna.distributions.distributions.Gamma.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.Gamma.logcdf": {"fullname": "arianna.distributions.distributions.Gamma.logcdf", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.logcdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Gamma.cdf": {"fullname": "arianna.distributions.distributions.Gamma.cdf", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.cdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Gamma.survival": {"fullname": "arianna.distributions.distributions.Gamma.survival", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.survival", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Gamma.mean": {"fullname": "arianna.distributions.distributions.Gamma.mean", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.mean", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Gamma.var": {"fullname": "arianna.distributions.distributions.Gamma.var", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.var", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Gamma.mode": {"fullname": "arianna.distributions.distributions.Gamma.mode", "modulename": "arianna.distributions.distributions", "qualname": "Gamma.mode", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.InverseGamma": {"fullname": "arianna.distributions.distributions.InverseGamma", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.Positive"}, "arianna.distributions.distributions.InverseGamma.__init__": {"fullname": "arianna.distributions.distributions.InverseGamma.__init__", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.__init__", "kind": "function", "doc": "

\n", "signature": "(\tshape: float | numpy.ndarray,\tscale: float | numpy.ndarray,\tcheck: bool = True)"}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"fullname": "arianna.distributions.distributions.InverseGamma.from_mean_std", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.from_mean_std", "kind": "function", "doc": "

\n", "signature": "(cls, mean, std, check: bool = True):", "funcdef": "def"}, "arianna.distributions.distributions.InverseGamma.shape": {"fullname": "arianna.distributions.distributions.InverseGamma.shape", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.shape", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.InverseGamma.scale": {"fullname": "arianna.distributions.distributions.InverseGamma.scale", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.scale", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"fullname": "arianna.distributions.distributions.InverseGamma.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.InverseGamma.mean": {"fullname": "arianna.distributions.distributions.InverseGamma.mean", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.mean", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.InverseGamma.var": {"fullname": "arianna.distributions.distributions.InverseGamma.var", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.var", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.InverseGamma.mode": {"fullname": "arianna.distributions.distributions.InverseGamma.mode", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.mode", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.InverseGamma.logcdf": {"fullname": "arianna.distributions.distributions.InverseGamma.logcdf", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.logcdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.InverseGamma.cdf": {"fullname": "arianna.distributions.distributions.InverseGamma.cdf", "modulename": "arianna.distributions.distributions", "qualname": "InverseGamma.cdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.LogNormal": {"fullname": "arianna.distributions.distributions.LogNormal", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.Positive"}, "arianna.distributions.distributions.LogNormal.__init__": {"fullname": "arianna.distributions.distributions.LogNormal.__init__", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.__init__", "kind": "function", "doc": "

\n", "signature": "(\tmu: float | numpy.ndarray,\tsigma: float | numpy.ndarray,\tcheck: bool = True)"}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"fullname": "arianna.distributions.distributions.LogNormal.from_mean_std", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.from_mean_std", "kind": "function", "doc": "

\n", "signature": "(cls, mean, std, check: bool = True):", "funcdef": "def"}, "arianna.distributions.distributions.LogNormal.mu": {"fullname": "arianna.distributions.distributions.LogNormal.mu", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.mu", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.LogNormal.sigma": {"fullname": "arianna.distributions.distributions.LogNormal.sigma", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.sigma", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.LogNormal.batch_shape": {"fullname": "arianna.distributions.distributions.LogNormal.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.LogNormal.mean": {"fullname": "arianna.distributions.distributions.LogNormal.mean", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.mean", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.LogNormal.var": {"fullname": "arianna.distributions.distributions.LogNormal.var", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.var", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.LogNormal.mode": {"fullname": "arianna.distributions.distributions.LogNormal.mode", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.mode", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.LogNormal.median": {"fullname": "arianna.distributions.distributions.LogNormal.median", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.median", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.LogNormal.logcdf": {"fullname": "arianna.distributions.distributions.LogNormal.logcdf", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.logcdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.LogNormal.cdf": {"fullname": "arianna.distributions.distributions.LogNormal.cdf", "modulename": "arianna.distributions.distributions", "qualname": "LogNormal.cdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Weibull": {"fullname": "arianna.distributions.distributions.Weibull", "modulename": "arianna.distributions.distributions", "qualname": "Weibull", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.Positive"}, "arianna.distributions.distributions.Gumbel": {"fullname": "arianna.distributions.distributions.Gumbel", "modulename": "arianna.distributions.distributions", "qualname": "Gumbel", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.UnivariateReal"}, "arianna.distributions.distributions.Logistic": {"fullname": "arianna.distributions.distributions.Logistic", "modulename": "arianna.distributions.distributions", "qualname": "Logistic", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.Positive"}, "arianna.distributions.distributions.LogLogistic": {"fullname": "arianna.distributions.distributions.LogLogistic", "modulename": "arianna.distributions.distributions", "qualname": "LogLogistic", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.UnivariateReal"}, "arianna.distributions.distributions.Normal": {"fullname": "arianna.distributions.distributions.Normal", "modulename": "arianna.distributions.distributions", "qualname": "Normal", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.UnivariateReal"}, "arianna.distributions.distributions.Normal.__init__": {"fullname": "arianna.distributions.distributions.Normal.__init__", "modulename": "arianna.distributions.distributions", "qualname": "Normal.__init__", "kind": "function", "doc": "

\n", "signature": "(\tloc: float | numpy.ndarray = 0.0,\tscale: float | numpy.ndarray = 1.0,\tcheck: bool = True)"}, "arianna.distributions.distributions.Normal.loc": {"fullname": "arianna.distributions.distributions.Normal.loc", "modulename": "arianna.distributions.distributions", "qualname": "Normal.loc", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Normal.scale": {"fullname": "arianna.distributions.distributions.Normal.scale", "modulename": "arianna.distributions.distributions", "qualname": "Normal.scale", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Normal.batch_shape": {"fullname": "arianna.distributions.distributions.Normal.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "Normal.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.Normal.logpdf": {"fullname": "arianna.distributions.distributions.Normal.logpdf", "modulename": "arianna.distributions.distributions", "qualname": "Normal.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Normal.logcdf": {"fullname": "arianna.distributions.distributions.Normal.logcdf", "modulename": "arianna.distributions.distributions", "qualname": "Normal.logcdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Normal.cdf": {"fullname": "arianna.distributions.distributions.Normal.cdf", "modulename": "arianna.distributions.distributions", "qualname": "Normal.cdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Normal.survival": {"fullname": "arianna.distributions.distributions.Normal.survival", "modulename": "arianna.distributions.distributions", "qualname": "Normal.survival", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Normal.mean": {"fullname": "arianna.distributions.distributions.Normal.mean", "modulename": "arianna.distributions.distributions", "qualname": "Normal.mean", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Normal.std": {"fullname": "arianna.distributions.distributions.Normal.std", "modulename": "arianna.distributions.distributions", "qualname": "Normal.std", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Normal.var": {"fullname": "arianna.distributions.distributions.Normal.var", "modulename": "arianna.distributions.distributions", "qualname": "Normal.var", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Normal.mode": {"fullname": "arianna.distributions.distributions.Normal.mode", "modulename": "arianna.distributions.distributions", "qualname": "Normal.mode", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.Normal.median": {"fullname": "arianna.distributions.distributions.Normal.median", "modulename": "arianna.distributions.distributions", "qualname": "Normal.median", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.MvNormal": {"fullname": "arianna.distributions.distributions.MvNormal", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.MultivariateReal"}, "arianna.distributions.distributions.MvNormal.__init__": {"fullname": "arianna.distributions.distributions.MvNormal.__init__", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.__init__", "kind": "function", "doc": "

\n", "signature": "(\tmean: Optional[numpy.ndarray] = None,\tcov: Optional[numpy.ndarray] = None,\t**kwargs)"}, "arianna.distributions.distributions.MvNormal.mean": {"fullname": "arianna.distributions.distributions.MvNormal.mean", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.mean", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.distributions.MvNormal.cov": {"fullname": "arianna.distributions.distributions.MvNormal.cov", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.cov", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.distributions.MvNormal.cov_inv": {"fullname": "arianna.distributions.distributions.MvNormal.cov_inv", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.cov_inv", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.distributions.MvNormal.L": {"fullname": "arianna.distributions.distributions.MvNormal.L", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.L", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.distributions.MvNormal.event_shape": {"fullname": "arianna.distributions.distributions.MvNormal.event_shape", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.event_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.MvNormal.batch_shape": {"fullname": "arianna.distributions.distributions.MvNormal.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.batch_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"fullname": "arianna.distributions.distributions.MvNormal.batch_plus_event_shape", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.batch_plus_event_shape", "kind": "variable", "doc": "

\n", "annotation": ": tuple[int, ...]"}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"fullname": "arianna.distributions.distributions.MvNormal.log_det_cov", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.log_det_cov", "kind": "variable", "doc": "

\n", "annotation": ": float | numpy.ndarray"}, "arianna.distributions.distributions.MvNormal.var": {"fullname": "arianna.distributions.distributions.MvNormal.var", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.var", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.distributions.MvNormal.logpdf": {"fullname": "arianna.distributions.distributions.MvNormal.logpdf", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x):", "funcdef": "def"}, "arianna.distributions.distributions.MvNormal.sample": {"fullname": "arianna.distributions.distributions.MvNormal.sample", "modulename": "arianna.distributions.distributions", "qualname": "MvNormal.sample", "kind": "function", "doc": "

\n", "signature": "(\tself,\tsample_shape: tuple[int, ...] = (),\trng: numpy.random._generator.Generator = Generator(PCG64) at 0x103F8FD80) -> numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Dirichlet": {"fullname": "arianna.distributions.distributions.Dirichlet", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "arianna.distributions.abstract.MultivariateContinuous"}, "arianna.distributions.distributions.Dirichlet.__init__": {"fullname": "arianna.distributions.distributions.Dirichlet.__init__", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.__init__", "kind": "function", "doc": "

\n", "signature": "(concentration: numpy.ndarray, check: bool = True)"}, "arianna.distributions.distributions.Dirichlet.concentration": {"fullname": "arianna.distributions.distributions.Dirichlet.concentration", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.concentration", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"fullname": "arianna.distributions.distributions.Dirichlet.concentration_sum", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.concentration_sum", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Dirichlet.event_shape": {"fullname": "arianna.distributions.distributions.Dirichlet.event_shape", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.event_shape", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"fullname": "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.batch_plus_event_shape", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"fullname": "arianna.distributions.distributions.Dirichlet.batch_shape", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.batch_shape", "kind": "variable", "doc": "

\n"}, "arianna.distributions.distributions.Dirichlet.logpdf": {"fullname": "arianna.distributions.distributions.Dirichlet.logpdf", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x: numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Dirichlet.sample": {"fullname": "arianna.distributions.distributions.Dirichlet.sample", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.sample", "kind": "function", "doc": "

\n", "signature": "(\tself,\tsample_shape: tuple[int, ...] = (),\trng: numpy.random._generator.Generator = Generator(PCG64) at 0x10401C040) -> numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Dirichlet.to_real": {"fullname": "arianna.distributions.distributions.Dirichlet.to_real", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.to_real", "kind": "function", "doc": "

\n", "signature": "(self, x: numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Dirichlet.to_native": {"fullname": "arianna.distributions.distributions.Dirichlet.to_native", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.to_native", "kind": "function", "doc": "

\n", "signature": "(self, z: numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"fullname": "arianna.distributions.distributions.Dirichlet.logdetjac", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.logdetjac", "kind": "function", "doc": "

\n", "signature": "(self, z: numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.distributions.distributions.Dirichlet.cov": {"fullname": "arianna.distributions.distributions.Dirichlet.cov", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.cov", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.distributions.Dirichlet.mean": {"fullname": "arianna.distributions.distributions.Dirichlet.mean", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.mean", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.distributions.Dirichlet.var": {"fullname": "arianna.distributions.distributions.Dirichlet.var", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.var", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.distributions.distributions.Dirichlet.std": {"fullname": "arianna.distributions.distributions.Dirichlet.std", "modulename": "arianna.distributions.distributions", "qualname": "Dirichlet.std", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.ppl": {"fullname": "arianna.ppl", "modulename": "arianna.ppl", "kind": "module", "doc": "

\n"}, "arianna.ppl.context": {"fullname": "arianna.ppl.context", "modulename": "arianna.ppl.context", "kind": "module", "doc": "

\n"}, "arianna.ppl.context.BasicDistribution": {"fullname": "arianna.ppl.context.BasicDistribution", "modulename": "arianna.ppl.context", "qualname": "BasicDistribution", "kind": "class", "doc": "

Base class for protocol classes.

\n\n

Protocol classes are defined as::

\n\n
class Proto(Protocol):\n    def meth(self) -> int:\n        ...\n
\n\n

Such classes are primarily used with static type checkers that recognize\nstructural subtyping (static duck-typing), for example::

\n\n
class C:\n    def meth(self) -> int:\n        return 0\n\ndef func(x: Proto) -> int:\n    return x.meth()\n\nfunc(C())  # Passes static type check\n
\n\n

See PEP 544 for details. Protocol classes decorated with\n@typing.runtime_checkable act as simple-minded runtime protocols that check\nonly the presence of given attributes, ignoring their type signatures.\nProtocol classes can be generic, they are defined as::

\n\n
class GenProto(Protocol[T]):\n    def meth(self) -> T:\n        ...\n
\n", "bases": "typing.Protocol"}, "arianna.ppl.context.BasicDistribution.__init__": {"fullname": "arianna.ppl.context.BasicDistribution.__init__", "modulename": "arianna.ppl.context", "qualname": "BasicDistribution.__init__", "kind": "function", "doc": "

\n", "signature": "(*args, **kwargs)"}, "arianna.ppl.context.BasicDistribution.logpdf": {"fullname": "arianna.ppl.context.BasicDistribution.logpdf", "modulename": "arianna.ppl.context", "qualname": "BasicDistribution.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.BasicDistribution.sample": {"fullname": "arianna.ppl.context.BasicDistribution.sample", "modulename": "arianna.ppl.context", "qualname": "BasicDistribution.sample", "kind": "function", "doc": "

\n", "signature": "(\tself,\tsample_shape: tuple[int, ...] = (),\trng: numpy.random._generator.Generator = Generator(PCG64) at 0x10401C3C0) -> numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.TransformableDistribution": {"fullname": "arianna.ppl.context.TransformableDistribution", "modulename": "arianna.ppl.context", "qualname": "TransformableDistribution", "kind": "class", "doc": "

Base class for protocol classes.

\n\n

Protocol classes are defined as::

\n\n
class Proto(Protocol):\n    def meth(self) -> int:\n        ...\n
\n\n

Such classes are primarily used with static type checkers that recognize\nstructural subtyping (static duck-typing), for example::

\n\n
class C:\n    def meth(self) -> int:\n        return 0\n\ndef func(x: Proto) -> int:\n    return x.meth()\n\nfunc(C())  # Passes static type check\n
\n\n

See PEP 544 for details. Protocol classes decorated with\n@typing.runtime_checkable act as simple-minded runtime protocols that check\nonly the presence of given attributes, ignoring their type signatures.\nProtocol classes can be generic, they are defined as::

\n\n
class GenProto(Protocol[T]):\n    def meth(self) -> T:\n        ...\n
\n", "bases": "BasicDistribution"}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"fullname": "arianna.ppl.context.TransformableDistribution.logdetjac", "modulename": "arianna.ppl.context", "qualname": "TransformableDistribution.logdetjac", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"fullname": "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac", "modulename": "arianna.ppl.context", "qualname": "TransformableDistribution.logpdf_plus_logdetjac", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.TransformableDistribution.to_real": {"fullname": "arianna.ppl.context.TransformableDistribution.to_real", "modulename": "arianna.ppl.context", "qualname": "TransformableDistribution.to_real", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.TransformableDistribution.to_native": {"fullname": "arianna.ppl.context.TransformableDistribution.to_native", "modulename": "arianna.ppl.context", "qualname": "TransformableDistribution.to_native", "kind": "function", "doc": "

\n", "signature": "(self, z: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.TransformableDistribution.logpdf": {"fullname": "arianna.ppl.context.TransformableDistribution.logpdf", "modulename": "arianna.ppl.context", "qualname": "TransformableDistribution.logpdf", "kind": "function", "doc": "

\n", "signature": "(self, x: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.Context": {"fullname": "arianna.ppl.context.Context", "modulename": "arianna.ppl.context", "qualname": "Context", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "abc.ABC"}, "arianna.ppl.context.Context.result": {"fullname": "arianna.ppl.context.Context.result", "modulename": "arianna.ppl.context", "qualname": "Context.result", "kind": "variable", "doc": "

\n", "annotation": ": Any"}, "arianna.ppl.context.Context.state": {"fullname": "arianna.ppl.context.Context.state", "modulename": "arianna.ppl.context", "qualname": "Context.state", "kind": "variable", "doc": "

\n", "annotation": ": dict[str, float | numpy.ndarray]"}, "arianna.ppl.context.Context.run": {"fullname": "arianna.ppl.context.Context.run", "modulename": "arianna.ppl.context", "qualname": "Context.run", "kind": "function", "doc": "

\n", "signature": "(cls):", "funcdef": "def"}, "arianna.ppl.context.Context.rv": {"fullname": "arianna.ppl.context.Context.rv", "modulename": "arianna.ppl.context", "qualname": "Context.rv", "kind": "function", "doc": "

\n", "signature": "(\tself,\tname: str,\tdist: arianna.ppl.context.BasicDistribution,\tobs: Union[float, numpy.ndarray, NoneType] = None) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.Context.cached": {"fullname": "arianna.ppl.context.Context.cached", "modulename": "arianna.ppl.context", "qualname": "Context.cached", "kind": "function", "doc": "

\n", "signature": "(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.LogprobAndPriorSample": {"fullname": "arianna.ppl.context.LogprobAndPriorSample", "modulename": "arianna.ppl.context", "qualname": "LogprobAndPriorSample", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Context"}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"fullname": "arianna.ppl.context.LogprobAndPriorSample.__init__", "modulename": "arianna.ppl.context", "qualname": "LogprobAndPriorSample.__init__", "kind": "function", "doc": "

\n", "signature": "(rng: Optional[numpy.random._generator.Generator] = None)"}, "arianna.ppl.context.LogprobAndPriorSample.run": {"fullname": "arianna.ppl.context.LogprobAndPriorSample.run", "modulename": "arianna.ppl.context", "qualname": "LogprobAndPriorSample.run", "kind": "function", "doc": "

Get (logprob, trace).

\n", "signature": "(\tcls,\tmodel,\trng: Optional[numpy.random._generator.Generator] = None,\t**data) -> tuple[float, dict[str, float | numpy.ndarray]]:", "funcdef": "def"}, "arianna.ppl.context.LogprobAndPriorSample.result": {"fullname": "arianna.ppl.context.LogprobAndPriorSample.result", "modulename": "arianna.ppl.context", "qualname": "LogprobAndPriorSample.result", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.LogprobAndPriorSample.rng": {"fullname": "arianna.ppl.context.LogprobAndPriorSample.rng", "modulename": "arianna.ppl.context", "qualname": "LogprobAndPriorSample.rng", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"fullname": "arianna.ppl.context.LogprobAndPriorSample.rv", "modulename": "arianna.ppl.context", "qualname": "LogprobAndPriorSample.rv", "kind": "function", "doc": "

\n", "signature": "(\tself,\tname: str,\tdist: arianna.ppl.context.BasicDistribution,\tobs: Union[float, numpy.ndarray, NoneType] = None):", "funcdef": "def"}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"fullname": "arianna.ppl.context.LogprobAndPriorSample.cached", "modulename": "arianna.ppl.context", "qualname": "LogprobAndPriorSample.cached", "kind": "function", "doc": "

\n", "signature": "(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.LogprobAndTrace": {"fullname": "arianna.ppl.context.LogprobAndTrace", "modulename": "arianna.ppl.context", "qualname": "LogprobAndTrace", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Context"}, "arianna.ppl.context.LogprobAndTrace.__init__": {"fullname": "arianna.ppl.context.LogprobAndTrace.__init__", "modulename": "arianna.ppl.context", "qualname": "LogprobAndTrace.__init__", "kind": "function", "doc": "

\n", "signature": "(state: dict[str, float | numpy.ndarray])"}, "arianna.ppl.context.LogprobAndTrace.run": {"fullname": "arianna.ppl.context.LogprobAndTrace.run", "modulename": "arianna.ppl.context", "qualname": "LogprobAndTrace.run", "kind": "function", "doc": "

TODO.

\n\n

Returns (logprob, trace). A trace is the state in the native space and\nthe cached values.

\n\n
Parameters
\n\n
    \n
  • model (Any):\n_description_
    • \n
  • state (State):\n_description_
    • \n
\n\n
Returns
\n\n
    \n
  • tuple[float, State]: _description_
    • \n
\n", "signature": "(\tcls,\tmodel,\tstate: dict[str, float | numpy.ndarray],\t**data) -> tuple[float, dict[str, float | numpy.ndarray]]:", "funcdef": "def"}, "arianna.ppl.context.LogprobAndTrace.state": {"fullname": "arianna.ppl.context.LogprobAndTrace.state", "modulename": "arianna.ppl.context", "qualname": "LogprobAndTrace.state", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.LogprobAndTrace.result": {"fullname": "arianna.ppl.context.LogprobAndTrace.result", "modulename": "arianna.ppl.context", "qualname": "LogprobAndTrace.result", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.LogprobAndTrace.rv": {"fullname": "arianna.ppl.context.LogprobAndTrace.rv", "modulename": "arianna.ppl.context", "qualname": "LogprobAndTrace.rv", "kind": "function", "doc": "

\n", "signature": "(\tself,\tname: str,\tdist: arianna.ppl.context.BasicDistribution,\tobs: Union[float, numpy.ndarray, NoneType] = None):", "funcdef": "def"}, "arianna.ppl.context.LogprobAndTrace.cached": {"fullname": "arianna.ppl.context.LogprobAndTrace.cached", "modulename": "arianna.ppl.context", "qualname": "LogprobAndTrace.cached", "kind": "function", "doc": "

\n", "signature": "(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.Predictive": {"fullname": "arianna.ppl.context.Predictive", "modulename": "arianna.ppl.context", "qualname": "Predictive", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Context"}, "arianna.ppl.context.Predictive.__init__": {"fullname": "arianna.ppl.context.Predictive.__init__", "modulename": "arianna.ppl.context", "qualname": "Predictive.__init__", "kind": "function", "doc": "

\n", "signature": "(\tstate: Optional[dict[str, float | numpy.ndarray]] = None,\trng: Optional[numpy.random._generator.Generator] = None,\treturn_cached: bool = True)"}, "arianna.ppl.context.Predictive.run": {"fullname": "arianna.ppl.context.Predictive.run", "modulename": "arianna.ppl.context", "qualname": "Predictive.run", "kind": "function", "doc": "

\n", "signature": "(\tcls,\tmodel,\tstate: Optional[dict[str, float | numpy.ndarray]] = None,\trng: Optional[numpy.random._generator.Generator] = None,\treturn_cached: bool = True,\t**data) -> dict[str, float | numpy.ndarray]:", "funcdef": "def"}, "arianna.ppl.context.Predictive.state": {"fullname": "arianna.ppl.context.Predictive.state", "modulename": "arianna.ppl.context", "qualname": "Predictive.state", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.Predictive.rng": {"fullname": "arianna.ppl.context.Predictive.rng", "modulename": "arianna.ppl.context", "qualname": "Predictive.rng", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.Predictive.return_cached": {"fullname": "arianna.ppl.context.Predictive.return_cached", "modulename": "arianna.ppl.context", "qualname": "Predictive.return_cached", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.Predictive.result": {"fullname": "arianna.ppl.context.Predictive.result", "modulename": "arianna.ppl.context", "qualname": "Predictive.result", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.Predictive.rv": {"fullname": "arianna.ppl.context.Predictive.rv", "modulename": "arianna.ppl.context", "qualname": "Predictive.rv", "kind": "function", "doc": "

\n", "signature": "(\tself,\tname: str,\tdist: arianna.ppl.context.BasicDistribution,\tobs: Union[float, numpy.ndarray, NoneType] = None) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.Predictive.cached": {"fullname": "arianna.ppl.context.Predictive.cached", "modulename": "arianna.ppl.context", "qualname": "Predictive.cached", "kind": "function", "doc": "

Handle cached values.

\n\n

Returns the value value and additionally stores value in\nself.result[name] if the return_cached attribute is True.

\n\n
Parameters
\n\n
    \n
  • name (str):\nName of value to cache.
    • \n
  • value (Numeric):\nValue of the thing to cache.
    • \n
\n\n
Returns
\n\n
    \n
  • Numeric: value, which is the second argument in cached.
    • \n
\n", "signature": "(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.TransformedLogprobAndTrace": {"fullname": "arianna.ppl.context.TransformedLogprobAndTrace", "modulename": "arianna.ppl.context", "qualname": "TransformedLogprobAndTrace", "kind": "class", "doc": "

TODO.

\n\n

Calculates the transformed log probability for a given state (on the real\nspace) and also returns the state in the native space.

\n\n
Returns
\n\n
    \n
  • tuple[float, State]: (logprob_plus_logdetjac, native_state_with_cached_items)
    • \n
\n", "bases": "Context"}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"fullname": "arianna.ppl.context.TransformedLogprobAndTrace.__init__", "modulename": "arianna.ppl.context", "qualname": "TransformedLogprobAndTrace.__init__", "kind": "function", "doc": "

\n", "signature": "(state: dict[str, float | numpy.ndarray])"}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"fullname": "arianna.ppl.context.TransformedLogprobAndTrace.run", "modulename": "arianna.ppl.context", "qualname": "TransformedLogprobAndTrace.run", "kind": "function", "doc": "

\n", "signature": "(\tcls,\tmodel,\tstate: dict[str, float | numpy.ndarray],\t**data) -> tuple[float, dict[str, float | numpy.ndarray]]:", "funcdef": "def"}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"fullname": "arianna.ppl.context.TransformedLogprobAndTrace.state", "modulename": "arianna.ppl.context", "qualname": "TransformedLogprobAndTrace.state", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"fullname": "arianna.ppl.context.TransformedLogprobAndTrace.result", "modulename": "arianna.ppl.context", "qualname": "TransformedLogprobAndTrace.result", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"fullname": "arianna.ppl.context.TransformedLogprobAndTrace.rv", "modulename": "arianna.ppl.context", "qualname": "TransformedLogprobAndTrace.rv", "kind": "function", "doc": "

\n", "signature": "(\tself,\tname: str,\tdist: arianna.ppl.context.TransformableDistribution,\tobs: Union[float, numpy.ndarray, NoneType] = None):", "funcdef": "def"}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"fullname": "arianna.ppl.context.TransformedLogprobAndTrace.cached", "modulename": "arianna.ppl.context", "qualname": "TransformedLogprobAndTrace.cached", "kind": "function", "doc": "

\n", "signature": "(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.TransformedPredictive": {"fullname": "arianna.ppl.context.TransformedPredictive", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive", "kind": "class", "doc": "

Get transformed predictive state.

\n\n

Get transformed predictive state (i.e. state predictive in the real\nspace) via the run method.

\n\n
Parameters
\n\n
    \n
  • state (Optional[State]):\nContains values on the native space. If a model parameter's\nvalue is not provided, it will be sampled from it's prior.\nDefaults to None.
    • \n
  • rng (Optional[RNG]):\nRandom number generator. Defaults to None.
    • \n
  • return_cached (bool):\nWhether or not to return cached values. Defaults to True.
    • \n
\n\n
Attributes
\n\n
    \n
  • state (State):\nContains values on the native space. If None was provided in the\nconstructor, it's value will be an empty dictionary.
    • \n
  • rng (RNG):\nRandom number generator. If None was provided in the\nconstructor, this will be default_rng().
    • \n
  • return_cached (bool):\nWhether or not to return cached values.
    • \n
\n", "bases": "Context"}, "arianna.ppl.context.TransformedPredictive.__init__": {"fullname": "arianna.ppl.context.TransformedPredictive.__init__", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive.__init__", "kind": "function", "doc": "

\n", "signature": "(\tstate: Optional[dict[str, float | numpy.ndarray]] = None,\trng: Optional[numpy.random._generator.Generator] = None,\treturn_cached: bool = True)"}, "arianna.ppl.context.TransformedPredictive.run": {"fullname": "arianna.ppl.context.TransformedPredictive.run", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive.run", "kind": "function", "doc": "

\n", "signature": "(\tcls,\tmodel,\tstate: Optional[dict[str, float | numpy.ndarray]] = None,\trng: Optional[numpy.random._generator.Generator] = None,\treturn_cached: bool = True,\t**data):", "funcdef": "def"}, "arianna.ppl.context.TransformedPredictive.state": {"fullname": "arianna.ppl.context.TransformedPredictive.state", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive.state", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.TransformedPredictive.rng": {"fullname": "arianna.ppl.context.TransformedPredictive.rng", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive.rng", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.TransformedPredictive.return_cached": {"fullname": "arianna.ppl.context.TransformedPredictive.return_cached", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive.return_cached", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.TransformedPredictive.result": {"fullname": "arianna.ppl.context.TransformedPredictive.result", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive.result", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.TransformedPredictive.rv": {"fullname": "arianna.ppl.context.TransformedPredictive.rv", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive.rv", "kind": "function", "doc": "

\n", "signature": "(\tself,\tname: str,\tdist: arianna.ppl.context.TransformableDistribution,\tobs: Union[float, numpy.ndarray, NoneType] = None) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.TransformedPredictive.cached": {"fullname": "arianna.ppl.context.TransformedPredictive.cached", "modulename": "arianna.ppl.context", "qualname": "TransformedPredictive.cached", "kind": "function", "doc": "

Handle cached values.

\n\n

Returns the value value and additionally stores value in\nself.result[name] if the return_cached attribute is True.

\n\n
Parameters
\n\n
    \n
  • name (str):\nName of value to cache.
    • \n
  • value (Numeric):\nValue of the thing to cache.
    • \n
\n\n
Returns
\n\n
    \n
  • Numeric: value, which is the second argument in cached.
    • \n
\n", "signature": "(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"fullname": "arianna.ppl.context.LogprobAndLogjacobianAndTrace", "modulename": "arianna.ppl.context", "qualname": "LogprobAndLogjacobianAndTrace", "kind": "class", "doc": "

Helper class that provides a standard way to create an ABC using\ninheritance.

\n", "bases": "Context"}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"fullname": "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__", "modulename": "arianna.ppl.context", "qualname": "LogprobAndLogjacobianAndTrace.__init__", "kind": "function", "doc": "

\n", "signature": "(state: dict[str, float | numpy.ndarray])"}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"fullname": "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run", "modulename": "arianna.ppl.context", "qualname": "LogprobAndLogjacobianAndTrace.run", "kind": "function", "doc": "

\n", "signature": "(\tcls,\tmodel,\tstate: dict[str, float | numpy.ndarray],\t**data) -> tuple[float, float, dict[str, float | numpy.ndarray]]:", "funcdef": "def"}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"fullname": "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state", "modulename": "arianna.ppl.context", "qualname": "LogprobAndLogjacobianAndTrace.state", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"fullname": "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result", "modulename": "arianna.ppl.context", "qualname": "LogprobAndLogjacobianAndTrace.result", "kind": "variable", "doc": "

\n"}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"fullname": "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv", "modulename": "arianna.ppl.context", "qualname": "LogprobAndLogjacobianAndTrace.rv", "kind": "function", "doc": "

\n", "signature": "(\tself,\tname: str,\tdist: arianna.ppl.context.TransformableDistribution,\tobs: Union[float, numpy.ndarray, NoneType] = None):", "funcdef": "def"}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"fullname": "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached", "modulename": "arianna.ppl.context", "qualname": "LogprobAndLogjacobianAndTrace.cached", "kind": "function", "doc": "

\n", "signature": "(self, name: str, value: float | numpy.ndarray) -> float | numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.diagnostics": {"fullname": "arianna.ppl.diagnostics", "modulename": "arianna.ppl.diagnostics", "kind": "module", "doc": "

\n"}, "arianna.ppl.diagnostics.ess_kish": {"fullname": "arianna.ppl.diagnostics.ess_kish", "modulename": "arianna.ppl.diagnostics", "qualname": "ess_kish", "kind": "function", "doc": "

Kish Effective Sample Size.

\n\n

Kish's effective sample size. Used for weighted samples. (e.g. importance\nsampling, sequential monte carlo, particle filters.)

\n\n

https://en.wikipedia.org/wiki/Effective_sample_size

\n\n

If log is True, then the w are log weights.

\n", "signature": "(w: numpy.ndarray, log: bool = True) -> float:", "funcdef": "def"}, "arianna.ppl.inference": {"fullname": "arianna.ppl.inference", "modulename": "arianna.ppl.inference", "kind": "module", "doc": "

\n"}, "arianna.ppl.inference.P": {"fullname": "arianna.ppl.inference.P", "modulename": "arianna.ppl.inference", "qualname": "P", "kind": "variable", "doc": "

\n", "default_value": "~P"}, "arianna.ppl.inference.Model": {"fullname": "arianna.ppl.inference.Model", "modulename": "arianna.ppl.inference", "qualname": "Model", "kind": "variable", "doc": "

\n", "default_value": "typing.Callable[typing.Concatenate[arianna.ppl.context.Context, ~P], NoneType]"}, "arianna.ppl.inference.Logprob": {"fullname": "arianna.ppl.inference.Logprob", "modulename": "arianna.ppl.inference", "qualname": "Logprob", "kind": "variable", "doc": "

\n", "default_value": "typing.Callable[[dict[str, float | numpy.ndarray]], tuple[float, dict[str, float | numpy.ndarray]]]"}, "arianna.ppl.inference.Chain": {"fullname": "arianna.ppl.inference.Chain", "modulename": "arianna.ppl.inference", "qualname": "Chain", "kind": "class", "doc": "

Chain MCMC samples.

\n\n
Parameters
\n\n
    \n
  • states (Iterable[State]):\nMCMC states.
    • \n
\n\n
Attributes
\n\n
    \n
  • chain (list[State]):\nMCMC states in list format.
    • \n
\n"}, "arianna.ppl.inference.Chain.__init__": {"fullname": "arianna.ppl.inference.Chain.__init__", "modulename": "arianna.ppl.inference", "qualname": "Chain.__init__", "kind": "function", "doc": "

\n", "signature": "(states: Iterable[dict[str, float | numpy.ndarray]])"}, "arianna.ppl.inference.Chain.states": {"fullname": "arianna.ppl.inference.Chain.states", "modulename": "arianna.ppl.inference", "qualname": "Chain.states", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.Chain.names": {"fullname": "arianna.ppl.inference.Chain.names", "modulename": "arianna.ppl.inference", "qualname": "Chain.names", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.Chain.get": {"fullname": "arianna.ppl.inference.Chain.get", "modulename": "arianna.ppl.inference", "qualname": "Chain.get", "kind": "function", "doc": "

Get all MCMC samples for one variable or cached value by name.

\n\n
Parameters
\n\n
    \n
  • name (str):\nName of model parameter or cached value.
    • \n
\n\n
Returns
\n\n
    \n
  • ndarray: MCMC samples for the variable or cached value named.
    • \n
\n", "signature": "(self, name: str) -> numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.inference.Chain.bundle": {"fullname": "arianna.ppl.inference.Chain.bundle", "modulename": "arianna.ppl.inference", "qualname": "Chain.bundle", "kind": "variable", "doc": "

Bundle MCMC values into a dictionary.

\n\n
Returns
\n\n
    \n
  • dict[str, ndarray]: Dictionary bundle of MCMC samples.
    • \n
\n", "annotation": ": dict[str, numpy.ndarray]"}, "arianna.ppl.inference.Chain.subset": {"fullname": "arianna.ppl.inference.Chain.subset", "modulename": "arianna.ppl.inference", "qualname": "Chain.subset", "kind": "function", "doc": "

Return subset of the states.

\n\n
Parameters
\n\n
    \n
  • burn (int, optional):\nNumber of initial samples to discard, by default 0.
    • \n
  • thin (int, optional):\nTake only every thin-th sample, by default 1.
    • \n
\n\n
Returns
\n\n
    \n
  • Chain: A whole new chain, with the first burn removed, and taking only\nevery thin-th sample.
    • \n
\n", "signature": "(self, burn: int = 0, thin: int = 1):", "funcdef": "def"}, "arianna.ppl.inference.InferenceEngine": {"fullname": "arianna.ppl.inference.InferenceEngine", "modulename": "arianna.ppl.inference", "qualname": "InferenceEngine", "kind": "class", "doc": "

Abstract inference engine class.

\n", "bases": "abc.ABC"}, "arianna.ppl.inference.InferenceEngine.rng": {"fullname": "arianna.ppl.inference.InferenceEngine.rng", "modulename": "arianna.ppl.inference", "qualname": "InferenceEngine.rng", "kind": "variable", "doc": "

\n", "annotation": ": numpy.random._generator.Generator"}, "arianna.ppl.inference.InferenceEngine.fit": {"fullname": "arianna.ppl.inference.InferenceEngine.fit", "modulename": "arianna.ppl.inference", "qualname": "InferenceEngine.fit", "kind": "function", "doc": "

Fit model.

\n", "signature": "(self):", "funcdef": "def"}, "arianna.ppl.inference.MCMC": {"fullname": "arianna.ppl.inference.MCMC", "modulename": "arianna.ppl.inference", "qualname": "MCMC", "kind": "class", "doc": "

Abstract class for MCMC.

\n", "bases": "InferenceEngine"}, "arianna.ppl.inference.MCMC.model": {"fullname": "arianna.ppl.inference.MCMC.model", "modulename": "arianna.ppl.inference", "qualname": "MCMC.model", "kind": "variable", "doc": "

\n", "annotation": ": Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType]"}, "arianna.ppl.inference.MCMC.model_data": {"fullname": "arianna.ppl.inference.MCMC.model_data", "modulename": "arianna.ppl.inference", "qualname": "MCMC.model_data", "kind": "variable", "doc": "

\n", "annotation": ": dict[str, typing.Any]"}, "arianna.ppl.inference.MCMC.nsamples": {"fullname": "arianna.ppl.inference.MCMC.nsamples", "modulename": "arianna.ppl.inference", "qualname": "MCMC.nsamples", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "arianna.ppl.inference.MCMC.burn": {"fullname": "arianna.ppl.inference.MCMC.burn", "modulename": "arianna.ppl.inference", "qualname": "MCMC.burn", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "arianna.ppl.inference.MCMC.thin": {"fullname": "arianna.ppl.inference.MCMC.thin", "modulename": "arianna.ppl.inference", "qualname": "MCMC.thin", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"fullname": "arianna.ppl.inference.MCMC.mcmc_iteration", "modulename": "arianna.ppl.inference", "qualname": "MCMC.mcmc_iteration", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "arianna.ppl.inference.MCMC.transform": {"fullname": "arianna.ppl.inference.MCMC.transform", "modulename": "arianna.ppl.inference", "qualname": "MCMC.transform", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "arianna.ppl.inference.MCMC.logprob_history": {"fullname": "arianna.ppl.inference.MCMC.logprob_history", "modulename": "arianna.ppl.inference", "qualname": "MCMC.logprob_history", "kind": "variable", "doc": "

\n", "annotation": ": list[float]"}, "arianna.ppl.inference.MCMC.step": {"fullname": "arianna.ppl.inference.MCMC.step", "modulename": "arianna.ppl.inference", "qualname": "MCMC.step", "kind": "function", "doc": "

Update model state in one MCMC iteration.

\n", "signature": "(self):", "funcdef": "def"}, "arianna.ppl.inference.MCMC.fit": {"fullname": "arianna.ppl.inference.MCMC.fit", "modulename": "arianna.ppl.inference", "qualname": "MCMC.fit", "kind": "function", "doc": "

Run MCMC.

\n\n
Returns
\n\n
    \n
  • Chain: Chain of MCMC samples.
    • \n
\n", "signature": "(self, *args, **kwargs) -> arianna.ppl.inference.Chain:", "funcdef": "def"}, "arianna.ppl.inference.MCMC.logprob": {"fullname": "arianna.ppl.inference.MCMC.logprob", "modulename": "arianna.ppl.inference", "qualname": "MCMC.logprob", "kind": "function", "doc": "

Compute log density.

\n\n
Parameters
\n\n
    \n
  • state (State):\nDictionary containing random variables to model.
    • \n
\n\n
Returns
\n\n
    \n
  • tuple[float, State]: (Log density (float), native state and cached values (dict))
    • \n
\n", "signature": "(\tself,\tstate: dict[str, float | numpy.ndarray]) -> tuple[float, dict[str, float | numpy.ndarray]]:", "funcdef": "def"}, "arianna.ppl.inference.SingleWalkerMCMC": {"fullname": "arianna.ppl.inference.SingleWalkerMCMC", "modulename": "arianna.ppl.inference", "qualname": "SingleWalkerMCMC", "kind": "class", "doc": "

Markov Chain Monte Carlo.

\n", "bases": "MCMC"}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"fullname": "arianna.ppl.inference.SingleWalkerMCMC.init_state", "modulename": "arianna.ppl.inference", "qualname": "SingleWalkerMCMC.init_state", "kind": "variable", "doc": "

\n", "annotation": ": dict[str, float | numpy.ndarray]"}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"fullname": "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state", "modulename": "arianna.ppl.inference", "qualname": "SingleWalkerMCMC.mcmc_state", "kind": "variable", "doc": "

\n", "annotation": ": dict[str, float | numpy.ndarray]"}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"fullname": "arianna.ppl.inference.SingleWalkerMCMC.transform", "modulename": "arianna.ppl.inference", "qualname": "SingleWalkerMCMC.transform", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"fullname": "arianna.ppl.inference.SingleWalkerMCMC.step", "modulename": "arianna.ppl.inference", "qualname": "SingleWalkerMCMC.step", "kind": "function", "doc": "

Update mcmc_state and return logprob and native_state_and_cache.

\n\n
Returns
\n\n
    \n
  • float, State: Logprob and native state and cache dictionary.
    • \n
\n", "signature": "(self) -> tuple[float, dict[str, float | numpy.ndarray]]:", "funcdef": "def"}, "arianna.ppl.inference.RandomWalkMetropolis": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis", "kind": "class", "doc": "

Random walk Metropolis.

\n\n
Parameters
\n\n
    \n
  • model (Model):\nmodel function.
    • \n
  • init_state (Optional[State]):\nInitial state for MCMC. If transform=True then init_state should\ncontain values in the real space; if transform=False, then\ninit_state should contain values in the native space. If not\nprovided, init_state is sampled from the prior predictive.\nDefaults to None.
    • \n
  • proposal (Optional[dict[str, Any]]):\nDictionary containing proposal functions, dependent on the current\nvalue. Defaults to None.
    • \n
  • transform (bool):\nWhether or not to sample parameters into the real space. If False,\nsamples parameters in the native space. Regardless, returned samples\nare in the native space and will include cached values. Defaults to\nTrue.
    • \n
  • rng (Optional[RNG]):\nNumpy random number generator. Defaults to None.
    • \n
\n\n
Attributes
\n\n
    \n
  • model (Model):\nSee Parameters.
    • \n
  • init_state (State):\nIf the constructor received None, init_state will be an empty\ndictionary.
    • \n

  • proposal (dict[str, Any]):\nIf None is received in the constructor, an empty dictionary is first\ncreated. In addition, any model parameters unnamed in the constructor\nwill have a value of\nlambda value, rng, mcmc_iteration: rng.normal(value, 0.1).\nThus, if you supplied in the constructor\ndict(mu=lambda value, rng, mcmc_iteration: rng.normal(value, 1))\nand your model is

    \n\n
    \n
    def model(ctx, y=None):\n    mu = ctx.rv("mu", Normal(0, 10))\n    sigma = ctx.rv("sigma", Gamma(1, 1))\n    ctx.rv("y", Normal(mu, sigma), obs=y)\n
    \n
    \n\n

    then the value for sigma will be\nlambda value, rng, _: rng.normal(value, 0.1).

    • \n
  • transform (bool):\nSee Parameters.
    • \n
  • rng (RNG):\nIf None was supplied in the constructor, then rng will be set to\nnp.random.default_rng().
    • \n
\n", "bases": "SingleWalkerMCMC"}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.__init__", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.__init__", "kind": "function", "doc": "

\n", "signature": "(\tmodel: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType],\tinit_state: Optional[dict[str, float | numpy.ndarray]] = None,\tproposal: Optional[dict[str, Any]] = None,\ttransform: bool = True,\trng: Optional[numpy.random._generator.Generator] = None,\t**model_data)"}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.mcmc_state", "kind": "variable", "doc": "

\n", "annotation": ": dict[str, float | numpy.ndarray]"}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.init_state", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.init_state", "kind": "variable", "doc": "

\n", "annotation": ": dict[str, float | numpy.ndarray]"}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.model", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.model", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.model_data", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.model_data", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.transform", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.transform", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.rng", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.rng", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.RandomWalkMetropolis.proposal": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.proposal", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.proposal", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"fullname": "arianna.ppl.inference.RandomWalkMetropolis.step", "modulename": "arianna.ppl.inference", "qualname": "RandomWalkMetropolis.step", "kind": "function", "doc": "

Update mcmc_state and return native state and cached values.

\n\n
Returns
\n\n
    \n
  • State: Native state and cached values.
    • \n
\n", "signature": "(self) -> tuple[float, dict[str, float | numpy.ndarray]]:", "funcdef": "def"}, "arianna.ppl.inference.AffineInvariantMCMC": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC", "kind": "class", "doc": "

Affine Invariant MCMC.

\n", "bases": "MCMC"}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.nsteps", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.nsteps", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.init_state", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.init_state", "kind": "variable", "doc": "

\n", "annotation": ": list[dict[str, float | numpy.ndarray]]"}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.mcmc_state", "kind": "variable", "doc": "

\n", "annotation": ": list[dict[str, float | numpy.ndarray]]"}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.accept_rate", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.accept_rate", "kind": "variable", "doc": "

\n", "annotation": ": numpy.ndarray"}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.accept", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.accept", "kind": "variable", "doc": "

\n", "annotation": ": list[int]"}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.nwalkers", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.nwalkers", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.rng", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.rng", "kind": "variable", "doc": "

\n", "annotation": ": numpy.random._generator.Generator"}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.a", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.a", "kind": "variable", "doc": "

\n", "annotation": ": float"}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.dim", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.dim", "kind": "variable", "doc": "

Number of model parameters.

\n", "annotation": ": int"}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.logprob", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.logprob", "kind": "function", "doc": "

Compute log density.

\n\n
Parameters
\n\n
    \n
  • state (State):\nDictionary containing random variables to model.
    • \n
\n\n
Returns
\n\n
    \n
  • tuple[float, float, State]: (\nLog density in native space,\nLog determinant of jacobian,\nnative state and cached values (dict)\n)
    • \n
\n", "signature": "(\tself,\tstate: dict[str, float | numpy.ndarray]) -> tuple[float, float, dict[str, float | numpy.ndarray]]:", "funcdef": "def"}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.step", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.step", "kind": "function", "doc": "

Update mcmc_state and return list of native_state_and_cache.

\n\n
Returns
\n\n
    \n
  • list[State]: List of native state and cache dictionary.
    • \n
\n", "signature": "(self) -> tuple[list[float], list[dict[str, float | numpy.ndarray]]]:", "funcdef": "def"}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"fullname": "arianna.ppl.inference.AffineInvariantMCMC.fit", "modulename": "arianna.ppl.inference", "qualname": "AffineInvariantMCMC.fit", "kind": "function", "doc": "

Fit model with AIES.

\n", "signature": "(\tself,\t*args,\trebalanced_samples: Optional[int] = None,\t**kwargs) -> arianna.ppl.inference.Chain:", "funcdef": "def"}, "arianna.ppl.inference.AIES": {"fullname": "arianna.ppl.inference.AIES", "modulename": "arianna.ppl.inference", "qualname": "AIES", "kind": "class", "doc": "

Sequential Affine Invariant Ensemble Sampler.

\n\n

This sampler is good for target distributions that are not multimodal and\nseparated by large low density regions. You should use as many walkers as\nyou can afford. Whereas this sampler employs walkers that are sequeutnailly\nupdated. there is a parallel analog that updates walkers in parallel.

\n\n
Parameters
\n\n
    \n
  • model (Model):\nA model function of the form def model(ctx: Context, **data).
    • \n
  • num_walkers (int, optional):\nNumber of walkers. Defaults to 10.
    • \n
  • transform (bool, optional):\nWhether or not to transform parameters into the real space, by default\nTrue.
    • \n
  • rng (RNG, optional):\nRandom number generator, by default default_rng()
    • \n
  • a (float, optional):\nTuning parameter that is set, by default, to 2.0, which is good for many\ncases.
    • \n
  • temperature_fn (Optional[Callable[[int], float]], optional):\nA temperature function for annealing, by default None.
    • \n
\n\n
References
\n\n\n", "bases": "AffineInvariantMCMC"}, "arianna.ppl.inference.AIES.__init__": {"fullname": "arianna.ppl.inference.AIES.__init__", "modulename": "arianna.ppl.inference", "qualname": "AIES.__init__", "kind": "function", "doc": "

\n", "signature": "(\tmodel: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType],\tnwalkers: int = 10,\ttransform: bool = True,\trng: numpy.random._generator.Generator = Generator(PCG64) at 0x105861000,\ta: float = 2.0,\ttemperature_fn: Optional[Callable[[int], float]] = None,\tinit_state: Optional[list[dict[str, float | numpy.ndarray]]] = None,\t**model_data)"}, "arianna.ppl.inference.AIES.default_temperature_fn": {"fullname": "arianna.ppl.inference.AIES.default_temperature_fn", "modulename": "arianna.ppl.inference", "qualname": "AIES.default_temperature_fn", "kind": "function", "doc": "

Return 1.

\n", "signature": "(iter: int) -> float:", "funcdef": "def"}, "arianna.ppl.inference.AIES.model": {"fullname": "arianna.ppl.inference.AIES.model", "modulename": "arianna.ppl.inference", "qualname": "AIES.model", "kind": "variable", "doc": "

\n", "annotation": ": Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType]"}, "arianna.ppl.inference.AIES.nwalkers": {"fullname": "arianna.ppl.inference.AIES.nwalkers", "modulename": "arianna.ppl.inference", "qualname": "AIES.nwalkers", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "arianna.ppl.inference.AIES.transform": {"fullname": "arianna.ppl.inference.AIES.transform", "modulename": "arianna.ppl.inference", "qualname": "AIES.transform", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "arianna.ppl.inference.AIES.rng": {"fullname": "arianna.ppl.inference.AIES.rng", "modulename": "arianna.ppl.inference", "qualname": "AIES.rng", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.AIES.accept": {"fullname": "arianna.ppl.inference.AIES.accept", "modulename": "arianna.ppl.inference", "qualname": "AIES.accept", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.AIES.a": {"fullname": "arianna.ppl.inference.AIES.a", "modulename": "arianna.ppl.inference", "qualname": "AIES.a", "kind": "variable", "doc": "

\n", "annotation": ": float"}, "arianna.ppl.inference.AIES.model_data": {"fullname": "arianna.ppl.inference.AIES.model_data", "modulename": "arianna.ppl.inference", "qualname": "AIES.model_data", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.AIES.temperature_fn": {"fullname": "arianna.ppl.inference.AIES.temperature_fn", "modulename": "arianna.ppl.inference", "qualname": "AIES.temperature_fn", "kind": "variable", "doc": "

\n", "annotation": ": Callable[[int], float]"}, "arianna.ppl.inference.AIES.init_state": {"fullname": "arianna.ppl.inference.AIES.init_state", "modulename": "arianna.ppl.inference", "qualname": "AIES.init_state", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.AIES.step": {"fullname": "arianna.ppl.inference.AIES.step", "modulename": "arianna.ppl.inference", "qualname": "AIES.step", "kind": "function", "doc": "

Update mcmc_state and return list of native_state_and_cache.

\n\n
Returns
\n\n
    \n
  • list[float], list[State]: List of logprobs and list of native state and cache dictionary.
    • \n
\n", "signature": "(self) -> tuple[list[float], list[dict[str, float | numpy.ndarray]]]:", "funcdef": "def"}, "arianna.ppl.inference.ParallelAIES": {"fullname": "arianna.ppl.inference.ParallelAIES", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES", "kind": "class", "doc": "

Parallel Affine Invariant MCMC (or Parallel AIES).

\n\n
References
\n\n\n", "bases": "AffineInvariantMCMC"}, "arianna.ppl.inference.ParallelAIES.__init__": {"fullname": "arianna.ppl.inference.ParallelAIES.__init__", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.__init__", "kind": "function", "doc": "

\n", "signature": "(\tmodel: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType],\texecutor: concurrent.futures._base.Executor,\tnwalkers: int = 10,\ttransform: bool = True,\trng: numpy.random._generator.Generator = Generator(PCG64) at 0x1058611C0,\ta: float = 2.0,\tinit_state: Optional[list[dict[str, float | numpy.ndarray]]] = None,\t**model_data)"}, "arianna.ppl.inference.ParallelAIES.executor": {"fullname": "arianna.ppl.inference.ParallelAIES.executor", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.executor", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ParallelAIES.model": {"fullname": "arianna.ppl.inference.ParallelAIES.model", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.model", "kind": "variable", "doc": "

\n", "annotation": ": Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType]"}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"fullname": "arianna.ppl.inference.ParallelAIES.nwalkers", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.nwalkers", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "arianna.ppl.inference.ParallelAIES.transform": {"fullname": "arianna.ppl.inference.ParallelAIES.transform", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.transform", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "arianna.ppl.inference.ParallelAIES.rng": {"fullname": "arianna.ppl.inference.ParallelAIES.rng", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.rng", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ParallelAIES.rngs": {"fullname": "arianna.ppl.inference.ParallelAIES.rngs", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.rngs", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ParallelAIES.accept": {"fullname": "arianna.ppl.inference.ParallelAIES.accept", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.accept", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ParallelAIES.a": {"fullname": "arianna.ppl.inference.ParallelAIES.a", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.a", "kind": "variable", "doc": "

\n", "annotation": ": float"}, "arianna.ppl.inference.ParallelAIES.model_data": {"fullname": "arianna.ppl.inference.ParallelAIES.model_data", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.model_data", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ParallelAIES.init_state": {"fullname": "arianna.ppl.inference.ParallelAIES.init_state", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.init_state", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ParallelAIES.step": {"fullname": "arianna.ppl.inference.ParallelAIES.step", "modulename": "arianna.ppl.inference", "qualname": "ParallelAIES.step", "kind": "function", "doc": "

Update mcmc_state and return list of native_state_and_cache.

\n\n
Returns
\n\n
    \n
  • list[float], list[State]: Tuple in which the first element is a list of logprobs, and the\nsecond element is a list of traces (i.e., native state and cache\ndictionary).
    • \n
\n", "signature": "(self) -> tuple[list[float], list[dict[str, float | numpy.ndarray]]]:", "funcdef": "def"}, "arianna.ppl.inference.ImportanceSampling": {"fullname": "arianna.ppl.inference.ImportanceSampling", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling", "kind": "class", "doc": "

Importance Sampling.

\n", "bases": "InferenceEngine"}, "arianna.ppl.inference.ImportanceSampling.__init__": {"fullname": "arianna.ppl.inference.ImportanceSampling.__init__", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.__init__", "kind": "function", "doc": "

\n", "signature": "(\tmodel: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType],\trng: Optional[numpy.random._generator.Generator] = None,\tparticles: Optional[list[dict[str, float | numpy.ndarray]]] = None,\tnparticles: Optional[int] = None,\ttemperature: float = 1.0,\t**model_data)"}, "arianna.ppl.inference.ImportanceSampling.particles": {"fullname": "arianna.ppl.inference.ImportanceSampling.particles", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.particles", "kind": "variable", "doc": "

\n", "annotation": ": list[dict[str, float | numpy.ndarray]]"}, "arianna.ppl.inference.ImportanceSampling.model": {"fullname": "arianna.ppl.inference.ImportanceSampling.model", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.model", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ImportanceSampling.model_data": {"fullname": "arianna.ppl.inference.ImportanceSampling.model_data", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.model_data", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ImportanceSampling.temperature": {"fullname": "arianna.ppl.inference.ImportanceSampling.temperature", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.temperature", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ImportanceSampling.rng": {"fullname": "arianna.ppl.inference.ImportanceSampling.rng", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.rng", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"fullname": "arianna.ppl.inference.ImportanceSampling.log_weights", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.log_weights", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ImportanceSampling.weights": {"fullname": "arianna.ppl.inference.ImportanceSampling.weights", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.weights", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.ImportanceSampling.fit": {"fullname": "arianna.ppl.inference.ImportanceSampling.fit", "modulename": "arianna.ppl.inference", "qualname": "ImportanceSampling.fit", "kind": "function", "doc": "

Sample.

\n", "signature": "(self, nsamples: int) -> arianna.ppl.inference.Chain:", "funcdef": "def"}, "arianna.ppl.inference.LaplaceApproximation": {"fullname": "arianna.ppl.inference.LaplaceApproximation", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation", "kind": "class", "doc": "

Laplace Approximation of Posterior.

\n", "bases": "InferenceEngine"}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"fullname": "arianna.ppl.inference.LaplaceApproximation.__init__", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.__init__", "kind": "function", "doc": "

\n", "signature": "(\tmodel: Callable[Concatenate[arianna.ppl.context.Context, ~P], NoneType],\ttransform: bool = True,\trng: Optional[numpy.random._generator.Generator] = None,\t**model_data)"}, "arianna.ppl.inference.LaplaceApproximation.rng": {"fullname": "arianna.ppl.inference.LaplaceApproximation.rng", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.rng", "kind": "variable", "doc": "

\n", "annotation": ": numpy.random._generator.Generator"}, "arianna.ppl.inference.LaplaceApproximation.model": {"fullname": "arianna.ppl.inference.LaplaceApproximation.model", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.model", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"fullname": "arianna.ppl.inference.LaplaceApproximation.model_data", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.model_data", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.LaplaceApproximation.transform": {"fullname": "arianna.ppl.inference.LaplaceApproximation.transform", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.transform", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.LaplaceApproximation.shaper": {"fullname": "arianna.ppl.inference.LaplaceApproximation.shaper", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.shaper", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"fullname": "arianna.ppl.inference.LaplaceApproximation.init_vec_state", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.init_vec_state", "kind": "variable", "doc": "

\n"}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"fullname": "arianna.ppl.inference.LaplaceApproximation.logprob", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.logprob", "kind": "function", "doc": "

Compute log density.

\n\n
Parameters
\n\n
    \n
  • state (State):\nDictionary containing random variables to model.
    • \n
\n\n
Returns
\n\n
    \n
  • tuple[float, State]: (Log density (float), native state and cached values (dict))
    • \n
\n", "signature": "(self, vec_state: numpy.ndarray) -> float:", "funcdef": "def"}, "arianna.ppl.inference.LaplaceApproximation.fit": {"fullname": "arianna.ppl.inference.LaplaceApproximation.fit", "modulename": "arianna.ppl.inference", "qualname": "LaplaceApproximation.fit", "kind": "function", "doc": "

Fit model with laplace approx.

\n", "signature": "(self, nsamples: int, **minimize_kwargs):", "funcdef": "def"}, "arianna.ppl.inference.BayesianOptimization": {"fullname": "arianna.ppl.inference.BayesianOptimization", "modulename": "arianna.ppl.inference", "qualname": "BayesianOptimization", "kind": "class", "doc": "

Bayesian Optimization.

\n", "bases": "InferenceEngine"}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"fullname": "arianna.ppl.inference.AdaptiveRandomWalkMetropolis", "modulename": "arianna.ppl.inference", "qualname": "AdaptiveRandomWalkMetropolis", "kind": "class", "doc": "

Adaptive Random Walk Metropolis.

\n\n
Resources
\n\n\n", "bases": "SingleWalkerMCMC"}, "arianna.ppl.shaper": {"fullname": "arianna.ppl.shaper", "modulename": "arianna.ppl.shaper", "kind": "module", "doc": "

\n"}, "arianna.ppl.shaper.Shaper": {"fullname": "arianna.ppl.shaper.Shaper", "modulename": "arianna.ppl.shaper", "qualname": "Shaper", "kind": "class", "doc": "

Shapes dict of numeric values into np.array and back.

\n"}, "arianna.ppl.shaper.Shaper.__init__": {"fullname": "arianna.ppl.shaper.Shaper.__init__", "modulename": "arianna.ppl.shaper", "qualname": "Shaper.__init__", "kind": "function", "doc": "

\n", "signature": "(shape: dict[str, tuple[int, ...]])"}, "arianna.ppl.shaper.Shaper.from_state": {"fullname": "arianna.ppl.shaper.Shaper.from_state", "modulename": "arianna.ppl.shaper", "qualname": "Shaper.from_state", "kind": "function", "doc": "

Construct a Shaper from a state.

\n", "signature": "(cls, state: dict[str, float | numpy.ndarray]):", "funcdef": "def"}, "arianna.ppl.shaper.Shaper.shape": {"fullname": "arianna.ppl.shaper.Shaper.shape", "modulename": "arianna.ppl.shaper", "qualname": "Shaper.shape", "kind": "variable", "doc": "

\n"}, "arianna.ppl.shaper.Shaper.dim": {"fullname": "arianna.ppl.shaper.Shaper.dim", "modulename": "arianna.ppl.shaper", "qualname": "Shaper.dim", "kind": "variable", "doc": "

\n"}, "arianna.ppl.shaper.Shaper.vec": {"fullname": "arianna.ppl.shaper.Shaper.vec", "modulename": "arianna.ppl.shaper", "qualname": "Shaper.vec", "kind": "function", "doc": "

Convert a state dict into a np.ndarray.

\n", "signature": "(self, state: dict[str, float | numpy.ndarray]) -> numpy.ndarray:", "funcdef": "def"}, "arianna.ppl.shaper.Shaper.unvec": {"fullname": "arianna.ppl.shaper.Shaper.unvec", "modulename": "arianna.ppl.shaper", "qualname": "Shaper.unvec", "kind": "function", "doc": "

Convert a np.ndarray back to a state dict.

\n", "signature": "(self, flat_state: numpy.ndarray) -> dict[str, float | numpy.ndarray]:", "funcdef": "def"}, "arianna.types": {"fullname": "arianna.types", "modulename": "arianna.types", "kind": "module", "doc": "

\n"}, "arianna.types.Numeric": {"fullname": "arianna.types.Numeric", "modulename": "arianna.types", "qualname": "Numeric", "kind": "variable", "doc": "

\n", "default_value": "float | numpy.ndarray"}, "arianna.types.Shape": {"fullname": "arianna.types.Shape", "modulename": "arianna.types", "qualname": "Shape", "kind": "variable", "doc": "

\n", "default_value": "tuple[int, ...]"}, "arianna.types.State": {"fullname": "arianna.types.State", "modulename": "arianna.types", "qualname": "State", "kind": "variable", "doc": "

\n", "default_value": "dict[str, float | numpy.ndarray]"}, "arianna.types.NegativeInfinityError": {"fullname": "arianna.types.NegativeInfinityError", "modulename": "arianna.types", "qualname": "NegativeInfinityError", "kind": "class", "doc": "

Common base class for all non-exit exceptions.

\n", "bases": "builtins.Exception"}, "arianna.types.NegativeParameterError": {"fullname": "arianna.types.NegativeParameterError", "modulename": "arianna.types", "qualname": "NegativeParameterError", "kind": "class", "doc": "

Common base class for all non-exit exceptions.

\n", "bases": "builtins.Exception"}, "arianna.types.InvalidBoundsError": {"fullname": "arianna.types.InvalidBoundsError", "modulename": "arianna.types", "qualname": "InvalidBoundsError", "kind": "class", "doc": "

Common base class for all non-exit exceptions.

\n", "bases": "builtins.Exception"}}, "docInfo": {"arianna": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Distribution": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "arianna.distributions.abstract.Distribution.event_shape": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Distribution.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Distribution.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Distribution.sample": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 101, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Distribution.pdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Distribution.mean": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Distribution.std": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Distribution.var": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Continuous": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.distributions.abstract.Continuous.to_real": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Continuous.to_native": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Continuous.logdetjac": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Discrete": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.distributions.abstract.Multivariate": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.distributions.abstract.Multivariate.mean": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Multivariate.std": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Multivariate.var": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Univariate": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.distributions.abstract.Univariate.event_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Univariate.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Univariate.sample": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 101, "bases": 0, "doc": 3}, "arianna.distributions.abstract.UnivariateContinuous": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 32}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Positive": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.distributions.abstract.Positive.to_real": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Positive.to_native": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Positive.logdetjac": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Positive.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.LowerUpperBounded": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 3, "doc": 16}, "arianna.distributions.abstract.LowerUpperBounded.lower": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.LowerUpperBounded.upper": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.LowerUpperBounded.range": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.MultivariateContinuous": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 32}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 3}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Real": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Real.to_real": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Real.to_native": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.Real.logdetjac": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.abstract.UnivariateReal": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "arianna.distributions.abstract.MultivariateReal": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "arianna.distributions.distributions": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.IndependentRagged": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Independent": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Independent.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Independent.dists": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Independent.is_same_family": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Independent.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 52, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Independent.sample": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 30, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Uniform": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Uniform.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Uniform.logcdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Uniform.cdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Uniform.mode": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Uniform.median": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Uniform.mean": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Uniform.var": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Beta.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 66, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta.a": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta.b": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta.mode": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta.logcdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta.cdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta.mean": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Beta.var": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.ScaledBeta.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 110, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta.a": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta.b": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta.base_dist": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta.cdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta.mean": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.ScaledBeta.var": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Gamma.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 66, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.from_mean_std": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.shape": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.scale": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.logcdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.cdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.survival": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.mean": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.var": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Gamma.mode": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.InverseGamma.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 66, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.shape": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.scale": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.mean": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.var": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.mode": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.logcdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.InverseGamma.cdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.LogNormal.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 66, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.mu": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.sigma": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.mean": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.var": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.mode": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.median": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.logcdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.LogNormal.cdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Weibull": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Gumbel": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Logistic": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.LogLogistic": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Normal": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Normal.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 82, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.loc": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.scale": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.logcdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.cdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.survival": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.mean": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.std": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.var": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.mode": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Normal.median": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.MvNormal.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 70, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.mean": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.cov": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.cov_inv": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.L": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.event_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"qualname": 5, "fullname": 8, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"qualname": 4, "fullname": 7, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.var": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "arianna.distributions.distributions.MvNormal.sample": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 101, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "arianna.distributions.distributions.Dirichlet.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.concentration": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.event_shape": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.sample": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 101, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.to_real": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.to_native": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.cov": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.mean": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.var": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.distributions.distributions.Dirichlet.std": {"qualname": 2, "fullname": 5, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.BasicDistribution": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 134}, "arianna.ppl.context.BasicDistribution.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 18, "bases": 0, "doc": 3}, "arianna.ppl.context.BasicDistribution.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.ppl.context.BasicDistribution.sample": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 101, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformableDistribution": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 134}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformableDistribution.to_real": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformableDistribution.to_native": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformableDistribution.logpdf": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "arianna.ppl.context.Context": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "arianna.ppl.context.Context.result": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.Context.state": {"qualname": 2, "fullname": 5, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.Context.run": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "arianna.ppl.context.Context.rv": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 104, "bases": 0, "doc": 3}, "arianna.ppl.context.Context.cached": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndPriorSample": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndPriorSample.run": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 102, "bases": 0, "doc": 6}, "arianna.ppl.context.LogprobAndPriorSample.result": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndPriorSample.rng": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 90, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndTrace": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.ppl.context.LogprobAndTrace.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndTrace.run": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 96, "bases": 0, "doc": 63}, "arianna.ppl.context.LogprobAndTrace.state": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndTrace.result": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndTrace.rv": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 90, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndTrace.cached": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 3}, "arianna.ppl.context.Predictive": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.ppl.context.Predictive.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 108, "bases": 0, "doc": 3}, "arianna.ppl.context.Predictive.run": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 156, "bases": 0, "doc": 3}, "arianna.ppl.context.Predictive.state": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.Predictive.rng": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.Predictive.return_cached": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.Predictive.result": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.Predictive.rv": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 104, "bases": 0, "doc": 3}, "arianna.ppl.context.Predictive.cached": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 94}, "arianna.ppl.context.TransformedLogprobAndTrace": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 51}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 96, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 90, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedPredictive": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 180}, "arianna.ppl.context.TransformedPredictive.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 108, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedPredictive.run": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 130, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedPredictive.state": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedPredictive.rng": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedPredictive.return_cached": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedPredictive.result": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedPredictive.rv": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 104, "bases": 0, "doc": 3}, "arianna.ppl.context.TransformedPredictive.cached": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 94}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 102, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 90, "bases": 0, "doc": 3}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 3}, "arianna.ppl.diagnostics": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.diagnostics.ess_kish": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 50}, "arianna.ppl.inference": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.P": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.Model": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.Logprob": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 12, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.Chain": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 43}, "arianna.ppl.inference.Chain.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 3}, "arianna.ppl.inference.Chain.states": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.Chain.names": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.Chain.get": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 59}, "arianna.ppl.inference.Chain.bundle": {"qualname": 2, "fullname": 5, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 28}, "arianna.ppl.inference.Chain.subset": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 86}, "arianna.ppl.inference.InferenceEngine": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 7}, "arianna.ppl.inference.InferenceEngine.rng": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.InferenceEngine.fit": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 5}, "arianna.ppl.inference.MCMC": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 7}, "arianna.ppl.inference.MCMC.model": {"qualname": 2, "fullname": 5, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.MCMC.model_data": {"qualname": 3, "fullname": 6, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.MCMC.nsamples": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.MCMC.burn": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.MCMC.thin": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.MCMC.transform": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.MCMC.logprob_history": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.MCMC.step": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 10}, "arianna.ppl.inference.MCMC.fit": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 22}, "arianna.ppl.inference.MCMC.logprob": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 82, "bases": 0, "doc": 50}, "arianna.ppl.inference.SingleWalkerMCMC": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 7}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"qualname": 3, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"qualname": 3, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 47, "bases": 0, "doc": 35}, "arianna.ppl.inference.RandomWalkMetropolis": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 515}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 201, "bases": 0, "doc": 3}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"qualname": 3, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"qualname": 3, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.RandomWalkMetropolis.proposal": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 47, "bases": 0, "doc": 31}, "arianna.ppl.inference.AffineInvariantMCMC": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 6}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"qualname": 3, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"qualname": 3, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 88, "bases": 0, "doc": 57}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 34}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 71, "bases": 0, "doc": 7}, "arianna.ppl.inference.AIES": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 209}, "arianna.ppl.inference.AIES.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 251, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.default_temperature_fn": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 5}, "arianna.ppl.inference.AIES.model": {"qualname": 2, "fullname": 5, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.nwalkers": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.transform": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.rng": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.accept": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.a": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.model_data": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.temperature_fn": {"qualname": 3, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.init_state": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.AIES.step": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 39}, "arianna.ppl.inference.ParallelAIES": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 34}, "arianna.ppl.inference.ParallelAIES.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 243, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.executor": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.model": {"qualname": 2, "fullname": 5, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.transform": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.rng": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.rngs": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.accept": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.a": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.model_data": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.init_state": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ParallelAIES.step": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 55}, "arianna.ppl.inference.ImportanceSampling": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 5}, "arianna.ppl.inference.ImportanceSampling.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 195, "bases": 0, "doc": 3}, "arianna.ppl.inference.ImportanceSampling.particles": {"qualname": 2, "fullname": 5, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ImportanceSampling.model": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ImportanceSampling.model_data": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ImportanceSampling.temperature": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ImportanceSampling.rng": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ImportanceSampling.weights": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.ImportanceSampling.fit": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 4}, "arianna.ppl.inference.LaplaceApproximation": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 7}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 121, "bases": 0, "doc": 3}, "arianna.ppl.inference.LaplaceApproximation.rng": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.LaplaceApproximation.model": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.LaplaceApproximation.transform": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.LaplaceApproximation.shaper": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 30, "bases": 0, "doc": 50}, "arianna.ppl.inference.LaplaceApproximation.fit": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 8}, "arianna.ppl.inference.BayesianOptimization": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 5}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 21}, "arianna.ppl.shaper": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.shaper.Shaper": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 13}, "arianna.ppl.shaper.Shaper.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 3}, "arianna.ppl.shaper.Shaper.from_state": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 9}, "arianna.ppl.shaper.Shaper.shape": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.shaper.Shaper.dim": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.ppl.shaper.Shaper.vec": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 52, "bases": 0, "doc": 11}, "arianna.ppl.shaper.Shaper.unvec": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 53, "bases": 0, "doc": 12}, "arianna.types": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "arianna.types.Numeric": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 4, "signature": 0, "bases": 0, "doc": 3}, "arianna.types.Shape": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "arianna.types.State": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "arianna.types.NegativeInfinityError": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 11}, "arianna.types.NegativeParameterError": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 11}, "arianna.types.InvalidBoundsError": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 11}}, "length": 356, "save": true}, "index": {"qualname": {"root": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}}, "df": 23, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Distribution.var": {"tf": 1}}, "df": 9}}}}}}}}, "s": {"docs": {"arianna.distributions.distributions.Independent.dists": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Discrete": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.concentration": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1}}, "df": 16}}}}}}}, "m": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.shaper.Shaper.dim": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}}, "df": 1}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}}, "df": 6}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}}, "df": 6}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.ParallelAIES.executor": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1}, "arianna.ppl.shaper.Shaper.shape": {"tf": 1}, "arianna.types.Shape": {"tf": 1}}, "df": 21, "r": {"docs": {"arianna.ppl.inference.LaplaceApproximation.shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.shape": {"tf": 1}, "arianna.ppl.shaper.Shaper.dim": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 8}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}}, "df": 6}}}, "e": {"docs": {"arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Normal.std": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1}}, "df": 7}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.Predictive.state": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.state": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.types.State": {"tf": 1}}, "df": 17, "s": {"docs": {"arianna.ppl.inference.Chain.states": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 6}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1}, "arianna.distributions.distributions.Normal.survival": {"tf": 1}}, "df": 3}}}}}}, "m": {"docs": {"arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1}}, "df": 1}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.Gamma.scale": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.scale": {"tf": 1}, "arianna.distributions.distributions.Normal.scale": {"tf": 1}}, "df": 3, "d": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.a": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.b": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1}}, "df": 10}}}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.LogNormal.sigma": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}, "b": {"docs": {"arianna.distributions.distributions.Beta.b": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.b": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1}}, "df": 13}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.BayesianOptimization": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.Beta.a": {"tf": 1}, "arianna.distributions.distributions.Beta.b": {"tf": 1}, "arianna.distributions.distributions.Beta.mode": {"tf": 1}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1}, "arianna.distributions.distributions.Beta.mean": {"tf": 1}, "arianna.distributions.distributions.Beta.var": {"tf": 1}}, "df": 10}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain.bundle": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.MCMC.burn": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {"arianna.distributions.distributions.MvNormal.L": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "g": {"docs": {"arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}}, "df": 12}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 5, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.result": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rng": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}}, "df": 7}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}}, "df": 7}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {"arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}}, "df": 9}}}}}}, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1}}, "df": 8}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mu": {"tf": 1}, "arianna.distributions.distributions.LogNormal.sigma": {"tf": 1}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1}}, "df": 12}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.distributions.distributions.Logistic": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.distributions.distributions.LogLogistic": {"tf": 1}}, "df": 1}}}}}}}}}, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.LowerUpperBounded.lower": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.lower": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.upper": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.range": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}, "c": {"docs": {"arianna.distributions.distributions.Normal.loc": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.LaplaceApproximation": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.transform": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.shaper": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 10}}}}}}}}}}}}}}}}}}}}, "p": {"docs": {"arianna.ppl.inference.P": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.Distribution.pdf": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}}, "df": 5}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}}, "df": 5}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.Predictive.state": {"tf": 1}, "arianna.ppl.context.Predictive.rng": {"tf": 1}, "arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.Predictive.result": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}}, "df": 9}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.proposal": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ParallelAIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.executor": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rng": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rngs": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.accept": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 13}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1}, "arianna.distributions.distributions.Beta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1}, "arianna.distributions.distributions.Normal.mean": {"tf": 1}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1}}, "df": 16}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.distributions.Uniform.median": {"tf": 1}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1}, "arianna.distributions.distributions.Normal.median": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {"arianna.distributions.distributions.LogNormal.mu": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}}, "df": 4, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}}, "df": 4}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.MultivariateReal": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.Uniform.mode": {"tf": 1}, "arianna.distributions.distributions.Beta.mode": {"tf": 1}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1}, "arianna.distributions.distributions.Normal.mode": {"tf": 1}}, "df": 6, "l": {"docs": {"arianna.ppl.inference.Model": {"tf": 1}, "arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}}, "df": 13}}}}, "v": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}, "arianna.distributions.distributions.MvNormal.L": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}}, "df": 13}}}}}}}, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.MCMC.nsamples": {"tf": 1}, "arianna.ppl.inference.MCMC.burn": {"tf": 1}, "arianna.ppl.inference.MCMC.thin": {"tf": 1}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}}, "df": 15}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.Distribution.var": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}, "arianna.distributions.distributions.Uniform.var": {"tf": 1}, "arianna.distributions.distributions.Beta.var": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.var": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1}, "arianna.distributions.distributions.Normal.var": {"tf": 1}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1}}, "df": 11}}, "e": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.Context.result": {"tf": 1}, "arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.context.Context.run": {"tf": 1}, "arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.Context.cached": {"tf": 1}}, "df": 6}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.distributions.Dirichlet.concentration": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1}}, "df": 2}}}}}}}}}}}, "v": {"docs": {"arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1}}, "df": 5}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1}}, "df": 8}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.context.Context.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}}, "df": 9}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.states": {"tf": 1}, "arianna.ppl.inference.Chain.names": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 7}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}}, "df": 12}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.transform": {"tf": 1}}, "df": 6, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.state": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rng": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.result": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 9}}}}}}}}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.MCMC.thin": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.temperature": {"tf": 1}}, "df": 3}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.Real": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}}, "df": 9}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.Context.result": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.result": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.Predictive.result": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.result": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"tf": 1}}, "df": 7}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.LowerUpperBounded.range": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.proposal": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}}, "df": 10}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.Context.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}}, "df": 7}}, "v": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}}, "df": 7}, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.context.LogprobAndPriorSample.rng": {"tf": 1}, "arianna.ppl.context.Predictive.rng": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rng": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.AIES.rng": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rng": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.rng": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}}, "df": 10, "s": {"docs": {"arianna.ppl.inference.ParallelAIES.rngs": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}}, "df": 6}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.Chain.names": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.Normal.loc": {"tf": 1}, "arianna.distributions.distributions.Normal.scale": {"tf": 1}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.survival": {"tf": 1}, "arianna.distributions.distributions.Normal.mean": {"tf": 1}, "arianna.distributions.distributions.Normal.std": {"tf": 1}, "arianna.distributions.distributions.Normal.var": {"tf": 1}, "arianna.distributions.distributions.Normal.mode": {"tf": 1}, "arianna.distributions.distributions.Normal.median": {"tf": 1}}, "df": 14}}}}}, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.MCMC.nsamples": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}}, "df": 3}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.types.Numeric": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.types.NegativeInfinityError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.types.NegativeParameterError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}}, "df": 4, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}}, "df": 6}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.UnivariateReal": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1}, "arianna.distributions.distributions.Uniform.median": {"tf": 1}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1}, "arianna.distributions.distributions.Uniform.var": {"tf": 1}}, "df": 9}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.LowerUpperBounded.upper": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.dists": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}}, "df": 6, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.distributions.IndependentRagged": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}}, "df": 29}}, "v": {"docs": {"arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.scale": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1}}, "df": 11}}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.InferenceEngine": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "s": {"docs": {"arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.ImportanceSampling": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.temperature": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.rng": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}}, "df": 10}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}}, "df": 5}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 5}}, "n": {"docs": {"arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}}, "df": 2}}, "a": {"docs": {"arianna.distributions.distributions.Beta.a": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.a": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}}, "df": 13}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}, "arianna.ppl.inference.AIES.accept": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.accept": {"tf": 1}}, "df": 4}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.AIES.rng": {"tf": 1}, "arianna.ppl.inference.AIES.accept": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}}, "df": 13}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Gamma.shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.scale": {"tf": 1}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1}, "arianna.distributions.distributions.Gamma.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1}}, "df": 12}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.Gumbel": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Chain.get": {"tf": 1}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.Weibull": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.weights": {"tf": 1}}, "df": 2}}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}}, "df": 1}}}}}}}}}, "fullname": {"root": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}}, "df": 23, "a": {"docs": {"arianna.distributions.distributions.Beta.a": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.a": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}}, "df": 5, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {"arianna": {"tf": 1}, "arianna.distributions": {"tf": 1}, "arianna.distributions.abstract": {"tf": 1}, "arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Distribution.var": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.lower": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.upper": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.range": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}, "arianna.distributions.abstract.Real": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.dists": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1}, "arianna.distributions.distributions.Uniform.median": {"tf": 1}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1}, "arianna.distributions.distributions.Uniform.var": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.Beta.a": {"tf": 1}, "arianna.distributions.distributions.Beta.b": {"tf": 1}, "arianna.distributions.distributions.Beta.mode": {"tf": 1}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1}, "arianna.distributions.distributions.Beta.mean": {"tf": 1}, "arianna.distributions.distributions.Beta.var": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.a": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.b": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Gamma.shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.scale": {"tf": 1}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1}, "arianna.distributions.distributions.Gamma.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.scale": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mu": {"tf": 1}, "arianna.distributions.distributions.LogNormal.sigma": {"tf": 1}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.Normal.loc": {"tf": 1}, "arianna.distributions.distributions.Normal.scale": {"tf": 1}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.survival": {"tf": 1}, "arianna.distributions.distributions.Normal.mean": {"tf": 1}, "arianna.distributions.distributions.Normal.std": {"tf": 1}, "arianna.distributions.distributions.Normal.var": {"tf": 1}, "arianna.distributions.distributions.Normal.mode": {"tf": 1}, "arianna.distributions.distributions.Normal.median": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}, "arianna.distributions.distributions.MvNormal.L": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.concentration": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1}, "arianna.ppl": {"tf": 1}, "arianna.ppl.context": {"tf": 1}, "arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.Context.result": {"tf": 1}, "arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.context.Context.run": {"tf": 1}, "arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.Context.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.result": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rng": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.Predictive.state": {"tf": 1}, "arianna.ppl.context.Predictive.rng": {"tf": 1}, "arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.Predictive.result": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.state": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rng": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.result": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}, "arianna.ppl.diagnostics": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference": {"tf": 1}, "arianna.ppl.inference.P": {"tf": 1}, "arianna.ppl.inference.Model": {"tf": 1}, "arianna.ppl.inference.Logprob": {"tf": 1}, "arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.states": {"tf": 1}, "arianna.ppl.inference.Chain.names": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.InferenceEngine": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}, "arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.MCMC.nsamples": {"tf": 1}, "arianna.ppl.inference.MCMC.burn": {"tf": 1}, "arianna.ppl.inference.MCMC.thin": {"tf": 1}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1}, "arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.proposal": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.AIES.rng": {"tf": 1}, "arianna.ppl.inference.AIES.accept": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.executor": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rng": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rngs": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.accept": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.temperature": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.rng": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.transform": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.shaper": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}, "arianna.ppl.inference.BayesianOptimization": {"tf": 1}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}, "arianna.ppl.shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.shape": {"tf": 1}, "arianna.ppl.shaper.Shaper.dim": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}, "arianna.types": {"tf": 1}, "arianna.types.Numeric": {"tf": 1}, "arianna.types.Shape": {"tf": 1}, "arianna.types.State": {"tf": 1}, "arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 356}}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract": {"tf": 1}, "arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Distribution.var": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.lower": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.upper": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.range": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}, "arianna.distributions.abstract.Real": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}}, "df": 52}}}}}}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}}, "df": 13}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}, "arianna.ppl.inference.AIES.accept": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.accept": {"tf": 1}}, "df": 4}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.AIES.rng": {"tf": 1}, "arianna.ppl.inference.AIES.accept": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}}, "df": 13}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Distribution.var": {"tf": 1}}, "df": 9, "s": {"docs": {"arianna.distributions": {"tf": 1}, "arianna.distributions.abstract": {"tf": 1}, "arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Distribution.var": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.lower": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.upper": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.range": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}, "arianna.distributions.abstract.Real": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.dists": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.sample": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.median": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.a": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.b": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.a": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.b": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.scale": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.scale": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.mu": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.sigma": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Weibull": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gumbel": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Logistic": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogLogistic": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.loc": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.scale": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.survival": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.std": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.median": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.L": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.concentration": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1.4142135623730951}}, "df": 172}}}}}}}}}, "s": {"docs": {"arianna.distributions.distributions.Independent.dists": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Discrete": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.concentration": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1}}, "df": 16}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.diagnostics": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 2}}}}}}}}}, "m": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.shaper.Shaper.dim": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}}, "df": 1}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}}, "df": 6}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}}, "df": 6}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.ParallelAIES.executor": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution.event_shape": {"tf": 1}, "arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1}, "arianna.ppl.shaper.Shaper.shape": {"tf": 1}, "arianna.types.Shape": {"tf": 1}}, "df": 21, "r": {"docs": {"arianna.ppl.inference.LaplaceApproximation.shaper": {"tf": 1}, "arianna.ppl.shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.shape": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.dim": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1.4142135623730951}}, "df": 9}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}}, "df": 6}}}, "e": {"docs": {"arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Normal.std": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1}}, "df": 7}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.Predictive.state": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.state": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.types.State": {"tf": 1}}, "df": 17, "s": {"docs": {"arianna.ppl.inference.Chain.states": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 6}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1}, "arianna.distributions.distributions.Normal.survival": {"tf": 1}}, "df": 3}}}}}}, "m": {"docs": {"arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1}}, "df": 1}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.Gamma.scale": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.scale": {"tf": 1}, "arianna.distributions.distributions.Normal.scale": {"tf": 1}}, "df": 3, "d": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.a": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.b": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1}}, "df": 10}}}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.LogNormal.sigma": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}, "b": {"docs": {"arianna.distributions.distributions.Beta.b": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.b": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1}}, "df": 13}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.BayesianOptimization": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.Beta.a": {"tf": 1}, "arianna.distributions.distributions.Beta.b": {"tf": 1}, "arianna.distributions.distributions.Beta.mode": {"tf": 1}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1}, "arianna.distributions.distributions.Beta.mean": {"tf": 1}, "arianna.distributions.distributions.Beta.var": {"tf": 1}}, "df": 10}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain.bundle": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.MCMC.burn": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {"arianna.distributions.distributions.MvNormal.L": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "g": {"docs": {"arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}}, "df": 12}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 5, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.result": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rng": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}}, "df": 7}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}}, "df": 7}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {"arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}}, "df": 9}}}}}}, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1}}, "df": 8}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mu": {"tf": 1}, "arianna.distributions.distributions.LogNormal.sigma": {"tf": 1}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1}}, "df": 12}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.distributions.distributions.Logistic": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.distributions.distributions.LogLogistic": {"tf": 1}}, "df": 1}}}}}}}}}, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.LowerUpperBounded.lower": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.lower": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.upper": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.range": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}, "c": {"docs": {"arianna.distributions.distributions.Normal.loc": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.LaplaceApproximation": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.transform": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.shaper": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 10}}}}}}}}}}}}}}}}}}}}, "p": {"docs": {"arianna.ppl.inference.P": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.Distribution.pdf": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}}, "df": 5}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}}, "df": 5}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl": {"tf": 1}, "arianna.ppl.context": {"tf": 1}, "arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.Context.result": {"tf": 1}, "arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.context.Context.run": {"tf": 1}, "arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.Context.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.result": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rng": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.Predictive.state": {"tf": 1}, "arianna.ppl.context.Predictive.rng": {"tf": 1}, "arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.Predictive.result": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.state": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rng": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.result": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}, "arianna.ppl.diagnostics": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference": {"tf": 1}, "arianna.ppl.inference.P": {"tf": 1}, "arianna.ppl.inference.Model": {"tf": 1}, "arianna.ppl.inference.Logprob": {"tf": 1}, "arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.states": {"tf": 1}, "arianna.ppl.inference.Chain.names": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.InferenceEngine": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}, "arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.MCMC.nsamples": {"tf": 1}, "arianna.ppl.inference.MCMC.burn": {"tf": 1}, "arianna.ppl.inference.MCMC.thin": {"tf": 1}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1}, "arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.proposal": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.AIES.rng": {"tf": 1}, "arianna.ppl.inference.AIES.accept": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.executor": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rng": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rngs": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.accept": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.temperature": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.rng": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.transform": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.shaper": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}, "arianna.ppl.inference.BayesianOptimization": {"tf": 1}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}, "arianna.ppl.shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.shape": {"tf": 1}, "arianna.ppl.shaper.Shaper.dim": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 176}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.Predictive.state": {"tf": 1}, "arianna.ppl.context.Predictive.rng": {"tf": 1}, "arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.Predictive.result": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}}, "df": 9}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.proposal": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ParallelAIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.executor": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rng": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rngs": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.accept": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 13}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1}, "arianna.distributions.distributions.Beta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1}, "arianna.distributions.distributions.Normal.mean": {"tf": 1}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1}}, "df": 16}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.distributions.Uniform.median": {"tf": 1}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1}, "arianna.distributions.distributions.Normal.median": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {"arianna.distributions.distributions.LogNormal.mu": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}}, "df": 4, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}}, "df": 4}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.MultivariateReal": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.Uniform.mode": {"tf": 1}, "arianna.distributions.distributions.Beta.mode": {"tf": 1}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1}, "arianna.distributions.distributions.Normal.mode": {"tf": 1}}, "df": 6, "l": {"docs": {"arianna.ppl.inference.Model": {"tf": 1}, "arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}}, "df": 13}}}}, "v": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}, "arianna.distributions.distributions.MvNormal.L": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}}, "df": 13}}}}}}}, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.MCMC.nsamples": {"tf": 1}, "arianna.ppl.inference.MCMC.burn": {"tf": 1}, "arianna.ppl.inference.MCMC.thin": {"tf": 1}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}}, "df": 15}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.Distribution.var": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}, "arianna.distributions.distributions.Uniform.var": {"tf": 1}, "arianna.distributions.distributions.Beta.var": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.var": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1}, "arianna.distributions.distributions.Normal.var": {"tf": 1}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1}}, "df": 11}}, "e": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context": {"tf": 1}, "arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.result": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.state": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.result": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rng": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.Predictive.state": {"tf": 1}, "arianna.ppl.context.Predictive.rng": {"tf": 1}, "arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.Predictive.result": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.state": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rng": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.result": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}}, "df": 63}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.distributions.Dirichlet.concentration": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1}}, "df": 2}}}}}}}}}}}, "v": {"docs": {"arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1}}, "df": 5}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1}}, "df": 8}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.context.Context.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}}, "df": 9}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.states": {"tf": 1}, "arianna.ppl.inference.Chain.names": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 7}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}}, "df": 12}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.transform": {"tf": 1}}, "df": 6, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.state": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rng": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.result": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 9}}}}}}}}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.MCMC.thin": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.temperature": {"tf": 1}}, "df": 3}}}}}}}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.types": {"tf": 1}, "arianna.types.Numeric": {"tf": 1}, "arianna.types.Shape": {"tf": 1}, "arianna.types.State": {"tf": 1}, "arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 7}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.Real": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}}, "df": 9}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.Context.result": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.result": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.Predictive.result": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.result": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"tf": 1}}, "df": 7}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.Predictive.return_cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.LowerUpperBounded.range": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.proposal": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}}, "df": 10}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.Context.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}}, "df": 7}}, "v": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}}, "df": 7}, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.context.LogprobAndPriorSample.rng": {"tf": 1}, "arianna.ppl.context.Predictive.rng": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rng": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.AIES.rng": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rng": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.rng": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}}, "df": 10, "s": {"docs": {"arianna.ppl.inference.ParallelAIES.rngs": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}}, "df": 6}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.Chain.names": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.Normal.loc": {"tf": 1}, "arianna.distributions.distributions.Normal.scale": {"tf": 1}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.survival": {"tf": 1}, "arianna.distributions.distributions.Normal.mean": {"tf": 1}, "arianna.distributions.distributions.Normal.std": {"tf": 1}, "arianna.distributions.distributions.Normal.var": {"tf": 1}, "arianna.distributions.distributions.Normal.mode": {"tf": 1}, "arianna.distributions.distributions.Normal.median": {"tf": 1}}, "df": 14}}}}}, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.MCMC.nsamples": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}}, "df": 3}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.types.Numeric": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.types.NegativeInfinityError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.types.NegativeParameterError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}}, "df": 4, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}}, "df": 6}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.UnivariateReal": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1}, "arianna.distributions.distributions.Uniform.median": {"tf": 1}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1}, "arianna.distributions.distributions.Uniform.var": {"tf": 1}}, "df": 9}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.LowerUpperBounded.upper": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.dists": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}}, "df": 6, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.distributions.IndependentRagged": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}}, "df": 29}}, "v": {"docs": {"arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.scale": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1}}, "df": 11}}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference": {"tf": 1}, "arianna.ppl.inference.P": {"tf": 1}, "arianna.ppl.inference.Model": {"tf": 1}, "arianna.ppl.inference.Logprob": {"tf": 1}, "arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.states": {"tf": 1}, "arianna.ppl.inference.Chain.names": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.InferenceEngine": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}, "arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.MCMC.nsamples": {"tf": 1}, "arianna.ppl.inference.MCMC.burn": {"tf": 1}, "arianna.ppl.inference.MCMC.thin": {"tf": 1}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1}, "arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.proposal": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.AIES.rng": {"tf": 1}, "arianna.ppl.inference.AIES.accept": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.AIES.model_data": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.init_state": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.executor": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rng": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.rngs": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.accept": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.temperature": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.rng": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.transform": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.shaper": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}, "arianna.ppl.inference.BayesianOptimization": {"tf": 1}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 102, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.InferenceEngine": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "s": {"docs": {"arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.ImportanceSampling": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.temperature": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.rng": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}}, "df": 10}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}}, "df": 5}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 5}}, "n": {"docs": {"arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}}, "df": 2}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Gamma.shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.scale": {"tf": 1}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1}, "arianna.distributions.distributions.Gamma.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1}}, "df": 12}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.Gumbel": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Chain.get": {"tf": 1}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.Weibull": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.weights": {"tf": 1}}, "df": 2}}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}}, "df": 1}}}}}}}}}, "annotation": {"root": {"docs": {"arianna.distributions.abstract.Distribution.mean": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Distribution.std": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Distribution.var": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.median": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.mean": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.std": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.var": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.mode": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.median": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}, "arianna.distributions.distributions.MvNormal.L": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1}, "arianna.ppl.context.Context.result": {"tf": 1}, "arianna.ppl.context.Context.state": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.MCMC.nsamples": {"tf": 1}, "arianna.ppl.inference.MCMC.burn": {"tf": 1}, "arianna.ppl.inference.MCMC.thin": {"tf": 1}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1}, "arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}}, "df": 88, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Distribution.var": {"tf": 1}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1}, "arianna.distributions.distributions.Uniform.median": {"tf": 1}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1}, "arianna.distributions.distributions.Uniform.var": {"tf": 1}, "arianna.distributions.distributions.Beta.mode": {"tf": 1}, "arianna.distributions.distributions.Beta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1}, "arianna.distributions.distributions.Gamma.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1}, "arianna.distributions.distributions.Normal.mean": {"tf": 1}, "arianna.distributions.distributions.Normal.std": {"tf": 1}, "arianna.distributions.distributions.Normal.var": {"tf": 1}, "arianna.distributions.distributions.Normal.mode": {"tf": 1}, "arianna.distributions.distributions.Normal.median": {"tf": 1}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1}, "arianna.ppl.inference.AIES.a": {"tf": 1}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}}, "df": 39}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Distribution.var": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1}, "arianna.distributions.distributions.Uniform.median": {"tf": 1}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1}, "arianna.distributions.distributions.Uniform.var": {"tf": 1}, "arianna.distributions.distributions.Beta.mode": {"tf": 1}, "arianna.distributions.distributions.Beta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1}, "arianna.distributions.distributions.Gamma.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1}, "arianna.distributions.distributions.Normal.mean": {"tf": 1}, "arianna.distributions.distributions.Normal.std": {"tf": 1}, "arianna.distributions.distributions.Normal.var": {"tf": 1}, "arianna.distributions.distributions.Normal.mode": {"tf": 1}, "arianna.distributions.distributions.Normal.median": {"tf": 1}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}, "arianna.distributions.distributions.MvNormal.L": {"tf": 1}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1}, "arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}}, "df": 52}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"arianna.distributions.abstract.Distribution.mean": {"tf": 1}, "arianna.distributions.abstract.Distribution.std": {"tf": 1}, "arianna.distributions.abstract.Distribution.var": {"tf": 1}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1}, "arianna.distributions.distributions.Uniform.median": {"tf": 1}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1}, "arianna.distributions.distributions.Uniform.var": {"tf": 1}, "arianna.distributions.distributions.Beta.mode": {"tf": 1}, "arianna.distributions.distributions.Beta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1}, "arianna.distributions.distributions.Gamma.var": {"tf": 1}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1}, "arianna.distributions.distributions.Normal.mean": {"tf": 1}, "arianna.distributions.distributions.Normal.std": {"tf": 1}, "arianna.distributions.distributions.Normal.var": {"tf": 1}, "arianna.distributions.distributions.Normal.mode": {"tf": 1}, "arianna.distributions.distributions.Normal.median": {"tf": 1}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1}, "arianna.distributions.distributions.MvNormal.L": {"tf": 1}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1}, "arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}}, "df": 49}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}}, "df": 3}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract.Univariate.event_shape": {"tf": 1}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1}}, "df": 12}}}}}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.MCMC.model_data": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.context.Context.result": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}}, "df": 2}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.context.Context.state": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1}}, "df": 7}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"arianna.ppl.inference.InferenceEngine.rng": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1}}, "df": 3}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.InferenceEngine.rng": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AIES.temperature_fn": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.MCMC.model": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.model": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}, "p": {"docs": {"arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}}, "df": 3, "p": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.MCMC.model": {"tf": 1}, "arianna.ppl.inference.AIES.model": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.MCMC.nsamples": {"tf": 1}, "arianna.ppl.inference.MCMC.burn": {"tf": 1}, "arianna.ppl.inference.MCMC.thin": {"tf": 1}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1}}, "df": 9}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.MCMC.transform": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1}, "arianna.ppl.inference.AIES.transform": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.MCMC.logprob_history": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1}}, "df": 3}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1}}, "df": 1}}}}}}}}}}, "default_value": {"root": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1.4142135623730951}, "arianna.types.Numeric": {"tf": 1}, "arianna.types.Shape": {"tf": 1}, "arianna.types.State": {"tf": 1}}, "df": 4, "p": {"docs": {"arianna.ppl.inference.P": {"tf": 1}, "arianna.ppl.inference.Model": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.Model": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.Model": {"tf": 1}, "arianna.ppl.inference.Logprob": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.types.Shape": {"tf": 1}}, "df": 1}}}}}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.Model": {"tf": 1}}, "df": 1}}}}}}, "[": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.inference.Model": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Model": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Model": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1.4142135623730951}, "arianna.types.Numeric": {"tf": 1}, "arianna.types.State": {"tf": 1}}, "df": 3}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1.4142135623730951}, "arianna.types.Numeric": {"tf": 1}, "arianna.types.State": {"tf": 1}}, "df": 3}}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1.4142135623730951}, "arianna.types.Numeric": {"tf": 1}, "arianna.types.State": {"tf": 1}}, "df": 3}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.Logprob": {"tf": 1}, "arianna.types.State": {"tf": 1}}, "df": 2}}}}}}}}}}, "signature": {"root": {"0": {"docs": {"arianna.distributions.distributions.Normal.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}}, "df": 5, "x": {"1": {"0": {"3": {"docs": {}, "df": 0, "f": {"8": {"docs": {}, "df": 0, "e": {"9": {"6": {"0": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "c": {"0": {"docs": {"arianna.distributions.abstract.Univariate.sample": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}, "f": {"docs": {}, "df": 0, "d": {"8": {"0": {"docs": {"arianna.distributions.distributions.MvNormal.sample": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}}, "4": {"0": {"1": {"docs": {}, "df": 0, "c": {"0": {"4": {"0": {"docs": {"arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "3": {"docs": {}, "df": 0, "c": {"0": {"docs": {"arianna.ppl.context.BasicDistribution.sample": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "5": {"8": {"6": {"1": {"0": {"0": {"0": {"docs": {"arianna.ppl.inference.AIES.__init__": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "1": {"docs": {}, "df": 0, "c": {"0": {"docs": {"arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "1": {"0": {"docs": {"arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 2}, "docs": {"arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}}, "df": 3}, "2": {"docs": {"arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 2}, "docs": {"arianna.distributions.abstract.Distribution.logpdf": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Distribution.sample": {"tf": 9.219544457292887}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Univariate.sample": {"tf": 9.219544457292887}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 6.164414002968976}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 6.164414002968976}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 6.164414002968976}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 6.164414002968976}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Positive.to_real": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Positive.to_native": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 6.164414002968976}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 6.164414002968976}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 6.164414002968976}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 6.164414002968976}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 6.164414002968976}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 5.744562646538029}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 4}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 4}, "arianna.distributions.abstract.Real.to_real": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Real.to_native": {"tf": 6.164414002968976}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Independent.__init__": {"tf": 5.385164807134504}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 6.082762530298219}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 6.557438524302}, "arianna.distributions.distributions.Independent.sample": {"tf": 5}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 4.242640687119285}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Beta.__init__": {"tf": 7.416198487095663}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Beta.cdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 9.539392014169456}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 7.416198487095663}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 5.656854249492381}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Gamma.survival": {"tf": 6.164414002968976}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 7.416198487095663}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 5.656854249492381}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 7.416198487095663}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 5.656854249492381}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Normal.__init__": {"tf": 8.18535277187245}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Normal.cdf": {"tf": 6.164414002968976}, "arianna.distributions.distributions.Normal.survival": {"tf": 6.164414002968976}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 7.681145747868608}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 3.7416573867739413}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 9.219544457292887}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 5.477225575051661}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 5.744562646538029}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 9.219544457292887}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 5.744562646538029}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 5.744562646538029}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 5.744562646538029}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 4}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 6.164414002968976}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 9.219544457292887}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 6.164414002968976}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 6.164414002968976}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 6.164414002968976}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 6.164414002968976}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 6.164414002968976}, "arianna.ppl.context.Context.run": {"tf": 3.1622776601683795}, "arianna.ppl.context.Context.rv": {"tf": 9.273618495495704}, "arianna.ppl.context.Context.cached": {"tf": 6.782329983125268}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 6}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 9.219544457292887}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 8.660254037844387}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 6.782329983125268}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 5.5677643628300215}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 8.94427190999916}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 8.660254037844387}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 6.782329983125268}, "arianna.ppl.context.Predictive.__init__": {"tf": 9.433981132056603}, "arianna.ppl.context.Predictive.run": {"tf": 11.357816691600547}, "arianna.ppl.context.Predictive.rv": {"tf": 9.273618495495704}, "arianna.ppl.context.Predictive.cached": {"tf": 6.782329983125268}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 5.5677643628300215}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 8.94427190999916}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 8.660254037844387}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 6.782329983125268}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 9.433981132056603}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 10.392304845413264}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 9.273618495495704}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 6.782329983125268}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 5.5677643628300215}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 9.219544457292887}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 8.660254037844387}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 6.782329983125268}, "arianna.ppl.diagnostics.ess_kish": {"tf": 5.830951894845301}, "arianna.ppl.inference.Chain.__init__": {"tf": 5.830951894845301}, "arianna.ppl.inference.Chain.get": {"tf": 4.898979485566356}, "arianna.ppl.inference.Chain.subset": {"tf": 6.164414002968976}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 3.1622776601683795}, "arianna.ppl.inference.MCMC.step": {"tf": 3.1622776601683795}, "arianna.ppl.inference.MCMC.fit": {"tf": 6}, "arianna.ppl.inference.MCMC.logprob": {"tf": 8.246211251235321}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 6.244997998398398}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 12.84523257866513}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 6.244997998398398}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 8.54400374531753}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 6.708203932499369}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 7.681145747868608}, "arianna.ppl.inference.AIES.__init__": {"tf": 14.2828568570857}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 4}, "arianna.ppl.inference.AIES.step": {"tf": 6.708203932499369}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 14.071247279470288}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 6.708203932499369}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 12.649110640673518}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 5.656854249492381}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 10}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 4.898979485566356}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 4.898979485566356}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 5.656854249492381}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 6.082762530298219}, "arianna.ppl.shaper.Shaper.vec": {"tf": 6.557438524302}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 6.557438524302}}, "df": 129, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.survival": {"tf": 1}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.Context.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 92}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}}, "df": 6, "s": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}}, "df": 9}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}}, "df": 3}}}}, "t": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}}, "df": 3}, "r": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.Context.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 42}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 19, "s": {"docs": {"arianna.ppl.inference.Chain.__init__": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {"arianna.distributions.abstract.Distribution.logpdf": {"tf": 1}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1}, "arianna.distributions.distributions.Normal.survival": {"tf": 1}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1}}, "df": 36}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract.Distribution.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Real.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 2}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.survival": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 2}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1.7320508075688772}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 2}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 99}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"arianna.ppl.inference.AIES.__init__": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"arianna.distributions.abstract.Distribution.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Real.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 2}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.survival": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1.4142135623730951}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1.4142135623730951}}, "df": 111}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"arianna.distributions.abstract.Distribution.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1}, "arianna.distributions.abstract.Real.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Real.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Independent.sample": {"tf": 1}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 2}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Normal.survival": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1.4142135623730951}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1.4142135623730951}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1.4142135623730951}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1.4142135623730951}}, "df": 109}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.MvNormal.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 20, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 12}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.Context.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}}, "df": 15}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 2}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}}, "df": 17}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 19}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}}, "df": 14}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 3}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 16}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 16}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}}, "df": 4}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}}, "df": 1}}}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1.7320508075688772}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1.4142135623730951}}, "df": 16}}}}}}}}}, "p": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 5, "c": {"docs": {}, "df": 0, "g": {"6": {"4": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 7}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "p": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 15}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {"arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 4, "t": {"docs": {"arianna.distributions.abstract.Distribution.sample": {"tf": 1}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 7}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}, "arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 17}}}}}, "g": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}}, "df": 3}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 2}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}}, "df": 1}}}, "z": {"docs": {"arianna.distributions.abstract.Continuous.to_native": {"tf": 1}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.Real.to_native": {"tf": 1}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1}}, "df": 15}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}}, "df": 7, "s": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 2}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 2, "s": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}}, "df": 2}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.__init__": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 27}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 11}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.Independent.__init__": {"tf": 1}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}}, "df": 9}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}}, "df": 1}}}, "c": {"docs": {"arianna.distributions.distributions.Normal.__init__": {"tf": 1}}, "df": 1}, "g": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}}, "b": {"docs": {"arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}}, "df": 2, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.Independent.is_same_family": {"tf": 1}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 20}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}, "e": {"docs": {"arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.ppl.context.Context.run": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}}, "df": 12}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"arianna.distributions.distributions.Beta.__init__": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}}, "df": 10}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "v": {"docs": {"arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 5}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1.4142135623730951}}, "df": 12}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.context.Predictive.__init__": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 5}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}}, "df": 5}}}, "u": {"docs": {"arianna.distributions.distributions.LogNormal.__init__": {"tf": 1}}, "df": 1}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1.4142135623730951}}, "df": 11}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}}, "df": 7}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.MvNormal.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.Predictive.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1}}, "df": 13}}}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.Context.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.Predictive.rv": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1}}, "df": 7}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.distributions.MvNormal.__init__": {"tf": 1}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 5}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Context.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1}}, "df": 7}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 1}}}, "w": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "bases": {"root": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context": {"tf": 1.4142135623730951}, "arianna.ppl.inference.InferenceEngine": {"tf": 1.4142135623730951}}, "df": 4}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}}, "df": 15}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {"arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}}, "df": 15}}}}}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}}, "df": 6, "s": {"docs": {"arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}}, "df": 15}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}}, "df": 3}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 6}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}}, "df": 2}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.distributions.MvNormal": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}}, "df": 5}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}}, "df": 1}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 3}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation": {"tf": 1}, "arianna.ppl.inference.BayesianOptimization": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 3}}}}}}}}}}}, "doc": {"root": {"0": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 5}, "1": {"0": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 2}, "docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.23606797749979}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}}, "df": 3}, "2": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}, "5": {"4": {"4": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {"arianna": {"tf": 1.7320508075688772}, "arianna.distributions": {"tf": 1.7320508075688772}, "arianna.distributions.abstract": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution.event_shape": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution.logpdf": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution.sample": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution.pdf": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution.mean": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution.std": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Distribution.var": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Continuous": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Continuous.to_real": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Continuous.to_native": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Continuous.logdetjac": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Discrete": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Multivariate": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Multivariate.mean": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Multivariate.std": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Multivariate.var": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Univariate": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Univariate.event_shape": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Univariate.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Univariate.sample": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 2.449489742783178}, "arianna.distributions.abstract.UnivariateContinuous.logcdf": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.UnivariateContinuous.cdf": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.UnivariateContinuous.survival": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.UnivariateContinuous.logsurvival": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Positive": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Positive.to_real": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Positive.to_native": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Positive.logdetjac": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Positive.logpdf": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.LowerUpperBounded.lower": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.LowerUpperBounded.upper": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.LowerUpperBounded.range": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.LowerUpperBounded.to_real": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.LowerUpperBounded.to_native": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.LowerUpperBounded.logdetjac": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.LowerUpperBounded.logpdf": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 2.449489742783178}, "arianna.distributions.abstract.MultivariateContinuous.cov": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.MultivariateContinuous.mean": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Real": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Real.to_real": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Real.to_native": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.Real.logdetjac": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1.7320508075688772}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1.7320508075688772}, "arianna.distributions.distributions": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Independent": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Independent.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Independent.dists": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Independent.is_same_family": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Independent.logpdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Independent.sample": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform.from_mean_shift": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform.logcdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform.cdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform.mode": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform.median": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Uniform.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.a": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.b": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.mode": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.logcdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.cdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Beta.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.a": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.b": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.base_dist": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.cdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.logcdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.ScaledBeta.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.from_mean_std": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.scale": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.logcdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.cdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.survival": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gamma.mode": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.from_mean_std": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.scale": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.mode": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.logcdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.InverseGamma.cdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.from_mean_std": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.mu": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.sigma": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.mode": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.median": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.logcdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogNormal.cdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Weibull": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Gumbel": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Logistic": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.LogLogistic": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.loc": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.scale": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.logpdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.logcdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.cdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.survival": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.std": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.mode": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Normal.median": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.cov": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.cov_inv": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.L": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.event_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.batch_plus_event_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.log_det_cov": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.logpdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.MvNormal.sample": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.__init__": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.concentration": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.concentration_sum": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.event_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.batch_plus_event_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.batch_shape": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.logpdf": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.sample": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.to_real": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.to_native": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.logdetjac": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.cov": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.mean": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.var": {"tf": 1.7320508075688772}, "arianna.distributions.distributions.Dirichlet.std": {"tf": 1.7320508075688772}, "arianna.ppl": {"tf": 1.7320508075688772}, "arianna.ppl.context": {"tf": 1.7320508075688772}, "arianna.ppl.context.BasicDistribution": {"tf": 5.196152422706632}, "arianna.ppl.context.BasicDistribution.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.context.BasicDistribution.logpdf": {"tf": 1.7320508075688772}, "arianna.ppl.context.BasicDistribution.sample": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution": {"tf": 5.196152422706632}, "arianna.ppl.context.TransformableDistribution.logdetjac": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution.logpdf_plus_logdetjac": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution.to_real": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution.to_native": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution.logpdf": {"tf": 1.7320508075688772}, "arianna.ppl.context.Context": {"tf": 1.7320508075688772}, "arianna.ppl.context.Context.result": {"tf": 1.7320508075688772}, "arianna.ppl.context.Context.state": {"tf": 1.7320508075688772}, "arianna.ppl.context.Context.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.Context.rv": {"tf": 1.7320508075688772}, "arianna.ppl.context.Context.cached": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndPriorSample.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndPriorSample.result": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndPriorSample.rng": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndPriorSample.rv": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndPriorSample.cached": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndTrace.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 5.916079783099616}, "arianna.ppl.context.LogprobAndTrace.state": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndTrace.result": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndTrace.rv": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndTrace.cached": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.state": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.rng": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.return_cached": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.result": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.rv": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.cached": {"tf": 6.855654600401044}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 4.123105625617661}, "arianna.ppl.context.TransformedLogprobAndTrace.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedLogprobAndTrace.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedLogprobAndTrace.state": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedLogprobAndTrace.result": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedLogprobAndTrace.rv": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedLogprobAndTrace.cached": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive": {"tf": 7.681145747868608}, "arianna.ppl.context.TransformedPredictive.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.state": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.rng": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.return_cached": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.result": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.rv": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 6.855654600401044}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.state": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.result": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.rv": {"tf": 1.7320508075688772}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace.cached": {"tf": 1.7320508075688772}, "arianna.ppl.diagnostics": {"tf": 1.7320508075688772}, "arianna.ppl.diagnostics.ess_kish": {"tf": 3.605551275463989}, "arianna.ppl.inference": {"tf": 1.7320508075688772}, "arianna.ppl.inference.P": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Model": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Logprob": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain": {"tf": 5.196152422706632}, "arianna.ppl.inference.Chain.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.states": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.names": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.get": {"tf": 5.0990195135927845}, "arianna.ppl.inference.Chain.bundle": {"tf": 3.7416573867739413}, "arianna.ppl.inference.Chain.subset": {"tf": 6.164414002968976}, "arianna.ppl.inference.InferenceEngine": {"tf": 1.7320508075688772}, "arianna.ppl.inference.InferenceEngine.rng": {"tf": 1.7320508075688772}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.model": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.model_data": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.nsamples": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.burn": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.thin": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.mcmc_iteration": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.transform": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.logprob_history": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.fit": {"tf": 3.7416573867739413}, "arianna.ppl.inference.MCMC.logprob": {"tf": 5.0990195135927845}, "arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1.7320508075688772}, "arianna.ppl.inference.SingleWalkerMCMC.init_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.SingleWalkerMCMC.mcmc_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.SingleWalkerMCMC.transform": {"tf": 1.7320508075688772}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 3.7416573867739413}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 15.716233645501712}, "arianna.ppl.inference.RandomWalkMetropolis.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.mcmc_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.init_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.model": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.model_data": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.transform": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.rng": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.proposal": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 3.7416573867739413}, "arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.nsteps": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.init_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.mcmc_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.accept_rate": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.accept": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.nwalkers": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.rng": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.a": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 5.0990195135927845}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 3.7416573867739413}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES": {"tf": 8.06225774829855}, "arianna.ppl.inference.AIES.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.model": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.nwalkers": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.transform": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.rng": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.accept": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.a": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.model_data": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.temperature_fn": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.init_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.step": {"tf": 3.7416573867739413}, "arianna.ppl.inference.ParallelAIES": {"tf": 4.123105625617661}, "arianna.ppl.inference.ParallelAIES.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.executor": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.model": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.nwalkers": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.transform": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.rng": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.rngs": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.accept": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.a": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.model_data": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.init_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 3.7416573867739413}, "arianna.ppl.inference.ImportanceSampling": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.particles": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.model": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.model_data": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.temperature": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.rng": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.log_weights": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.weights": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.rng": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.model": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.model_data": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.transform": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.shaper": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.init_vec_state": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 5.0990195135927845}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1.7320508075688772}, "arianna.ppl.inference.BayesianOptimization": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 3.605551275463989}, "arianna.ppl.shaper": {"tf": 1.7320508075688772}, "arianna.ppl.shaper.Shaper": {"tf": 1.7320508075688772}, "arianna.ppl.shaper.Shaper.__init__": {"tf": 1.7320508075688772}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1.7320508075688772}, "arianna.ppl.shaper.Shaper.shape": {"tf": 1.7320508075688772}, "arianna.ppl.shaper.Shaper.dim": {"tf": 1.7320508075688772}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1.7320508075688772}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1.7320508075688772}, "arianna.types": {"tf": 1.7320508075688772}, "arianna.types.Numeric": {"tf": 1.7320508075688772}, "arianna.types.Shape": {"tf": 1.7320508075688772}, "arianna.types.State": {"tf": 1.7320508075688772}, "arianna.types.NegativeInfinityError": {"tf": 1.7320508075688772}, "arianna.types.NegativeParameterError": {"tf": 1.7320508075688772}, "arianna.types.InvalidBoundsError": {"tf": 1.7320508075688772}}, "df": 356, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 31}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "c": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}}, "df": 2, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.BasicDistribution": {"tf": 2}, "arianna.ppl.context.TransformableDistribution": {"tf": 2}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.inference.InferenceEngine": {"tf": 1}, "arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 38, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 2.23606797749979}, "arianna.ppl.context.TransformableDistribution": {"tf": 2.23606797749979}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 31, "d": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC.fit": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 3}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.4142135623730951}}, "df": 6, "d": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 2}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.get": {"tf": 1.7320508075688772}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 11}}}}, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}, "/": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.shaper.Shaper.from_state": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": null}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": null}}, "df": 2}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 2}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 3}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "x": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 2}}}, "t": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2, "h": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 2}}, "df": 34}}, "e": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 2.23606797749979}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 2.23606797749979}, "arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.cached": {"tf": 2}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 2}, "arianna.ppl.context.TransformedPredictive": {"tf": 2.449489742783178}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 2}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 3.605551275463989}, "arianna.ppl.inference.AIES": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.4142135623730951}}, "df": 16, "i": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}, "y": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}, "n": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2}}, "df": 2}, "r": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1.7320508075688772}}, "df": 1, "g": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 2}}, "s": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 2}}, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}, "o": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive": {"tf": 2.23606797749979}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.449489742783178}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 41, "d": {"docs": {}, "df": 0, "o": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 2, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 6}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.7320508075688772}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 1, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 5}}}}}}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 31}, "d": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}}, "df": 2, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 2.23606797749979}, "arianna.ppl.context.TransformableDistribution": {"tf": 2.23606797749979}}, "df": 2, "s": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}, "[": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}}}}}}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 5, "s": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.449489742783178}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 13}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.LaplaceApproximation": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 1}}}, "a": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 2}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1.4142135623730951}}, "df": 42, "n": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 33, "d": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 2.23606797749979}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 2}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 2}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}}, "df": 16}, "y": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}}, "df": 2}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}}}}, "b": {"docs": {}, "df": 0, "c": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 31}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.InferenceEngine": {"tf": 1}, "arianna.ppl.inference.MCMC": {"tf": 1}}, "df": 2}}}}}}}, "t": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 2, "s": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 5}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 5}, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.shaper.Shaper": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 3}, "c": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 2}}}}}}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {"arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}}, "df": 1}}, "l": {"docs": {"arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 4}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES": {"tf": 1.4142135623730951}}, "df": 3}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 2}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {"arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.LaplaceApproximation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "s": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 31}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.7320508075688772}}, "df": 2}}, "e": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 2}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 2}, "arianna.ppl.context.TransformedPredictive": {"tf": 2.449489742783178}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 2}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 2}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.8284271247461903}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 2}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 2}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AIES.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 2}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 16, "s": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}}, "df": 3, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.23606797749979}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 8}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 4}}, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 3}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 3}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 2}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}, "b": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2}}, "df": 1}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1.7320508075688772}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling.fit": {"tf": 1}}, "df": 4, "d": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}, "s": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 7}, "r": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1.7320508075688772}}, "df": 1, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling": {"tf": 1}}, "df": 2}}}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.shaper.Shaper": {"tf": 1}}, "df": 1}, "r": {"docs": {"arianna.ppl.shaper.Shaper.from_state": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "y": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 31}, "s": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}, "l": {"docs": {}, "df": 0, "k": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 2.23606797749979}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 8}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.23606797749979}}, "df": 2}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 3}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}, "s": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 31}}}, "e": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1, "d": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 3}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 6, "d": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 2, "n": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 3}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 11, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.distributions.abstract.Distribution": {"tf": 1}, "arianna.distributions.abstract.Continuous": {"tf": 1}, "arianna.distributions.abstract.Discrete": {"tf": 1}, "arianna.distributions.abstract.Multivariate": {"tf": 1}, "arianna.distributions.abstract.Univariate": {"tf": 1}, "arianna.distributions.abstract.UnivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.Positive": {"tf": 1}, "arianna.distributions.abstract.LowerUpperBounded": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous": {"tf": 1}, "arianna.distributions.abstract.UnivariateReal": {"tf": 1}, "arianna.distributions.abstract.MultivariateReal": {"tf": 1}, "arianna.distributions.distributions.IndependentRagged": {"tf": 1}, "arianna.distributions.distributions.Independent": {"tf": 1}, "arianna.distributions.distributions.Uniform": {"tf": 1}, "arianna.distributions.distributions.Beta": {"tf": 1}, "arianna.distributions.distributions.ScaledBeta": {"tf": 1}, "arianna.distributions.distributions.Gamma": {"tf": 1}, "arianna.distributions.distributions.InverseGamma": {"tf": 1}, "arianna.distributions.distributions.LogNormal": {"tf": 1}, "arianna.distributions.distributions.Weibull": {"tf": 1}, "arianna.distributions.distributions.Gumbel": {"tf": 1}, "arianna.distributions.distributions.Logistic": {"tf": 1}, "arianna.distributions.distributions.LogLogistic": {"tf": 1}, "arianna.distributions.distributions.Normal": {"tf": 1}, "arianna.distributions.distributions.MvNormal": {"tf": 1}, "arianna.distributions.distributions.Dirichlet": {"tf": 1}, "arianna.ppl.context.Context": {"tf": 1}, "arianna.ppl.context.LogprobAndPriorSample": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace": {"tf": 1}, "arianna.ppl.context.Predictive": {"tf": 1}, "arianna.ppl.context.LogprobAndLogjacobianAndTrace": {"tf": 1}}, "df": 31}}}}}}}}}, "t": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 4, "o": {"docs": {"arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}}, "df": 5}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.449489742783178}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.InferenceEngine": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 3}, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 2}}}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2}, "arianna.ppl.inference.AIES": {"tf": 2}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.4142135623730951}}, "df": 8}, "f": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.8284271247461903}}, "df": 5}, "t": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}}, "df": 1, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.ImportanceSampling": {"tf": 1}}, "df": 2}}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1.4142135623730951}}, "df": 7, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}}, "df": 2}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1.4142135623730951}}, "df": 4, "s": {"docs": {"arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.7320508075688772}}, "df": 4, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 4}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 2}}}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.LaplaceApproximation": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 2}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}}, "df": 3}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}, "f": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 2}, "arianna.ppl.context.TransformableDistribution": {"tf": 2}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 2.23606797749979}}, "df": 4, "s": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 3}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.MCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1.4142135623730951}}, "df": 4}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 7, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 10}}}}}}, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.7320508075688772}, "arianna.ppl.inference.LaplaceApproximation": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}}, "df": 19}, "n": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 5, "l": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}}, "df": 3}}, "e": {"docs": {"arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}}, "df": 2}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 2.23606797749979}}, "df": 2, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 2}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.BayesianOptimization": {"tf": 1}}, "df": 1}}}}}}}}}}}, "r": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.get": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 5, "g": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}, "j": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}}, "df": 3}}}}}}}}, "e": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 3, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}}, "df": 1}}}}, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 3}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 3}}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 2}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 2}}}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.InferenceEngine": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.ParallelAIES.step": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.distributions.abstract.UnivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.distributions.abstract.MultivariateContinuous.logpdf_plus_logdetjac": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 6}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 2}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.default_temperature_fn": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 12, "s": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1.4142135623730951}, "arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 16}, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}}, "df": 2}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1}}, "df": 2}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 2}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 3.3166247903554}, "arianna.ppl.inference.AIES": {"tf": 1.7320508075688772}}, "df": 3}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 7}}}}}, "v": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}}, "df": 1}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 5}}, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.BayesianOptimization": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"arianna.ppl.shaper.Shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 2}}}, "e": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}}, "df": 4}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 3}}}, "y": {"docs": {"arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 2.23606797749979}}, "df": 3}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain.bundle": {"tf": 1.4142135623730951}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1.4142135623730951}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.7320508075688772}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}, "arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1.7320508075688772}, "arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 11, "m": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}}, "df": 2, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.shaper.Shaper.from_state": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 3}}}, "t": {"docs": {"arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 3}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}}, "df": 1}}}}, "n": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 2}, "arianna.ppl.context.TransformableDistribution": {"tf": 2}}, "df": 2, "o": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AdaptiveRandomWalkMetropolis": {"tf": 1}}, "df": 2}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1}, "arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.InferenceEngine.fit": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.8284271247461903}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.fit": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 2}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.fit": {"tf": 1}}, "df": 13}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.inference.Chain": {"tf": 1.7320508075688772}, "arianna.ppl.inference.Chain.get": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.bundle": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC": {"tf": 1}, "arianna.ppl.inference.MCMC.step": {"tf": 1}, "arianna.ppl.inference.MCMC.fit": {"tf": 1.4142135623730951}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}, "arianna.ppl.inference.AIES.step": {"tf": 1}, "arianna.ppl.inference.ParallelAIES": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1}}, "df": 15}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"arianna.ppl.inference.SingleWalkerMCMC": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 1}}}, "u": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2}}, "df": 1, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1}}}}}}}}}}, "g": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1}}, "df": 1, "t": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 2}, "arianna.ppl.context.TransformableDistribution": {"tf": 2}}, "df": 2}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1}}, "df": 3}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 3}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1}, "arianna.ppl.context.TransformableDistribution": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {"arianna.ppl.context.LogprobAndPriorSample.run": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.get": {"tf": 1}}, "df": 3}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 1}}}}, "x": {"docs": {"arianna.ppl.context.BasicDistribution": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformableDistribution": {"tf": 1.4142135623730951}}, "df": 2}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.TransformedLogprobAndTrace": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.SingleWalkerMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.ParallelAIES.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 12}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.get": {"tf": 1.7320508075688772}}, "df": 3, "d": {"docs": {"arianna.ppl.inference.Chain.get": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"arianna.ppl.inference.AIES": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1.4142135623730951}, "arianna.ppl.shaper.Shaper": {"tf": 1}}, "df": 3}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.inference.Chain.subset": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.dim": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 5}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 3}, "n": {"docs": {"arianna.types.NegativeInfinityError": {"tf": 1}, "arianna.types.NegativeParameterError": {"tf": 1}, "arianna.types.InvalidBoundsError": {"tf": 1}}, "df": 3, "e": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 2}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.6457513110645907}, "arianna.ppl.inference.AIES": {"tf": 1}}, "df": 3}}, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.23606797749979}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"arianna.ppl.inference.Chain.get": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"arianna.ppl.inference.Chain.subset": {"tf": 1}}, "df": 1}}, "p": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}, "arianna.ppl.shaper.Shaper.vec": {"tf": 1}, "arianna.ppl.shaper.Shaper.unvec": {"tf": 1}}, "df": 4}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.context.Predictive.cached": {"tf": 2.6457513110645907}, "arianna.ppl.context.TransformedPredictive": {"tf": 1.4142135623730951}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 2.6457513110645907}, "arianna.ppl.inference.Chain.get": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 3}}, "df": 5, "s": {"docs": {"arianna.ppl.context.LogprobAndTrace.run": {"tf": 1}, "arianna.ppl.context.Predictive.cached": {"tf": 1}, "arianna.ppl.context.TransformedPredictive": {"tf": 2}, "arianna.ppl.context.TransformedPredictive.cached": {"tf": 1}, "arianna.ppl.inference.Chain.bundle": {"tf": 1}, "arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}, "arianna.ppl.inference.RandomWalkMetropolis.step": {"tf": 1.4142135623730951}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}, "arianna.ppl.shaper.Shaper": {"tf": 1}}, "df": 11}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"arianna.ppl.inference.Chain.get": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"arianna.ppl.inference.MCMC.logprob": {"tf": 1}, "arianna.ppl.inference.AffineInvariantMCMC.logprob": {"tf": 1}, "arianna.ppl.inference.LaplaceApproximation.logprob": {"tf": 1}}, "df": 3}}}}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {"arianna.ppl.context.TransformedPredictive": {"tf": 1}}, "df": 1}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"arianna.ppl.diagnostics.ess_kish": {"tf": 1.4142135623730951}}, "df": 1}}}}, "y": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1.7320508075688772}}, "df": 1, "o": {"docs": {}, "df": 0, "u": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}, "arianna.ppl.inference.AIES": {"tf": 1.4142135623730951}}, "df": 2, "r": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 1}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"arianna.ppl.inference.RandomWalkMetropolis": {"tf": 2.449489742783178}}, "df": 1}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true}; + + // mirrored in build-search-index.js (part 1) + // Also split on html tags. this is a cheap heuristic, but good enough. + elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); + + let searchIndex; + if (docs._isPrebuiltIndex) { + console.info("using precompiled search index"); + searchIndex = elasticlunr.Index.load(docs); + } else { + console.time("building search index"); + // mirrored in build-search-index.js (part 2) + searchIndex = elasticlunr(function () { + this.pipeline.remove(elasticlunr.stemmer); + this.pipeline.remove(elasticlunr.stopWordFilter); + this.addField("qualname"); + this.addField("fullname"); + this.addField("annotation"); + this.addField("default_value"); + this.addField("signature"); + this.addField("bases"); + this.addField("doc"); + this.setRef("fullname"); + }); + for (let doc of docs) { + searchIndex.addDoc(doc); + } + console.timeEnd("building search index"); + } + + return (term) => searchIndex.search(term, { + fields: { + qualname: {boost: 4}, + fullname: {boost: 2}, + annotation: {boost: 2}, + default_value: {boost: 2}, + signature: {boost: 2}, + bases: {boost: 2}, + doc: {boost: 1}, + }, + expand: true + }); +})(); \ No newline at end of file diff --git a/justfile b/justfile new file mode 100644 index 0000000..fea0abc --- /dev/null +++ b/justfile @@ -0,0 +1,83 @@ +alias ta := test-all +alias tl := test-lowest-versions +alias th := test-highest-versions +alias tt := test-nogil +alias t := test +alias w := watch +alias p := python +alias d := docs +alias s := serve +alias r := recover-uvlock +alias f := fmt +alias c := clean + +@default: + just -u -l + +watch *flags: + uv run --frozen -- watchmedo shell-command \ + --patterns='*.py' \ + --recursive \ + --command='just test {{ flags }}' \ + --verbose \ + src/ tests/ + +# Disable warnings by adding `--disable-warnings`. +test *flags: + uv run --frozen -- \ + pytest -s tests/ {{ if flags == "-dw" { "--disable-warnings" } else { "" } }} + +test-all *flags: + just test-lowest-versions {{ flags }} + just test-highest-versions {{ flags }} + just test-nogil {{ flags }} + +test-lowest-versions *flags: + uv run --resolution=lowest-direct --python=3.10 --isolated -- \ + pytest -s {{ if flags == "-dw" { "--disable-warnings" } else { "" } }} + just recover-uvlock + +test-highest-versions *flags: + uv run --resolution=highest --python=3.13 --isolated -- \ + pytest -s {{ if flags == "-dw" { "--disable-warnings" } else { "" } }} + just recover-uvlock + +test-nogil *flags: + uv run --resolution=highest --python=3.13t --isolated -- \ + pytest -s {{ if flags == "-dw" { "--disable-warnings" } else { "" } }} + just recover-uvlock + +sync: + uv sync --frozen + +python: + uv run --frozen -- ipython --no-autoindent + +docs: + rm -rf docs/* + uv run --frozen pdoc --math ./src/arianna -o ./docs --docformat numpy + +serve: + # uv run --frozen python -m http.server -d ./docs 8000 + uv run --frozen pdoc --docformat numpy --math -p 8000 ./src/arianna + +fmt-self: + just --fmt --unstable + +recover-uvlock: + git checkout uv.lock + uv sync --frozen + +# uv run --resolution=lowest-direct --python=3.10 --isolated -- pytest -s + +fmt-py: + ruff format + +fmt: fmt-self fmt-py + +lint: + ruff check --fix + +clean: + rm -rf src/*.egg-info src/arianna/__pycache__ src/arianna/*/__pycache__ + rm -rf dist diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..349ff67 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,72 @@ +[project] +name = "arianna-ppl" +dynamic = ["version"] +description = "Arianna probabilistic programming language" +readme = "README.md" +authors = [ + { name = "Arthur Lui", email = "alui@lanl.gov" } +] +maintainers = [{name="Arthur Lui", email="alui@lanl.gov"}] +classifiers = [ + "Operating System :: OS Independent", + "License :: OSI Approved :: BSD License", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.13t", +] +requires-python = ">=3.10" +dependencies = [ + "numpy>=2.2.1", + "scipy>=1.15.0", + "tqdm>=4.65,<5.0.0", +] + +[project.urls] +Homepage = "https://github.com/lanl/arianna" +Documentation = "https://lanl.github.io/arianna" +Repository = "https://github.com/lanl/arianna" +Issues = "https://github.com/lanl/arianna/issues" +Changelog = "https://github.com/me/spam/blob/master/CHANGELOG.md" + +[build-system] +requires = ["setuptools>=74.1", "setuptools-git-versioning>=2.0,<3"] +build-backend = "setuptools.build_meta" + +[dependency-groups] +dev = [ + "emcee>=3.1.6", + "matplotlib>=3.10.0", + "pdoc>=15.0.1", + "pytest>=8.3.4", + "seaborn>=0.13.2", + "watchdog>=6.0.0", + # psutil (notebook dependency) does not yet work with 3.13t. + "notebook>=7.2.2; python_version < '3.13'", +] + +[tool.setuptools-git-versioning] +enabled = true + +[tool.ruff] +line-length = 80 + +[tool.ruff.lint] +ignore = ["D100"] +extend-select = ["I", "D", "W505"] +extend-unsafe-fixes = ["F401"] +pydocstyle.convention = "numpy" +pycodestyle.max-doc-length = 80 + +# Ignore test file documentation linting. +[tool.ruff.lint.extend-per-file-ignores] +"tests/**/*.py" = ["D"] +"demos/**/*.ipynb" = ["D"] + +[tool.pytest.ini_options] +norecursedirs = ["venv", "build", ".git", "docs"] +addopts = "-s" +testpaths = [ + "tests", +] diff --git a/src/arianna/distributions/__init__.py b/src/arianna/distributions/__init__.py new file mode 100644 index 0000000..3a48a32 --- /dev/null +++ b/src/arianna/distributions/__init__.py @@ -0,0 +1 @@ +from .distributions import * # noqa: D104, F403 diff --git a/src/arianna/distributions/abstract.py b/src/arianna/distributions/abstract.py new file mode 100644 index 0000000..9958bdb --- /dev/null +++ b/src/arianna/distributions/abstract.py @@ -0,0 +1,203 @@ +from abc import ABC, abstractmethod +from functools import cached_property + +import numpy as np +from numpy import ndarray +from numpy.random import Generator as RNG +from numpy.random import default_rng +from scipy.special import expit, logit + +from arianna.types import InvalidBoundsError, Numeric, Shape + + +class Distribution(ABC): + @cached_property + @abstractmethod + def event_shape(self): ... + + # TODO: Think about how to implement this. + @cached_property + @abstractmethod + def batch_shape(self): ... + + @abstractmethod + def logpdf(self, x: Numeric) -> Numeric: ... + + @abstractmethod + def sample( + self, sample_shape: Shape = (), rng: RNG = default_rng() + ) -> ndarray: ... + + def pdf(self, x: Numeric) -> Numeric: + return np.exp(self.logpdf(x)) + + @cached_property + @abstractmethod + def mean(self) -> Numeric: ... + + @cached_property + def std(self) -> Numeric: + return np.sqrt(self.var) + + @cached_property + @abstractmethod + def var(self) -> Numeric: ... + + +class Continuous(Distribution): + @abstractmethod + def to_real(self, x: Numeric) -> Numeric: ... + + @abstractmethod + def to_native(self, z: Numeric) -> Numeric: ... + + @abstractmethod + def logdetjac(self, z: Numeric) -> Numeric: ... + + +class Discrete(Distribution): ... + + +class Multivariate(Distribution): + @cached_property + @abstractmethod + def mean(self) -> ndarray: ... + + @cached_property + def std(self) -> ndarray: + return np.sqrt(self.var) + + @cached_property + @abstractmethod + def var(self) -> ndarray: ... + + +class Univariate(Distribution): + @cached_property + def event_shape(self) -> Shape: + return () + + @cached_property + @abstractmethod + def batch_shape(self) -> Shape: ... + + def _reshape(self, sample_shape: Shape) -> Shape: + return sample_shape + self.batch_shape + + @abstractmethod + def _sample(self, size: Shape, rng: RNG) -> ndarray: ... + + def sample( + self, sample_shape: Shape = (), rng: RNG = default_rng() + ) -> ndarray: + shape = self._reshape(sample_shape) + return self._sample(shape, rng) + + +class UnivariateContinuous(Univariate, Continuous): + def logpdf_plus_logdetjac(self, z: Numeric) -> Numeric: + """Logpdf plus the log absolute determinant of the jacobian. + + Logpdf plus the log absolute determinant of the jacobian, evaluated at + parameter on the transformed (real) space. + """ + x = self.to_native(z) + return self.logpdf(x) + self.logdetjac(z) + + @abstractmethod + def logcdf(self, x: Numeric) -> Numeric: ... + + def cdf(self, x: Numeric) -> Numeric: + with np.errstate(divide="ignore"): + return np.exp(self.logcdf(x)) + + def survival(self, x: Numeric) -> Numeric: + return 1 - self.cdf(x) + + def logsurvival(self, x: Numeric) -> Numeric: + return np.log1p(-self.cdf(x)) + + +class Positive(UnivariateContinuous): + @abstractmethod + def _logpdf(self, x: Numeric) -> Numeric: ... + + def to_real(self, x: Numeric) -> Numeric: + return np.log(x) + + def to_native(self, z: Numeric) -> Numeric: + return np.exp(z) + + def logdetjac(self, z: Numeric) -> Numeric: + return z + + def logpdf(self, x: Numeric) -> Numeric: + # ignore divide by zero encountered in log. + with np.errstate(divide="ignore"): + return np.where(x > 0, self._logpdf(np.maximum(0, x)), -np.inf) + + +class LowerUpperBounded(UnivariateContinuous, ABC): + @abstractmethod + def _logpdf(self, x: Numeric) -> Numeric: ... + + def __init__(self, lower: Numeric, upper: Numeric, check: bool = True): + self.lower = lower + self.upper = upper + self.range = self.upper - self.lower + if check and np.any(self.range <= 0): + raise InvalidBoundsError( + "In LowerUpperBounded, lower bound needs to be strictly less than upper bound!" + ) + + def to_real(self, x: Numeric) -> Numeric: + return logit((x - self.lower) / self.range) + + def to_native(self, z: Numeric) -> Numeric: + return expit(z) * self.range + self.lower + + def logdetjac(self, z: Numeric) -> Numeric: + return np.log(self.range) + z - 2 * np.logaddexp(0, z) + + def logpdf(self, x: Numeric) -> Numeric: + # ignore divide by zero encountered in log. + with np.errstate(divide="ignore"): + return np.where( + (self.lower < x) & (x < self.upper), + self._logpdf(np.clip(x, self.lower, self.upper)), + -np.inf, + ) + + +class MultivariateContinuous(Multivariate, Continuous): + def logpdf_plus_logdetjac(self, z: ndarray) -> Numeric: + """Logpdf plus the log absolute determinant of the jacobian. + + Logpdf plus the log absolute determinant of the jacobian, evaluated at + parameter on the transformed (real) space. + """ + x = self.to_native(z) + return self.logpdf(x) + self.logdetjac(z) + + @abstractmethod + def cov(self) -> ndarray: ... + + @abstractmethod + def mean(self) -> ndarray: ... + + +class Real: + def to_real(self, x: Numeric) -> Numeric: + return x + + def to_native(self, z: Numeric) -> Numeric: + return z + + def logdetjac(self, z: Numeric) -> Numeric: + return 0 + + +class UnivariateReal(Real, UnivariateContinuous): ... + + +class MultivariateReal(Real, MultivariateContinuous): ... diff --git a/src/arianna/distributions/distributions.py b/src/arianna/distributions/distributions.py new file mode 100644 index 0000000..65b5693 --- /dev/null +++ b/src/arianna/distributions/distributions.py @@ -0,0 +1,630 @@ +from functools import cached_property +from typing import Optional + +import numpy as np +from numpy import ndarray +from numpy.random import Generator as RNG +from numpy.random import default_rng +from scipy.special import ( + betainc, + betaln, + gammaln, + gdtr, + gdtrc, + log_ndtr, + ndtr, +) + +from arianna.types import NegativeParameterError + +from .abstract import ( + Distribution, + LowerUpperBounded, + MultivariateContinuous, + MultivariateReal, + Numeric, + Positive, + Shape, + UnivariateReal, +) + + +class IndependentRagged(Distribution): ... + + +class Independent(Distribution): + def __init__(self, dists: list[Distribution]): + assert self.is_same_family(dists) + self.dists = dists + + def is_same_family(self, dists: list[Distribution]) -> bool: + first_type = type(dists[0]) + return all(type(d) is first_type for d in dists) + + def logpdf(self, x: list[Numeric]) -> Numeric: + return sum(di.logpdf(xi) for di, xi in zip(self.dists, x)) + + def sample(self, sample_shape=[]) -> ndarray: + # TODO: Check the logic. + return np.stack([di.sample(sample_shape) for di in self.dists]) + + +class Uniform(LowerUpperBounded): + @classmethod + def from_mean_shift(cls, mean, shift): + return cls(mean - shift, mean + shift) + + @cached_property + def batch_shape(self) -> Shape: + return np.broadcast_shapes(np.shape(self.lower), np.shape(self.upper)) + + def _logpdf(self, x: Numeric) -> Numeric: + return -np.log(self.range) + + def logcdf(self, x: Numeric) -> Numeric: + with np.errstate(divide="ignore"): + return np.log(self.cdf(x)) + + def cdf(self, x: Numeric) -> Numeric: + return np.clip((x - self.lower) / self.range, 0, 1) + + def _sample(self, size: Shape, rng: RNG) -> ndarray: + return rng.uniform(self.lower, self.upper, size=size) + + @cached_property + def mode(self) -> Numeric: + # FIXME: Really, it should be anything in [lower, upper]. + return self.mean + + @cached_property + def median(self) -> Numeric: + return self.mean + + @cached_property + def mean(self) -> Numeric: + return (self.lower + self.upper) / 2 + + @cached_property + def var(self) -> Numeric: + return np.square(self.range) / 12 + + +class Beta(LowerUpperBounded): + def __init__(self, a: Numeric, b: Numeric, check: bool = True): + super().__init__(lower=0, upper=1) + if check and np.any(a < 0): + raise NegativeParameterError( + "In Beta(a,b), `a` must be strictly positive!" + ) + if check and np.any(b < 0): + raise NegativeParameterError( + "In Beta(a,b), `b` must be strictly positive!" + ) + self.a = a + self.b = b + + @cached_property + def mode(self) -> Numeric: + # https://en.wikipedia.org/wiki/Beta_distribution + raise NotImplementedError + + @cached_property + def batch_shape(self) -> Shape: + return np.broadcast(self.a, self.b).shape + + def _logpdf(self, x: Numeric) -> Numeric: + # Hide warnings if 0 * inf, which is nan. Should just return -inf. + with np.errstate(invalid="ignore"): + return ( + (self.a - 1) * np.log(x) + + (self.b - 1) * np.log1p(-x) + - betaln(self.a, self.b) + ) + + def logcdf(self, x: Numeric) -> Numeric: + with np.errstate(divide="ignore"): + return np.log(self.cdf(x)) + + def cdf(self, x: Numeric) -> Numeric: + return betainc(self.a, self.b, np.clip(x, 0, 1)) + + def _sample(self, size: Shape, rng: RNG) -> ndarray: + return rng.beta(self.a, self.b, size=size) + + @cached_property + def mean(self) -> Numeric: + return self.a / (self.a + self.b) + + @cached_property + def var(self): + c = self.a + self.b + return self.a * self.b / (np.square(c) * (c + 1)) + + +# TODO (12/4/2024): Write tests for all methods in Scaled Beta. +class ScaledBeta(LowerUpperBounded): + def __init__( + self, + a: Numeric, + b: Numeric, + lower: Numeric, + upper: Numeric, + check: bool = True, + ): + super().__init__(lower=lower, upper=upper) + if check and np.any(a < 0): + raise NegativeParameterError( + "In ScaledBeta(a,b,lower,upper), `a` must be strictly positive!" + ) + if check and np.any(b < 0): + raise NegativeParameterError( + "In ScaledBeta(a,b,lower,upper), `b` must be strictly positive!" + ) + + self.a = a + self.b = b + self.base_dist = Beta(self.a, self.b, check=False) + + @cached_property + def batch_shape(self) -> Shape: + return np.broadcast(self.a, self.b, self.lower, self.upper).shape + + def _broadcast(self, x: Numeric) -> Numeric: + shape = np.broadcast_shapes(np.shape(x), self.batch_shape) + return np.broadcast_to(x, shape) + + def _to_unit_interval(self, x: Numeric) -> Numeric: + return self._broadcast((x - self.lower) / self.range) + + def _from_unit_interval(self, y: Numeric) -> Numeric: + return self._broadcast(y * self.range + self.lower) + + def _sample(self, size: Shape, rng: RNG) -> Numeric: + return self._from_unit_interval( + self.base_dist._sample(size=size, rng=rng) + ) + + def cdf(self, x: Numeric) -> Numeric: + return self.base_dist.cdf(self._to_unit_interval(x)) + + def logcdf(self, x: Numeric) -> Numeric: + with np.errstate(divide="ignore"): + return np.log(self.cdf(x)) + + def _logpdf(self, x: Numeric) -> Numeric: + return self.base_dist._logpdf(self._to_unit_interval(x)) - np.log( + self.range + ) + + @cached_property + def mean(self) -> Numeric: + return self._from_unit_interval(self.base_dist.mean) + + @cached_property + def var(self) -> Numeric: + return self.base_dist.var * self.range**2 + + +class Gamma(Positive): + @classmethod + def from_mean_std(cls, mean, std, check: bool = True): + if check and np.any(mean < 0): + raise NegativeParameterError( + "In Gamma.from_mean_std(mean, std), `mean` must be strictly positive!" + ) + if check and np.any(std < 0): + raise NegativeParameterError( + "In Gamma.from_mean_std(mean, std), `std` must be strictly positive!" + ) + + var = std**2 + return cls(shape=mean**2 / var, scale=var / mean) + + def __init__(self, shape: Numeric, scale: Numeric, check: bool = True): + if check and np.any(shape < 0): + raise NegativeParameterError( + "In Gamma(shape, scale), `shape` must be strictly positive!" + ) + if check and np.any(scale < 0): + raise NegativeParameterError( + "In Gamma(shape, scale), `scale` must be strictly positive!" + ) + + self.shape = shape + self.scale = scale + + @cached_property + def batch_shape(self) -> Shape: + return np.broadcast(self.shape, self.scale).shape + + def _logpdf(self, x: Numeric) -> Numeric: + # Hide warnings if 0 * inf, which is nan. Should just return -inf. + with np.errstate(invalid="ignore"): + return ( + -gammaln(self.shape) + - self.shape * np.log(self.scale) + + (self.shape - 1) * np.log(x) + - x / self.scale + ) + + def logcdf(self, x: Numeric) -> Numeric: + with np.errstate(divide="ignore"): + return np.log(self.cdf(x)) + + def cdf(self, x: Numeric) -> Numeric: + return gdtr(1 / self.scale, self.shape, np.maximum(0, x)) + + def survival(self, x: Numeric) -> Numeric: + return gdtrc(1 / self.scale, self.shape, np.maximum(0, x)) + + def _sample(self, size: Shape, rng: RNG) -> ndarray: + return rng.gamma(shape=self.shape, scale=self.scale, size=size) + + @cached_property + def mean(self) -> Numeric: + return self.shape * self.scale + + @cached_property + def var(self) -> Numeric: + return self.shape * np.square(self.scale) + + @cached_property + def mode(self) -> Numeric: + return np.where(self.shape > 1, self.scale * (self.shape - 1), 0.0) + + +# https://en.wikipedia.org/wiki/Inverse-gamma_distribution +class InverseGamma(Positive): + @classmethod + def from_mean_std(cls, mean, std, check: bool = True): + if check and np.any(mean < 0): + raise NegativeParameterError( + "In InverseGamma.from_mean_std(mean, mean), `mean` must be strictly positive!" + ) + if check and np.any(std < 0): + raise NegativeParameterError( + "In InverseGamma.from_mean_std(mean, mean), `std` must be strictly positive!" + ) + + shape = (mean / std) ** 2 + 2 + scale = mean * (shape - 1) + return cls(shape, scale) + + def __init__(self, shape: Numeric, scale: Numeric, check: bool = True): + if check and np.any(shape < 0): + raise NegativeParameterError( + "In InverseGamma(shape, scale), `shape` must be strictly positive!" + ) + if check and np.any(scale < 0): + raise NegativeParameterError( + "In InverseGamma(shape, scale), `scale` must be strictly positive!" + ) + + self.shape = shape + self.scale = scale + + @cached_property + def batch_shape(self) -> Shape: + return np.broadcast(self.shape, self.scale).shape + + @cached_property + def mean(self) -> Numeric: + return np.where(self.shape > 1, self.scale / (self.shape - 1), np.nan) + + @cached_property + def var(self) -> Numeric: + return np.where(self.shape > 2, self.mean**2 / (self.shape - 2), np.nan) + + @cached_property + def mode(self) -> Numeric: + return self.scale / (self.shape + 1) + + def _logpdf(self, x: Numeric) -> Numeric: + # Hide warnings if 0 * inf, which is nan. Should just return -inf. + with np.errstate(invalid="ignore", divide="ignore"): + return ( + self.shape * np.log(self.scale) + - gammaln(self.shape) + - (self.shape + 1) * np.log(x) + - self.scale / x + ) + + def logcdf(self, x: Numeric) -> Numeric: + with np.errstate(divide="ignore"): + return np.log(self.cdf(x)) + + def cdf(self, x: Numeric) -> Numeric: + with np.errstate(divide="ignore"): + x = np.maximum(0, x) + return gdtrc(self.scale, self.shape, 1 / x) + + def _sample(self, size: Shape, rng: RNG) -> ndarray: + return 1 / rng.gamma(shape=self.shape, scale=1 / self.scale, size=size) + + +class LogNormal(Positive): + @classmethod + def from_mean_std(cls, mean, std, check: bool = True): + if check and np.any(mean < 0): + raise NegativeParameterError( + "In LogNormal.from_mean_std(mean, std), `mean` must be strictly positive!" + ) + if check and np.any(std < 0): + raise NegativeParameterError( + "In LogNormal.from_mean_std(mean, std), `std` must be strictly positive!" + ) + var = std**2 + sigma_squared = np.log1p(var / mean**2) + mu = np.log(mean) - sigma_squared / 2 + sigma = np.sqrt(sigma_squared) + return cls(mu, sigma) + + def __init__(self, mu: Numeric, sigma: Numeric, check: bool = True): + if check and np.any(sigma < 0): + raise NegativeParameterError( + "In LogNormal(mu, sigma), `sigma` must be strictly positive!" + ) + + self.mu = mu + self.sigma = sigma + + @cached_property + def batch_shape(self) -> Shape: + return np.broadcast(self.mu, self.sigma).shape + + @cached_property + def mean(self) -> Numeric: + return np.exp(self.mu + self.sigma**2 / 2) + + @cached_property + def var(self) -> Numeric: + return (np.exp(self.sigma**2) - 1) * np.exp(2 * self.mu + self.sigma**2) + + @cached_property + def mode(self) -> Numeric: + return np.exp(self.mu - self.sigma**2) + + @cached_property + def median(self) -> Numeric: + return np.exp(self.mu) + + def _logpdf(self, x: Numeric) -> Numeric: + # Hide warnings if 0 * inf, which is nan. Should just return -inf. + with np.errstate(divide="ignore", invalid="ignore"): + z = (np.log(x) - self.mu) / self.sigma + return -np.log(x * self.sigma * np.sqrt(2 * np.pi)) - z**2 / 2 + + def logcdf(self, x: Numeric) -> Numeric: + x = np.maximum(0, x) + with np.errstate(divide="ignore"): + z = (np.log(x) - self.mu) / self.sigma + return log_ndtr(z) + + def cdf(self, x: Numeric) -> Numeric: + x = np.maximum(0, x) + with np.errstate(divide="ignore"): + z = (np.log(x) - self.mu) / self.sigma + return ndtr(z) + + def _sample(self, size: Shape, rng: RNG) -> ndarray: + return rng.lognormal(self.mu, self.sigma, size=size) + + +class Weibull(Positive): ... + + +class Gumbel(UnivariateReal): ... + + +class Logistic(Positive): ... + + +class LogLogistic(UnivariateReal): ... + + +class Normal(UnivariateReal): + def __init__( + self, loc: Numeric = 0.0, scale: Numeric = 1.0, check: bool = True + ): + if check and np.any(scale < 0): + raise NegativeParameterError( + "In Normal(loc, scale), `scale` must be strictly positive!" + ) + self.loc = loc + self.scale = scale + + @cached_property + def batch_shape(self) -> Shape: + return np.broadcast(self.loc, self.scale).shape + + def logpdf(self, x: Numeric) -> Numeric: + z = (x - self.loc) / self.scale + return -np.square(z) / 2 - np.log(2 * np.pi) / 2 - np.log(self.scale) + + def logcdf(self, x: Numeric) -> Numeric: + return log_ndtr((x - self.mean) / self.scale) + + def cdf(self, x: Numeric) -> Numeric: + return ndtr((x - self.mean) / self.scale) + + def survival(self, x: Numeric) -> Numeric: + return 1 - self.cdf(x) + + def _sample(self, size: Shape, rng: RNG) -> ndarray: + return rng.normal(loc=self.loc, scale=self.scale, size=size) + + @cached_property + def mean(self) -> Numeric: + return np.broadcast_to(self.loc, self.batch_shape) + + @cached_property + def std(self) -> Numeric: + return np.broadcast_to(self.scale, self.batch_shape) + + @cached_property + def var(self) -> Numeric: + return np.square(self.std) + + @cached_property + def mode(self) -> Numeric: + return self.mean + + @cached_property + def median(self) -> Numeric: + return self.mean + + +class MvNormal(MultivariateReal): + def __init__( + self, + mean: Optional[ndarray] = None, + cov: Optional[ndarray] = None, + **kwargs, + ): + match mean, cov: + case (None, None): + raise ValueError("mean and cov cannot both be None!") + case (None, _): + mean = np.zeros(cov.shape[-1]) + case (_, None): + cov = np.eye(mean.shape[-1]) + + super().__init__(**kwargs) + + self._mean = mean + self._cov = cov + + @cached_property + def mean(self) -> ndarray: + return np.broadcast_to(self._mean, self.batch_plus_event_shape) + + @cached_property + def _icov(self) -> ndarray: + return np.linalg.inv(self._cov) + + @cached_property + def cov(self) -> ndarray: + return np.broadcast_to( + self._cov, self.batch_plus_event_shape + self.event_shape + ) + + @cached_property + def cov_inv(self) -> ndarray: + return np.broadcast_to( + self._icov, self.batch_plus_event_shape + self.event_shape + ) + + @cached_property + def L(self) -> ndarray: + return np.linalg.cholesky(self.cov) + + @cached_property + def event_shape(self) -> Shape: + return self.mean.shape[-1:] + + @cached_property + def batch_shape(self) -> Shape: + return self.batch_plus_event_shape[:-1] + + @cached_property + def batch_plus_event_shape(self) -> Shape: + return np.broadcast_shapes(self._mean.shape, self._cov.shape[:-1]) + + @cached_property + def log_det_cov(self) -> float | ndarray: + _, ldc = np.linalg.slogdet(self.cov) + return ldc + + @cached_property + def var(self) -> ndarray: + return np.diagonal(self.cov, axis1=-2, axis2=-1) + + def logpdf(self, x): + d = x - self.mean + + # Compute quadratic form + quad_form = np.einsum("...i, ...ij, ...j -> ...", d, self.cov_inv, d) # type: ignore + + return -0.5 * ( + self.event_shape[0] * np.log(2 * np.pi) + + self.log_det_cov + + quad_form + ) + + def sample( + self, sample_shape: Shape = (), rng: RNG = default_rng() + ) -> ndarray: + shape = sample_shape + self.batch_shape + self.event_shape + standard_normals = rng.standard_normal(shape) + b = np.einsum("...ij,...j->...i", self.L, standard_normals) + samples = self.mean + b + return samples + + +class Dirichlet(MultivariateContinuous): + def __init__(self, concentration: ndarray, check: bool = True): + if check and np.any(concentration < 0): + raise NegativeParameterError( + "In Dirichlet(concentration), `concentration` must be stricly positive!" + ) + self.concentration = concentration + + @cached_property + def concentration_sum(self): + return self.concentration.sum(-1, keepdims=True) + + @cached_property + def event_shape(self): + return self.concentration.shape[-1] + + @cached_property + def batch_plus_event_shape(self): + return self.concentration.shape + + @cached_property + def batch_shape(self): + return self.batch_plus_event_shape[:-1] + + def logpdf(self, x: ndarray) -> float | ndarray: + # TODO: Test. + return ( + np.sum((self.concentration - 1) * np.log(x), -1) + + gammaln(self.concentration.sum(-1)) + - gammaln(self.concentration).sum(-1) + ) + + def sample( + self, sample_shape: Shape = (), rng: RNG = default_rng() + ) -> ndarray: + shape = sample_shape + self.batch_plus_event_shape + alpha = rng.standard_gamma(shape) + return alpha / alpha.sum(-1, keepdims=True) + + def to_real(self, x: ndarray) -> float | ndarray: + # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html + raise NotImplementedError + + def to_native(self, z: ndarray) -> float | ndarray: + # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html + raise NotImplementedError + + def logdetjac(self, z: ndarray) -> float | ndarray: + # https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html + raise NotImplementedError + + @cached_property + def cov(self) -> ndarray: + raise NotImplementedError + + @cached_property + def mean(self) -> ndarray: + return self.concentration / self.concentration_sum + + @cached_property + def var(self) -> ndarray: + m = self.mean + return m * (1 - m) / (1 + self.concentration_sum) + + @cached_property + def std(self) -> ndarray: + return np.sqrt(self.var) diff --git a/src/arianna/ppl/__init__.py b/src/arianna/ppl/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/arianna/ppl/context.py b/src/arianna/ppl/context.py new file mode 100644 index 0000000..f73e1fd --- /dev/null +++ b/src/arianna/ppl/context.py @@ -0,0 +1,412 @@ +from abc import ABC, abstractmethod +from typing import Any, Optional, Protocol + +import numpy as np +from numpy import ndarray +from numpy.random import Generator as RNG +from numpy.random import default_rng + +from arianna.types import NegativeInfinityError, Numeric, Shape, State + + +class BasicDistribution(Protocol): + def logpdf(self, x: Numeric) -> Numeric: ... + def sample( + self, sample_shape: Shape = (), rng: RNG = default_rng() + ) -> ndarray: ... + + +class TransformableDistribution(BasicDistribution): + def logdetjac(self, z: Numeric) -> Numeric: ... + + def logpdf_plus_logdetjac(self, z: Numeric) -> Numeric: ... + + def to_real(self, x: Numeric) -> Numeric: + return np.log(x) + + def to_native(self, z: Numeric) -> Numeric: + return np.exp(z) + + def logpdf(self, x: Numeric) -> Numeric: ... + + +# NOTE: Ideally, the name of a child Context class should be what its `run` +# method returns. For example, the LogprobAndTrace Context's `run` method +# returns the model log probability and trace. (Note that a trace is the state +# in the native space and also includes cached values.) +class Context(ABC): + result: Any + state: State + + @classmethod + @abstractmethod + def run(cls): ... + + @abstractmethod + def rv( + self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None + ) -> Numeric: ... + + @abstractmethod + def cached(self, name: str, value: Numeric) -> Numeric: ... + + def __call__(self): + return self.result + + +class LogprobAndPriorSample(Context): + @classmethod + def run( + cls, model, rng: Optional[RNG] = None, **data + ) -> tuple[float, State]: + """Get (logprob, trace).""" + ctx = cls(rng=rng) + model(ctx, **data) + return ctx.result + + def __init__(self, rng: Optional[RNG] = None): + self.result = [0.0, {}] + self.rng = rng or default_rng() + + def rv( + self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None + ): + if obs is None: + value = dist.sample() + self.result[1][name] = value + else: + value = obs + + self.result[0] += np.sum(dist.logpdf(value)) + + return value + + def cached(self, name: str, value: Numeric) -> Numeric: + self.result[1][name] = value + return value + + +class LogprobAndTrace(Context): + @classmethod + def run(cls, model, state: State, **data) -> tuple[float, State]: + """TODO. + + Returns (logprob, trace). A trace is the state in the native space and + the cached values. + + Parameters + ---------- + model : Any + _description_ + + state : State + _description_ + + Returns + ------- + tuple[float, State] + _description_ + """ + ctx = cls(state) + + try: + # Accumulate logprob. + model(ctx, **data) + except NegativeInfinityError: + # If -inf anywhere during the accumulation, just end early and + # return -inf and an empty trace. + return -np.inf, {} + + return ctx.result + + def __init__(self, state: State): + self.state = state + self.result = [0.0, {}] + + def rv( + self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None + ): + if obs is None: + value = self.state[name] + self.result[1][name] = value + else: + value = obs + + self.result[0] += np.sum(dist.logpdf(value)) + if self.result[0] == -np.inf: + raise NegativeInfinityError("Negative infinity in Logprob.") + + return value + + def cached(self, name: str, value: Numeric) -> Numeric: + self.result[1][name] = value + return value + + +class Predictive(Context): + @classmethod + def run( + cls, + model, + state: Optional[State] = None, + rng: Optional[RNG] = None, + return_cached: bool = True, + **data, + ) -> State: + ctx = cls(state=state, rng=rng, return_cached=return_cached) + model(ctx, **data) + return ctx.result + + def __init__( + self, + state: Optional[State] = None, + rng: Optional[RNG] = None, + return_cached: bool = True, + ): + self.state = state or {} + self.rng = rng or default_rng() + self.return_cached = return_cached + self.result = {} + + def rv( + self, name: str, dist: BasicDistribution, obs: Optional[Numeric] = None + ) -> Numeric: + match self.state.get(name), obs: + case None, None: + self.result[name] = dist.sample(rng=self.rng) + return self.result[name] + case _, None: + self.result[name] = self.state[name] + return self.result[name] + case None, _: + return obs + case _: + raise RuntimeError("state and obs cannot both be defined.") + + def cached(self, name: str, value: Numeric) -> Numeric: + """Handle cached values. + + Returns the value `value` and additionally stores `value` in + `self.result[name]` if the `return_cached` attribute is True. + + Parameters + ---------- + name : str + Name of value to cache. + value : Numeric + Value of the thing to cache. + + Returns + ------- + Numeric + `value`, which is the second argument in `cached`. + """ + if self.return_cached: + self.result[name] = value + return value + + +class TransformedLogprobAndTrace(Context): + """TODO. + + Calculates the transformed log probability for a given state (on the real + space) and also returns the state in the native space. + + Returns + ------- + tuple[float, State] + (logprob_plus_logdetjac, native_state_with_cached_items) + """ + + @classmethod + def run(cls, model, state: State, **data) -> tuple[float, State]: + ctx = cls(state) + + try: + model(ctx, **data) + except NegativeInfinityError: + # In case of -inf, just return -inf and an empty trace ({}) early. + # The trace doesn't matter, just need to return something. + return -np.inf, {} + + return ctx.result + + def __init__(self, state: State): + self.state = state + self.result = [0.0, {}] # logprob, native_state + + def rv( + self, + name: str, + dist: TransformableDistribution, + obs: Optional[Numeric] = None, + ): + if obs is None: + real_value = self.state[name] + self.result[0] += np.sum(dist.logpdf_plus_logdetjac(real_value)) + value = dist.to_native(real_value) + self.result[1][name] = value + else: + value = obs + self.result[0] += np.sum(dist.logpdf(value)) + + if self.result[0] == -np.inf: + raise NegativeInfinityError( + "Negative infinity in TransformedLogprob." + ) + + return value + + def cached(self, name: str, value: Numeric) -> Numeric: + self.result[1][name] = value + return value + + +class TransformedPredictive(Context): + """Get transformed predictive state. + + Get transformed predictive state (i.e. state predictive in the real + space) via the `run` method. + + Parameters + ---------- + state: Optional[State] + Contains values on the native space. If a model parameter's + value is not provided, it will be sampled from it's prior. + Defaults to None. + rng: Optional[RNG] + Random number generator. Defaults to None. + return_cached: bool + Whether or not to return cached values. Defaults to True. + + Attributes + ---------- + state: State + Contains values on the native space. If None was provided in the + constructor, it's value will be an empty dictionary. + rng: RNG + Random number generator. If None was provided in the + constructor, this will be `default_rng()`. + return_cached: bool + Whether or not to return cached values. + """ + + @classmethod + def run( + cls, + model, + state: Optional[State] = None, + rng: Optional[RNG] = None, + return_cached: bool = True, + **data, + ): + ctx = cls(state=state, rng=rng, return_cached=return_cached) + model(ctx, **data) + return ctx.result + + def __init__( + self, + state: Optional[State] = None, + rng: Optional[RNG] = None, + return_cached: bool = True, + ): + self.state = state or {} + self.rng = rng or default_rng() + self.return_cached = return_cached + self.result = {} + + def rv( + self, + name: str, + dist: TransformableDistribution, + obs: Optional[Numeric] = None, + ) -> Numeric: + match self.state.get(name), obs: + case None, None: + # Sample from prior. + native_value = dist.sample(rng=self.rng) + self.result[name] = dist.to_real(native_value) + return native_value + case _, None: + # provided state is in native space, so needs to be converted + # to real space. + self.result[name] = dist.to_real(self.state[name]) + return self.result[name] + case None, _: + # Observed values need no transformation. + return obs + case _: + raise RuntimeError("state and obs cannot both be defined.") + + def cached(self, name: str, value: Numeric) -> Numeric: + """Handle cached values. + + Returns the value `value` and additionally stores `value` in + `self.result[name]` if the `return_cached` attribute is True. + + Parameters + ---------- + name : str + Name of value to cache. + value : Numeric + Value of the thing to cache. + + Returns + ------- + Numeric + `value`, which is the second argument in `cached`. + """ + if self.return_cached: + self.result[name] = value + return value + + +class LogprobAndLogjacobianAndTrace(Context): + @classmethod + def run(cls, model, state: State, **data) -> tuple[float, float, State]: + ctx = cls(state) + + try: + model(ctx, **data) + except NegativeInfinityError: + # In case of -inf, just return -inf and an empty trace ({}) early. + # The trace doesn't matter, just need to return something. + return -np.inf, -np.inf, {} + + return ctx.result + + def __init__(self, state: State): + self.state = state + self.result = [0.0, 0.0, {}] # logprob, logdetjac, native_state + + def rv( + self, + name: str, + dist: TransformableDistribution, + obs: Optional[Numeric] = None, + ): + if obs is None: + real_value = self.state[name] + value = dist.to_native(real_value) + self.result[0] += np.sum(dist.logpdf(value)) + self.result[1] += np.sum(dist.logdetjac(real_value)) + self.result[2][name] = value + else: + value = obs + self.result[0] += np.sum(dist.logpdf(value)) + + if self.result[0] == -np.inf: + raise NegativeInfinityError( + "Negative infinity in LogprobAndLogjacobianAndTrace." + ) + + if self.result[1] == -np.inf: + raise NegativeInfinityError( + "Negative infinity in LogprobAndLogjacobianAndTrace." + ) + + return value + + def cached(self, name: str, value: Numeric) -> Numeric: + self.result[2][name] = value + return value diff --git a/src/arianna/ppl/diagnostics.py b/src/arianna/ppl/diagnostics.py new file mode 100644 index 0000000..6f364c7 --- /dev/null +++ b/src/arianna/ppl/diagnostics.py @@ -0,0 +1,17 @@ +import numpy as np + + +def ess_kish(w: np.ndarray, log: bool = True) -> float: + """Kish Effective Sample Size. + + Kish's effective sample size. Used for weighted samples. (e.g. importance + sampling, sequential monte carlo, particle filters.) + + https://en.wikipedia.org/wiki/Effective_sample_size + + If log is True, then the w are log weights. + """ + if log: + return ess_kish(np.exp(w - np.max(w)), log=False) + else: + return sum(w) ** 2 / sum(w**2) diff --git a/src/arianna/ppl/inference.py b/src/arianna/ppl/inference.py new file mode 100644 index 0000000..af25171 --- /dev/null +++ b/src/arianna/ppl/inference.py @@ -0,0 +1,840 @@ +from abc import ABC, abstractmethod +from concurrent.futures import Executor +from copy import deepcopy +from functools import cached_property +from typing import ( + Any, + Callable, + Concatenate, + Generator, + Iterable, + Optional, + ParamSpec, +) + +import numpy as np +from numpy import ndarray +from numpy.random import Generator as RNG +from numpy.random import default_rng +from scipy.optimize import minimize +from scipy.special import log_softmax, softmax +from tqdm import tqdm, trange + +from arianna.distributions import MvNormal +from arianna.ppl.context import ( + Context, + LogprobAndLogjacobianAndTrace, + LogprobAndPriorSample, + LogprobAndTrace, + Predictive, + State, + TransformedLogprobAndTrace, + TransformedPredictive, +) +from arianna.ppl.shaper import Shaper + +P = ParamSpec("P") +Model = Callable[Concatenate[Context, P], None] +Logprob = Callable[[State], tuple[float, State]] + + +class Chain: + """Chain MCMC samples. + + Parameters + ---------- + states : Iterable[State] + MCMC states. + + Attributes + ---------- + chain : list[State] + MCMC states in list format. + """ + + def __init__(self, states: Iterable[State]): + self.states = list(states) + self.names = list(self.states[0].keys()) + + def __iter__(self): + """Iterate over states. + + Yields + ------ + State + MCMC state within chain. + """ + for state in self.states: + yield state + + def __len__(self) -> int: + """Return the number of states.""" + return len(self.states) + + def get(self, name: str) -> ndarray: + """Get all MCMC samples for one variable or cached value by name. + + Parameters + ---------- + name : str + Name of model parameter or cached value. + + Returns + ------- + ndarray + MCMC samples for the variable or cached value named. + """ + return np.stack([c[name] for c in self.states]) + + @cached_property + def bundle(self) -> dict[str, ndarray]: + """Bundle MCMC values into a dictionary. + + Returns + ------- + dict[str, ndarray] + Dictionary bundle of MCMC samples. + """ + return {name: self.get(name) for name in self.names} + + def subset(self, burn: int = 0, thin: int = 1): + """Return subset of the states. + + Parameters + ---------- + burn : int, optional + Number of initial samples to discard, by default 0. + thin : int, optional + Take only every `thin`-th sample, by default 1. + + Returns + ------- + Chain + A whole new chain, with the first `burn` removed, and taking only + every `thin`-th sample. + """ + return Chain(self.states[burn::thin]) + + +class InferenceEngine(ABC): + """Abstract inference engine class.""" + + rng: RNG + + @abstractmethod + def fit(self): + """Fit model.""" + pass + + +class MCMC(InferenceEngine): + """Abstract class for MCMC.""" + + model: Model + model_data: dict[str, Any] + nsamples: int + burn: int + thin: int + mcmc_iteration: int + transform: bool + logprob_history: list[float] + + @abstractmethod + def _fit(self, *args, **kwargs) -> Generator[State, None, None]: + pass + + @abstractmethod + def step(self): + """Update model state in one MCMC iteration.""" + pass + + def fit(self, *args, **kwargs) -> Chain: + """Run MCMC. + + Returns + ------- + Chain + Chain of MCMC samples. + """ + return Chain(self._fit(*args, **kwargs)) + + def logprob(self, state: State) -> tuple[float, State]: + """Compute log density. + + Parameters + ---------- + state : State + Dictionary containing random variables to model. + + Returns + ------- + tuple[float, State] + (Log density (float), native state and cached values (dict)) + """ + if self.transform: + # state is real. + # Returns logprob + log_det_jacobian, native_state. + return TransformedLogprobAndTrace.run( + self.model, state, **self.model_data + ) + else: + # state is native. + # Returns logprob, state (which is already native). + return LogprobAndTrace.run(self.model, state, **self.model_data) + + +class SingleWalkerMCMC(MCMC): + """Markov Chain Monte Carlo.""" + + init_state: State + mcmc_state: State + transform: bool + + @abstractmethod + def step(self) -> tuple[float, State]: + """Update mcmc_state and return logprob and native_state_and_cache. + + Returns + ------- + float, State + Logprob and native state and cache dictionary. + """ + pass + + def _fit( + self, nsamples: int, burn: int = 0, thin: int = 1 + ) -> Generator[State, None, None]: + self.nsamples = nsamples + self.burn = burn + self.thin = thin + self.mcmc_state = deepcopy(self.init_state) + self.logprob_history = [] + + for i in trange(nsamples * thin + burn): + self.mcmc_iteration = i + # NOTE: mcmc_state may not be the returned state, but the state + # that is used in the MCMC (e.g., for computational efficiency). + # trace is the state in its native space appended with any cached + # values. + logprob, trace = self.step() + if i >= burn and (i + 1) % thin == 0: + self.logprob_history.append(logprob) + yield trace + + +class RandomWalkMetropolis(SingleWalkerMCMC): + """Random walk Metropolis. + + Parameters + ---------- + model: Model + model function. + init_state: Optional[State] + Initial state for MCMC. If `transform=True` then `init_state` should + contain values in the real space; if `transform=False`, then + `init_state` should contain values in the native space. If not + provided, `init_state` is sampled from the prior predictive. + Defaults to None. + proposal: Optional[dict[str, Any]] + Dictionary containing proposal functions, dependent on the current + value. Defaults to None. + transform: bool + Whether or not to sample parameters into the real space. If False, + samples parameters in the native space. Regardless, returned samples + are in the native space and will include cached values. Defaults to + True. + rng: Optional[RNG] + Numpy random number generator. Defaults to None. + + Attributes + ---------- + model: Model + See Parameters. + init_state: State + If the constructor received None, `init_state` will be an empty + dictionary. + proposal: dict[str, Any] + If None is received in the constructor, an empty dictionary is first + created. In addition, any model parameters unnamed in the constructor + will have a value of + `lambda value, rng, mcmc_iteration: rng.normal(value, 0.1)`. + Thus, if you supplied in the constructor + `dict(mu=lambda value, rng, mcmc_iteration: rng.normal(value, 1))` + and your model is + ```python + def model(ctx, y=None): + mu = ctx.rv("mu", Normal(0, 10)) + sigma = ctx.rv("sigma", Gamma(1, 1)) + ctx.rv("y", Normal(mu, sigma), obs=y) + ``` + then the value for sigma will be + `lambda value, rng, _: rng.normal(value, 0.1)`. + transform: bool + See Parameters. + rng: RNG + If `None` was supplied in the constructor, then rng will be set to + `np.random.default_rng()`. + """ + + mcmc_state: State + init_state: State + + def __init__( + self, + model: Model, + init_state: Optional[State] = None, + proposal: Optional[dict[str, Any]] = None, + transform: bool = True, + rng: Optional[RNG] = None, + **model_data, + ): + self.model = model + self.model_data = model_data + self.transform = transform + self.rng = rng or default_rng() + + match init_state, transform: + case None, True: + self.init_state = TransformedPredictive.run( + model, rng=rng, return_cached=False, **model_data + ) + case None, False: + self.init_state = Predictive.run( + model, rng=rng, return_cached=False, **model_data + ) + case _: # init_state is provided. + self.init_state = init_state + + self.proposal = proposal or {} + for name in self.init_state: # should not have cached values. + self.proposal.setdefault( + name, lambda value, rng, _: rng.normal(value, 0.1) + ) + + def step(self) -> tuple[float, State]: + """Update mcmc_state and return native state and cached values. + + Returns + ------- + State + Native state and cached values. + """ + proposed_state = { + name: propose(self.mcmc_state[name], self.rng, self.mcmc_iteration) + for name, propose in self.proposal.items() + } + # NOTE: A trace contains the state (i.e., result of rv) in the native + # space AND cached values (i.e., result of cached). + logprob_proposed, proposed_trace = self.logprob(proposed_state) + logprob_current, current_trace = self.logprob(self.mcmc_state) + if logprob_proposed - logprob_current > np.log(self.rng.uniform()): + self.mcmc_state = proposed_state + return logprob_proposed, proposed_trace + else: + return logprob_current, current_trace + + +class AffineInvariantMCMC(MCMC): + """Affine Invariant MCMC.""" + + nsteps: int + init_state: list[State] + mcmc_state: list[State] + accept_rate: ndarray + accept: list[int] + nwalkers: int + rng: RNG + a: float + + @cached_property + def dim(self) -> int: + """Number of model parameters.""" + return int( + sum( + np.prod(np.shape(value)) + for value in self.init_state[0].values() + ) + ) + + def logprob(self, state: State) -> tuple[float, float, State]: + """Compute log density. + + Parameters + ---------- + state : State + Dictionary containing random variables to model. + + Returns + ------- + tuple[float, float, State] + ( + Log density in native space, + Log determinant of jacobian, + native state and cached values (dict) + ) + """ + if self.transform: + # state is real. + # Returns logprob, log_det_jacobian, native_state. + return LogprobAndLogjacobianAndTrace.run( + self.model, state, **self.model_data + ) + else: + # state is native. + # Returns logprob, logprob, state (which is already native). + lp, trace = LogprobAndTrace.run( + self.model, state, **self.model_data + ) + return lp, 0, trace + + @abstractmethod + def step(self) -> tuple[list[float], list[State]]: + """Update mcmc_state and return list of native_state_and_cache. + + Returns + ------- + list[State] + List of native state and cache dictionary. + """ + pass + + def _update_walker(self, i: int) -> tuple[float, State]: + this_walker = self.mcmc_state[i] + z = self._draw_z(i) + other_walker = self._draw_walker(i) + + candidate = { + name: value + (this_walker[name] - value) * z + for name, value in other_walker.items() + } + + cand_logprob, cand_ldj, cand_trace = self.logprob(candidate) + this_logprob, this_ldj, this_trace = self.logprob(this_walker) + log_accept_prob = cand_logprob + cand_ldj - this_logprob - this_ldj + log_accept_prob += (self.dim - 1) * np.log(z) + if log_accept_prob > np.log(self._draw_u(i)): + if self.mcmc_iteration >= self.burn: + self.accept[i] += 1 + for key, value in candidate.items(): + this_walker[key] = value + trace = cand_trace + lp = cand_logprob + else: + trace = this_trace + lp = this_logprob + + return lp, trace + + def fit( + self, *args, rebalanced_samples: Optional[int] = None, **kwargs + ) -> Chain: + """Fit model with AIES.""" + chain = Chain(self._fit(*args, **kwargs)) + + if rebalanced_samples is None: + rebalanced_samples = self.nsteps + + if rebalanced_samples > 0: + # Reweight with importance sampling. + weights = softmax(self.logprob_history) + index = self.rng.choice( + len(weights), rebalanced_samples, replace=True, p=weights + ) + self.resampled_logprob_history = np.array( + [self.logprob_history[i] for i in index] + ) + chain = Chain(chain.states[i] for i in index) + + return chain + + def _fit( + self, nsteps: int, burn: int = 0, thin: int = 1 + ) -> Generator[State, None, None]: + self.nsteps = nsteps + self.nsamples = nsteps * self.nwalkers + self.burn = burn + self.thin = thin + self.mcmc_state = deepcopy(self.init_state) + self.logprob_history = [] + + for i in trange(nsteps * thin + burn): + self.mcmc_iteration = i + # NOTE: mcmc_state may not be the returned state, but the state + # that is used in the MCMC (e.g., for computational efficiency). + # trace is the state in its native space appended with any cached + # values. + logprob, trace = self.step() + if i >= burn and (i + 1) % thin == 0: + self.logprob_history.extend(logprob) + yield from trace + + self.accept_rate = np.array(self.accept) / (self.nsteps * self.thin) + + @cached_property + def _root_a(self) -> float: + return np.sqrt(self.a) + + @cached_property + def _invroot_a(self) -> float: + return 1 / self._root_a + + @abstractmethod + def _draw_walker(self, i: int) -> State: ... + + @abstractmethod + def _draw_u(self, i: int) -> float: ... + + def _compute_z_given_u(self, u: float) -> float: + return (u * (self._root_a - self._invroot_a) + self._invroot_a) ** 2 + + def _draw_z(self, i: int) -> float: + u = self._draw_u(i) + return self._compute_z_given_u(u) + + +# https://arxiv.org/abs/1202.3665 +class AIES(AffineInvariantMCMC): + """Sequential Affine Invariant Ensemble Sampler. + + This sampler is good for target distributions that are not multimodal and + separated by large low density regions. You should use as many walkers as + you can afford. Whereas this sampler employs walkers that are sequeutnailly + updated. there is a parallel analog that updates walkers in parallel. + + Parameters + ---------- + model : Model + A model function of the form `def model(ctx: Context, **data)`. + num_walkers : int, optional + Number of walkers. Defaults to 10. + transform : bool, optional + Whether or not to transform parameters into the real space, by default + True. + rng : RNG, optional + Random number generator, by default default_rng() + a : float, optional + Tuning parameter that is set, by default, to 2.0, which is good for many + cases. + temperature_fn : Optional[Callable[[int], float]], optional + A temperature function for annealing, by default None. + + References + ---------- + - [emcee: The MCMC Hammer](https://arxiv.org/pdf/1202.3665) + - [Ensemble Samplers with Affine Invariance](https://msp.org/camcos/2010/5-1/camcos-v5-n1-p04-s.pdf) + """ + + @staticmethod + def default_temperature_fn(iter: int) -> float: + """Return 1.""" + return 1.0 + + def __init__( + self, + model: Model, + nwalkers: int = 10, + transform: bool = True, + rng: RNG = default_rng(), + a: float = 2.0, + temperature_fn: Optional[Callable[[int], float]] = None, + init_state: Optional[list[State]] = None, + **model_data, + ): + self.model: Model = model + self.nwalkers: int = nwalkers + self.transform: bool = transform + self.rng = rng + self.accept = [0] * nwalkers + if a <= 1: + raise ValueError("Tuning parameter `a` must be larger than 1.") + + self.a: float = a + self.model_data = model_data + self.temperature_fn: Callable[[int], float] = ( + temperature_fn or self.default_temperature_fn + ) + predictive = TransformedPredictive if transform else Predictive + if init_state is None: + init_state = [ + predictive.run( + model, rng=rng, return_cached=False, **model_data + ) + for _ in range(self.nwalkers) + ] + self.init_state = init_state + + def step(self) -> tuple[list[float], list[State]]: + """Update mcmc_state and return list of native_state_and_cache. + + Returns + ------- + list[float], list[State] + List of logprobs and list of native state and cache dictionary. + """ + trace = [] + lp = [] + for i, _ in enumerate(self.mcmc_state): + lp_i, trace_i = self._update_walker(i) + lp.append(lp_i) + trace.append(trace_i) + + return lp, trace + + def _draw_u(self, _: int) -> float: + return self.rng.uniform() + + def _draw_walker(self, i: int) -> State: + # Draw anything but the current walker (i). + if (j := self.rng.integers(self.nwalkers)) == i: + return self._draw_walker(i) + else: + return self.mcmc_state[j] + + +class ParallelAIES(AffineInvariantMCMC): + """Parallel Affine Invariant MCMC (or Parallel AIES). + + References + ---------- + - [emcee: The MCMC Hammer](https://arxiv.org/pdf/1202.3665) + - [Ensemble Samplers with Affine Invariance](https://msp.org/camcos/2010/5-1/camcos-v5-n1-p04-s.pdf) + """ + + def __init__( + self, + model: Model, + executor: Executor, + nwalkers: int = 10, + transform: bool = True, + rng: RNG = default_rng(), + a: float = 2.0, + init_state: Optional[list[State]] = None, + **model_data, + ): + if nwalkers < 4 or nwalkers % 2 == 1: + raise ValueError( + "num_walkers needs to be an even integer greater than 3, " + f"but got {nwalkers}!" + ) + + self.executor = executor + self.model: Model = model + self.nwalkers: int = nwalkers + self.transform: bool = transform + self.rng = rng + self.rngs = self.rng.spawn(self.nwalkers) + self.accept = [0] * nwalkers + if a <= 1: + raise ValueError("Tuning parameter `a` must be larger than 1.") + + self.a: float = a + self.model_data = model_data + predictive = TransformedPredictive if transform else Predictive + if init_state is None: + init_state = [ + predictive.run( + model, rng=self.rng, return_cached=False, **model_data + ) + for _ in range(self.nwalkers) + ] + self.init_state = init_state + + def _draw_u(self, i: int) -> float: + return self.rngs[i].uniform() + + def step(self) -> tuple[list[float], list[State]]: + """Update mcmc_state and return list of native_state_and_cache. + + Returns + ------- + list[float], list[State] + Tuple in which the first element is a list of logprobs, and the + second element is a list of traces (i.e., native state and cache + dictionary). + """ + mid = self.nwalkers // 2 + out_first_half = list( + self.executor.map(self._update_walker, range(mid)) + ) + out_second_half = list( + self.executor.map(self._update_walker, range(mid, self.nwalkers)) + ) + logprob_first_half, trace_first_half = zip(*out_first_half) + logprob_second_half, trace_second_half = zip(*out_second_half) + + logprob = logprob_first_half + logprob_second_half + trace = trace_first_half + trace_second_half + return logprob, trace + + def _draw_walker(self, i: int) -> State: + other_walkers = self._get_other_walkers(i) + j = self.rngs[i].integers(len(other_walkers)) + return other_walkers[j] + + def _get_other_walkers(self, i: int) -> list[State]: + mid = self.nwalkers // 2 + if i < mid: + return self.mcmc_state[mid:] + else: + return self.mcmc_state[:mid] + + +class ImportanceSampling(InferenceEngine): + """Importance Sampling.""" + + particles: list[State] + + def __init__( + self, + model: Model, + rng: Optional[RNG] = None, + particles: Optional[list[State]] = None, + nparticles: Optional[int] = None, + temperature: float = 1.0, + **model_data, + ): + self.model = model + self.model_data = model_data + self.temperature = temperature + self.rng = rng or default_rng() + match nparticles, particles: + case None, None: + raise ValueError( + "nparticles and particles cannot both be None!" + ) + case _, None: + self.nparticles = nparticles + logprobs_and_samples = [ + LogprobAndPriorSample.run( + model=self.model, rng=self.rng, **self.model_data + ) + for _ in trange(self.nparticles) + ] + self.logprobs, self.particles = zip(*logprobs_and_samples) + case None, _: + self.particles = particles + self.nparticles = len(particles) + self.logprobs = [ + LogprobAndTrace.run( + model=self.model, state=particle, **self.model_data + )[0] + for particle in tqdm(self.particles) + ] + case _: + raise ValueError( + "nparticles and particles cannot both be specified!" + ) + + self.log_weights = log_softmax(self.logprobs) + self.weights = softmax(self.logprobs) + # self.ess = ess_kish(self.weights) + + def fit(self, nsamples: int) -> Chain: + """Sample.""" + indices = self.rng.choice(self.nparticles, nsamples, p=self.weights) + return Chain(self.particles[i] for i in indices) + + +class LaplaceApproximation(InferenceEngine): + """Laplace Approximation of Posterior.""" + + rng: RNG + + def __init__( + self, + model: Model, + transform: bool = True, + rng: Optional[RNG] = None, + **model_data, + ): + self.model = model + self.model_data = model_data + self.rng = rng or default_rng() + self.transform = transform + + if self.transform: + self.init_state = TransformedPredictive.run( + model, rng=rng, return_cached=False, **self.model_data + ) + else: + self.init_state = Predictive.run( + model, rng=rng, return_cached=False, **self.model_data + ) + + self.shaper = Shaper.from_state(self.init_state) + self.init_vec_state = self.shaper.vec(self.init_state) + + def logprob(self, vec_state: np.ndarray) -> float: + """Compute log density. + + Parameters + ---------- + state : State + Dictionary containing random variables to model. + + Returns + ------- + tuple[float, State] + (Log density (float), native state and cached values (dict)) + """ + state = self.shaper.unvec(vec_state) + if self.transform: + # state is real. + # Returns logprob + log_det_jacobian, native_state. + return TransformedLogprobAndTrace.run( + self.model, state, **self.model_data + )[0] + else: + # state is native. + # Returns logprob, state (which is already native). + return LogprobAndTrace.run(self.model, state, **self.model_data)[0] + + def _negative_logprob(self, vec_state) -> float: + return -self.logprob(vec_state) + + def fit(self, nsamples: int, **minimize_kwargs): + """Fit model with laplace approx.""" + self.result = minimize( + self._negative_logprob, x0=self.init_vec_state, **minimize_kwargs + ) + mean = self.result.x + cov = self.result.hess_inv + samples = MvNormal(mean, cov).sample((nsamples,), rng=self.rng) + + # Return native state and cache. + if self.transform: + return Chain( + TransformedLogprobAndTrace.run( + self.model, + self.shaper.unvec(vec_state), + **self.model_data, + )[1] + for vec_state in samples + ) + else: + return Chain( + Predictive.run( + self.model, + self.shaper.unvec(vec_state), + return_cached=True, + **self.model_data, + ) + for vec_state in samples + ) + + +class BayesianOptimization(InferenceEngine): + """Bayesian Optimization.""" + + ... + + +class AdaptiveRandomWalkMetropolis(SingleWalkerMCMC): + """Adaptive Random Walk Metropolis. + + Resources + --------- + - https://probability.ca/jeff/ftpdir/adaptex.pdf + """ + + ... diff --git a/src/arianna/ppl/shaper.py b/src/arianna/ppl/shaper.py new file mode 100644 index 0000000..3c6879d --- /dev/null +++ b/src/arianna/ppl/shaper.py @@ -0,0 +1,35 @@ +import numpy as np + +from arianna.types import State + + +class Shaper: + """Shapes dict of numeric values into np.array and back.""" + + @classmethod + def from_state(cls, state: State): + """Construct a Shaper from a state.""" + return cls({name: np.shape(value) for name, value in state.items()}) + + def __init__(self, shape: dict[str, tuple[int, ...]]): + self.shape = shape + self.dim = int(sum(np.prod(s) for s in self.shape.values())) + + def vec(self, state: State) -> np.ndarray: + """Convert a state dict into a np.ndarray.""" + flat_state = [] + for _, value in state.items(): + value = np.array(value) + flat_state.extend(value.flatten()) + return np.array(flat_state) + + def unvec(self, flat_state: np.ndarray) -> State: + """Convert a np.ndarray back to a state dict.""" + state = {} + start = 0 + for name, shapes in self.shape.items(): + num_elems = int(np.prod(shapes)) + value = np.reshape(flat_state[start : start + num_elems], shapes) + state[name] = value + start += num_elems + return state diff --git a/src/arianna/types.py b/src/arianna/types.py new file mode 100644 index 0000000..515d9a1 --- /dev/null +++ b/src/arianna/types.py @@ -0,0 +1,15 @@ +from numpy import ndarray + +Numeric = float | ndarray +Shape = tuple[int, ...] +State = dict[str, Numeric] + + +class NegativeInfinityError(Exception): + pass + + +class NegativeParameterError(Exception): ... + + +class InvalidBoundsError(Exception): ... diff --git a/tests/distributions/__init__.py b/tests/distributions/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/distributions/test_mv_real.py b/tests/distributions/test_mv_real.py new file mode 100644 index 0000000..32e2d02 --- /dev/null +++ b/tests/distributions/test_mv_real.py @@ -0,0 +1,96 @@ +from abc import ABC, abstractmethod +from functools import cached_property + +import numpy as np +from numpy import ndarray +from numpy.random import Generator +from numpy.testing import assert_allclose +from scipy import stats + +import arianna.distributions as dist +from arianna.distributions.abstract import MultivariateContinuous + + +def make_stacked_diag_cov( + batch_shape: tuple[int, ...], dim: int, rng: Generator +): + cov = np.empty(batch_shape + (dim, dim)) + for indices in np.ndindex(batch_shape): + cov[indices] = np.diag(np.abs(rng.normal(0, 3, dim))) + return cov + + +class AbstractTestMulivariateContinuous(ABC): + @cached_property + @abstractmethod + def d(self) -> MultivariateContinuous: ... + + @cached_property + @abstractmethod + def x(self) -> ndarray: ... + + @cached_property + @abstractmethod + def logpdf_truth(self) -> ndarray: ... + + @property + def event_shape(self): + return (2,) + + @property + def batch_shape(self): + return (3,) + + @property + def sample_shape(self): + return (7, 5) + + @cached_property + def rng(self): + return np.random.default_rng(1) + + def test_sample(self): + assert ( + np.shape(self.d.sample(rng=self.rng)) + == self.batch_shape + self.event_shape + ) + assert ( + np.shape(self.d.sample(self.sample_shape, rng=self.rng)) + == self.sample_shape + self.batch_shape + self.event_shape + ) + + samples = self.d.sample((100_000,), rng=self.rng) + assert_allclose(samples.mean(0), self.d.mean, rtol=0.05) + assert_allclose(samples.std(0), self.d.std, rtol=0.05) + + def test_logpdf(self): + lpdf = self.d.logpdf(self.x) + assert_allclose(self.logpdf_truth, lpdf, rtol=1e-6) + + pdf = self.d.pdf(self.x) + assert_allclose(np.exp(lpdf), pdf, rtol=1e-6) + + +class TestMvNormal(AbstractTestMulivariateContinuous): + @cached_property + def d(self): + return dist.MvNormal( + mean=self.rng.normal(0, 1, (self.batch_shape + self.event_shape)), + cov=make_stacked_diag_cov( + self.batch_shape, self.event_shape[0], self.rng + ), + ) + + @cached_property + def x(self): + return self.rng.normal( + 0.0, 1.0, (self.sample_shape + self.batch_shape + self.event_shape) + ) + + @cached_property + def logpdf_truth(self): + return stats.norm.logpdf( + self.x, + self.d.mean, + np.sqrt(np.diagonal(self.d.cov, axis1=-2, axis2=-1)), + ).sum(-1) diff --git a/tests/distributions/test_uni_real.py b/tests/distributions/test_uni_real.py new file mode 100644 index 0000000..11bbf44 --- /dev/null +++ b/tests/distributions/test_uni_real.py @@ -0,0 +1,257 @@ +from abc import ABC, abstractmethod +from functools import cached_property + +import numpy as np +from matplotlib.pylab import Generator +from numpy import ndarray +from numpy.testing import assert_allclose +from scipy import stats + +import arianna.distributions as dist +from arianna.distributions.abstract import UnivariateContinuous + + +# @pytest.mark.filterwarnings("ignore") +class AbstractTestUnivariateContinuous(ABC): + @cached_property + @abstractmethod + def d(self) -> UnivariateContinuous: ... + + @cached_property + @abstractmethod + def x(self) -> ndarray: ... + + @cached_property + @abstractmethod + def pdf_truth(self) -> ndarray: ... + + @cached_property + @abstractmethod + def cdf_truth(self) -> ndarray: ... + + @cached_property + def rng(self) -> Generator: + return np.random.default_rng(0) + + def test_sample(self): + m = (2,) + assert np.shape(self.d.sample()) == m + + n = (7, 5) + assert np.shape(self.d.sample(n)) == n + m + + samples = self.d.sample((100_000,), rng=self.rng) + assert np.allclose(samples.mean(0), self.d.mean, rtol=0.02) + assert np.allclose(samples.std(0), self.d.std, rtol=0.02) + + def test_logpdf(self): + pdf = self.d.pdf(self.x) + assert_allclose(self.pdf_truth, pdf, rtol=1e-6) + + lpdf = self.d.logpdf(self.x) + assert_allclose(np.exp(lpdf), pdf, rtol=1e-6) + + def test_logcdf(self): + cdf = self.d.cdf(self.x) + assert_allclose(self.cdf_truth, cdf, rtol=1e-6) + + lcdf = self.d.logcdf(self.x) + assert_allclose(np.exp(lcdf), cdf, rtol=1e-6) + + survival = self.d.survival(self.x) + assert_allclose(1 - cdf, survival, rtol=1e-6) + + +class TestUniform(AbstractTestUnivariateContinuous): + @cached_property + def d(self): + return dist.Uniform(lower=np.array([0, -5]), upper=np.array([1, 11])) + + @cached_property + def x(self): + return np.array([[0.6, 6], [0, 11], [-1, 12]]) + + @cached_property + def pdf_truth(self): + return np.where( + (self.d.lower < self.x) & (self.x < self.d.upper), + stats.uniform.pdf(self.x, loc=self.d.lower, scale=self.d.range), + 0, + ) + + @cached_property + def cdf_truth(self): + return stats.uniform.cdf(self.x, loc=self.d.lower, scale=self.d.range) + + def test_from_mean_shift(self): + d = dist.Uniform.from_mean_shift(3, 1) + assert d.lower == 2 + assert d.upper == 4 + + def _test_logjacdet(self): + # TODO. + + # Case 1: + # Uniform(0 ,1) + # Beta(2,4) + + # Can we 2: + # Uniform(-2, 3) + + # Case 3: + # X ~ Uniform(1, 3) + # Y|X ~ Uniform(X, 5) + # Compare against analytic marginal distribution for Y. + + # def case1(ctx: Context): + # alpha = ctx.rv("alpha", dist.Uniform(0, 1)) + # beta = ctx.rv("beta", dist.Beta(2, 4)) + + # def case2(ctx: Context): + # alpha = ctx.rv("alpha", dist.Uniform(-2, 3)) + + # def case3(ctx: Context): + # alpha = ctx.rv("alpha", dist.Uniform(1, 3)) + # beta = ctx.rv("beta", dist.Uniform(alpha, 5)) + + # cases = [case1, case2, case3] + # result = {} + # for case in cases: + # for transform in (True, False): + # emcee = Emcee(case, transform=transform) + # result[case.__name__, transform] = emcee.fit(1000, burn=1000, + # thin=10) + + # for (case_name, transform), value in result.items(): + # sns.pairplot( + # pd.DataFrame(value.bundle), + # ) + # plt.suptitle(f"{case_name}, {transform}") + # plt.show() + pass + + +class TestBeta(AbstractTestUnivariateContinuous): + @cached_property + def d(self): + return dist.Beta(np.array([1, 2]), np.array([1, 3])) + + @cached_property + def x(self): + return np.array([[0.6, 0.6], [-10, 10], [0, 1]]) + + @cached_property + def pdf_truth(self): + return np.where( + (0 < self.x) & (self.x < 1), + stats.beta.pdf(self.x, a=self.d.a, b=self.d.b), + 0, + ) + + @cached_property + def cdf_truth(self): + return stats.beta.cdf(self.x, a=self.d.a, b=self.d.b) + + +class TestGamma(AbstractTestUnivariateContinuous): + @cached_property + def d(self): + return dist.Gamma(shape=np.array([3, 7]), scale=np.array([2, 4])) + + @cached_property + def x(self): + return np.array([[0.6, 6], [0, 11], [-1, 12]]) + + @cached_property + def pdf_truth(self): + return stats.gamma.pdf(self.x, a=self.d.shape, scale=self.d.scale) + + @cached_property + def cdf_truth(self): + return stats.gamma.cdf(self.x, a=self.d.shape, scale=self.d.scale) + + def test_from_mean_std(self): + d = dist.Gamma(3, 5) + assert d.mean == 15 + assert d.var == 3 * 5**2 + + m = self.rng.uniform(0, 10, 100) + s = self.rng.uniform(0, 10, 100) + d = dist.Gamma.from_mean_std(mean=m, std=s) + assert_allclose(d.mean, m) + assert_allclose(d.std, s) + + +class TestInverseGamma(AbstractTestUnivariateContinuous): + @cached_property + def d(self): + return dist.InverseGamma(shape=np.array([3, 4]), scale=np.array([2, 3])) + + @cached_property + def x(self): + return np.array([[0.6, 6], [0, 5], [-1, 3]]) + + @cached_property + def pdf_truth(self): + return stats.invgamma.pdf(self.x, a=self.d.shape, scale=self.d.scale) + + @cached_property + def cdf_truth(self): + return stats.invgamma(self.d.shape, scale=self.d.scale).cdf(self.x) + + def test_from_mean_std(self): + m = self.rng.uniform(0, 5, 10) + s = self.rng.uniform(0, 5, 10) + d = dist.InverseGamma.from_mean_std(mean=m, std=s) + assert_allclose(d.mean, m) + assert_allclose(d.std, s) + + +class TestLogNormal(AbstractTestUnivariateContinuous): + def test_sample(self): + pass + + @cached_property + def d(self): + return dist.LogNormal(mu=np.array([3, 4]), sigma=np.array([2, 3])) + + @cached_property + def x(self): + return np.array([[0.6, 6], [0, 5], [-1, 3]]) + + @cached_property + def pdf_truth(self): + return stats.lognorm.pdf( + self.x, s=self.d.sigma, scale=np.exp(self.d.mu) + ) + + @cached_property + def cdf_truth(self): + return stats.lognorm(s=self.d.sigma, scale=np.exp(self.d.mu)).cdf( + self.x + ) + + def test_from_mean_std(self): + m = self.rng.uniform(0, 5, 10) + s = self.rng.uniform(0, 5, 10) + d = dist.LogNormal.from_mean_std(mean=m, std=s) + assert_allclose(d.mean, m) + assert_allclose(d.std, s) + + +class TestNormal(AbstractTestUnivariateContinuous): + @cached_property + def d(self): + return dist.Normal(loc=np.array([-1, 2]), scale=np.array([2, 4])) + + @cached_property + def x(self): + return np.array([[0.6, 6], [0, 1], [-1, 5]]) + + @cached_property + def pdf_truth(self): + return stats.norm.pdf(self.x, loc=self.d.loc, scale=self.d.scale) + + @cached_property + def cdf_truth(self): + return stats.norm.cdf(self.x, loc=self.d.loc, scale=self.d.scale) diff --git a/tests/ppl/__init__.py b/tests/ppl/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/ppl/test_context.py b/tests/ppl/test_context.py new file mode 100644 index 0000000..e71c020 --- /dev/null +++ b/tests/ppl/test_context.py @@ -0,0 +1,27 @@ +import numpy as np +from numpy import array, ndarray +from numpy.random import default_rng + +from arianna.distributions import Normal +from arianna.ppl.context import Context, LogprobAndTrace, Predictive + + +class TestContext: + def test_gaussian_model(self): + def model(ctx: Context, y: ndarray): + mu = ctx.rv("mu", Normal(0, 10)) + log_sigma = ctx.rv("log_sigma", Normal(array(0), array(3))) + sigma = ctx.cached("sigma", np.exp(log_sigma)) + ctx.rv("y", Normal(mu, sigma), obs=y) + + np.random.seed(0) + state = {"mu": 0.0, "log_sigma": 0.0} + y = np.random.normal(3, 2, 50) + + state = Predictive.run(model, rng=default_rng(0), y=y) + lpdf, state_and_cache = LogprobAndTrace.run(model, state=state, y=y) + assert lpdf > -np.inf + assert "sigma" in state_and_cache + + for name in ("mu", "log_sigma", "sigma"): + assert name in state diff --git a/tests/ppl/test_linear_regression.py b/tests/ppl/test_linear_regression.py new file mode 100644 index 0000000..edd54fc --- /dev/null +++ b/tests/ppl/test_linear_regression.py @@ -0,0 +1,141 @@ +from concurrent.futures import ThreadPoolExecutor +from typing import Optional + +import numpy as np +from numpy.random import default_rng + +from arianna.distributions import Gamma, Normal +from arianna.ppl.context import Context, Predictive +from arianna.ppl.inference import ( + AIES, + AffineInvariantMCMC, + Chain, + LaplaceApproximation, + ParallelAIES, + RandomWalkMetropolis, +) + +print("numpy version:", np.__version__) + + +def linear_regression( + ctx: Context, X: np.ndarray, y: Optional[np.ndarray], bias=True +): + _, p = X.shape + beta = ctx.rv("beta", Normal(np.zeros(p), 10)) + sigma = ctx.rv("sigma", Gamma(1, 1)) + mu = ctx.cached("mu", X @ beta) + if bias: + alpha = ctx.rv("alpha", Normal(0, 10)) + mu += alpha + + ctx.rv("y", Normal(mu, sigma), obs=y) + + +def test_linear_regression(): + rng = np.random.default_rng(0) + X = rng.normal(0, 1, (100, 1)) + sim_truth = Predictive.run( + linear_regression, + state=dict(sigma=0.7), + rng=rng, + X=X, + y=None, + return_cached=False, + ) + y = sim_truth.pop("y") + + for transform in (True, False): + proposal = { + name: ( + lambda value, rng, mcmc_iteration: rng.normal( + value, np.clip(10 * np.exp(-mcmc_iteration / 100), 0.1, 5) + ) + ) + for name in sim_truth + } + rwm = RandomWalkMetropolis( + linear_regression, + proposal=proposal, + rng=default_rng(0), + X=X, + y=y, + transform=transform, + ) + aies = AIES( + linear_regression, + rng=default_rng(0), + X=X, + y=y, + transform=transform, + ) + paies = ParallelAIES( + linear_regression, + ThreadPoolExecutor(4), + rng=default_rng(0), + X=X, + y=y, + transform=transform, + ) + laplace = LaplaceApproximation( + linear_regression, + rng=default_rng(2), + X=X, + y=y, + transform=transform, + ) + + samplers = dict(laplace=laplace, rwm=rwm, aies=aies, paies=paies) + + for name, sampler in samplers.items(): + print(f"Transformed: {transform}, Sampler: {name}") + n, burn = 3000, 3000 + match sampler: + case AffineInvariantMCMC(): + samples = sampler.fit(n, burn=burn, thin=1) + case LaplaceApproximation(): + samples = sampler.fit(n) + case _: + thin = aies.nwalkers + samples = sampler.fit(n, burn=burn * thin, thin=thin) + + match sampler: + case AffineInvariantMCMC(): + print(f"{name} acceptance rates:", sampler.accept_rate) + # Authors say that acceptance rates in (0.2, 0.5) is best. + # Increase `a` to decrease acceptance frequency (bigger + # steps). + # Decrease `a` to increase acceptance frequency (smaller + # steps). + np.testing.assert_array_less(sampler.accept_rate, 1) + np.testing.assert_array_less(0, sampler.accept_rate) + + xnew = np.linspace(-3, 3, 50) + Xnew = xnew.reshape(-1, 1) + _ = Chain( + Predictive.run( + linear_regression, state=c, rng=rng, X=Xnew, y=None + ) + for c in samples + ).get("y") # ynew + + for name, value in samples.bundle.items(): + if name in sim_truth: + value = value.squeeze() + + match name, transform, sampler: + case "sigma", False, LaplaceApproximation(): + rtol = 0.1 + case _: + rtol = 0.05 + + # Test that the posterior mean is near the truth. + np.testing.assert_allclose( + np.squeeze(sim_truth[name]), + samples.get(name).mean(), + rtol=rtol, + ) + + # Test that the 95% credible interval contains the truth. + assert np.all(np.quantile(value, 0.025) < sim_truth[name]) + assert np.all(np.quantile(value, 0.975) > sim_truth[name]) diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..bdc6e9d --- /dev/null +++ b/uv.lock @@ -0,0 +1,2206 @@ +version = 1 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] + +[[package]] +name = "anyio" +version = "4.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/73/199a98fc2dae33535d6b8e8e6ec01f8c1d76c9adb096c6b7d64823038cde/anyio-4.8.0.tar.gz", hash = "sha256:1d9fe889df5212298c0c0723fa20479d1b94883a2df44bd3897aa91083316f7a", size = 181126 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/eb/e7f063ad1fec6b3178a3cd82d1a3c4de82cccf283fc42746168188e1cdd5/anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a", size = 96041 }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321 }, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/fa/57ec2c6d16ecd2ba0cf15f3c7d1c3c2e7b5fcb83555ff56d7ab10888ec8f/argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08", size = 42798 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/6a/e8a041599e78b6b3752da48000b14c8d1e8a04ded09c88c714ba047f34f5/argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea", size = 15124 }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/e9/184b8ccce6683b0aa2fbb7ba5683ea4b9c5763f1356347f1312c32e3c66e/argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3", size = 1779911 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/13/838ce2620025e9666aa8f686431f67a29052241692a3dd1ae9d3692a89d3/argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367", size = 29658 }, + { url = "https://files.pythonhosted.org/packages/b3/02/f7f7bb6b6af6031edb11037639c697b912e1dea2db94d436e681aea2f495/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d", size = 80583 }, + { url = "https://files.pythonhosted.org/packages/ec/f7/378254e6dd7ae6f31fe40c8649eea7d4832a42243acaf0f1fff9083b2bed/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae", size = 86168 }, + { url = "https://files.pythonhosted.org/packages/74/f6/4a34a37a98311ed73bb80efe422fed95f2ac25a4cacc5ae1d7ae6a144505/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c", size = 82709 }, + { url = "https://files.pythonhosted.org/packages/74/2b/73d767bfdaab25484f7e7901379d5f8793cccbb86c6e0cbc4c1b96f63896/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86", size = 83613 }, + { url = "https://files.pythonhosted.org/packages/4f/fd/37f86deef67ff57c76f137a67181949c2d408077e2e3dd70c6c42912c9bf/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f", size = 84583 }, + { url = "https://files.pythonhosted.org/packages/6f/52/5a60085a3dae8fded8327a4f564223029f5f54b0cb0455a31131b5363a01/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e", size = 88475 }, + { url = "https://files.pythonhosted.org/packages/8b/95/143cd64feb24a15fa4b189a3e1e7efbaeeb00f39a51e99b26fc62fbacabd/argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082", size = 27698 }, + { url = "https://files.pythonhosted.org/packages/37/2c/e34e47c7dee97ba6f01a6203e0383e15b60fb85d78ac9a15cd066f6fe28b/argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f", size = 30817 }, + { url = "https://files.pythonhosted.org/packages/5a/e4/bf8034d25edaa495da3c8a3405627d2e35758e44ff6eaa7948092646fdcc/argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93", size = 53104 }, +] + +[[package]] +name = "arianna-ppl" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "numpy" }, + { name = "scipy" }, + { name = "tqdm" }, +] + +[package.dev-dependencies] +dev = [ + { name = "emcee" }, + { name = "matplotlib" }, + { name = "notebook", marker = "python_full_version < '3.13'" }, + { name = "pdoc" }, + { name = "pytest" }, + { name = "seaborn" }, + { name = "watchdog" }, +] + +[package.metadata] +requires-dist = [ + { name = "numpy", specifier = ">=2.2.1" }, + { name = "scipy", specifier = ">=1.15.0" }, + { name = "tqdm", specifier = ">=4.65,<5.0.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "emcee", specifier = ">=3.1.6" }, + { name = "matplotlib", specifier = ">=3.10.0" }, + { name = "notebook", marker = "python_full_version < '3.13'", specifier = ">=7.2.2" }, + { name = "pdoc", specifier = ">=15.0.1" }, + { name = "pytest", specifier = ">=8.3.4" }, + { name = "seaborn", specifier = ">=0.13.2" }, + { name = "watchdog", specifier = ">=6.0.0" }, +] + +[[package]] +name = "arrow" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "types-python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/00/0f6e8fcdb23ea632c866620cc872729ff43ed91d284c866b515c6342b173/arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85", size = 131960 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/ed/e97229a566617f2ae958a6b13e7cc0f585470eac730a73e9e82c32a3cdd2/arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80", size = 66419 }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, +] + +[[package]] +name = "async-lru" +version = "2.0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/e2/2b4651eff771f6fd900d233e175ddc5e2be502c7eb62c0c42f975c6d36cd/async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627", size = 10019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/9f/3c3503693386c4b0f245eaf5ca6198e3b28879ca0a40bde6b0e319793453/async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224", size = 6111 }, +] + +[[package]] +name = "attrs" +version = "24.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/48/c8/6260f8ccc11f0917360fc0da435c5c9c7504e3db174d5a12a1494887b045/attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff", size = 805984 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/89/aa/ab0f7891a01eeb2d2e338ae8fecbe57fcebea1a24dbb64d45801bfab481d/attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308", size = 63397 }, +] + +[[package]] +name = "babel" +version = "2.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/74/f1bc80f23eeba13393b7222b11d95ca3af2c1e28edca18af487137eefed9/babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316", size = 9348104 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", size = 9587599 }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/ca/824b1195773ce6166d388573fc106ce56d4a805bd7427b624e063596ec58/beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051", size = 581181 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/fe/e8c672695b37eecc5cbf43e1d0638d88d66ba3a44c4d321c796f4e59167f/beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed", size = 147925 }, +] + +[[package]] +name = "bleach" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406 }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "certifi" +version = "2024.12.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/bd/1d41ee578ce09523c81a15426705dd20969f5abf006d1afe8aeff0dd776a/certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db", size = 166010 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/32/8f6669fc4798494966bf446c8c4a162e0b5d893dff088afddf76414f70e1/certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56", size = 164927 }, +] + +[[package]] +name = "cffi" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 }, + { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 }, + { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 }, + { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 }, + { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 }, + { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 }, + { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 }, + { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 }, + { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 }, + { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 }, + { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 }, + { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 }, + { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 }, + { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 }, + { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 }, + { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 }, + { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 }, + { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 }, + { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 }, + { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 }, + { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 }, + { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 }, + { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 }, + { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 }, + { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 }, + { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 }, + { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 }, + { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 }, + { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 }, + { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 }, + { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 }, + { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 }, + { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 }, + { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 }, + { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 }, + { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 }, + { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 }, + { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 }, + { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 }, + { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 }, + { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 }, + { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 }, + { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 }, + { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 }, + { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 }, + { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/58/5580c1716040bc89206c77d8f74418caf82ce519aae06450393ca73475d1/charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de", size = 198013 }, + { url = "https://files.pythonhosted.org/packages/d0/11/00341177ae71c6f5159a08168bcb98c6e6d196d372c94511f9f6c9afe0c6/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176", size = 141285 }, + { url = "https://files.pythonhosted.org/packages/01/09/11d684ea5819e5a8f5100fb0b38cf8d02b514746607934134d31233e02c8/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037", size = 151449 }, + { url = "https://files.pythonhosted.org/packages/08/06/9f5a12939db324d905dc1f70591ae7d7898d030d7662f0d426e2286f68c9/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f", size = 143892 }, + { url = "https://files.pythonhosted.org/packages/93/62/5e89cdfe04584cb7f4d36003ffa2936681b03ecc0754f8e969c2becb7e24/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a", size = 146123 }, + { url = "https://files.pythonhosted.org/packages/a9/ac/ab729a15c516da2ab70a05f8722ecfccc3f04ed7a18e45c75bbbaa347d61/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a", size = 147943 }, + { url = "https://files.pythonhosted.org/packages/03/d2/3f392f23f042615689456e9a274640c1d2e5dd1d52de36ab8f7955f8f050/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247", size = 142063 }, + { url = "https://files.pythonhosted.org/packages/f2/e3/e20aae5e1039a2cd9b08d9205f52142329f887f8cf70da3650326670bddf/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408", size = 150578 }, + { url = "https://files.pythonhosted.org/packages/8d/af/779ad72a4da0aed925e1139d458adc486e61076d7ecdcc09e610ea8678db/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb", size = 153629 }, + { url = "https://files.pythonhosted.org/packages/c2/b6/7aa450b278e7aa92cf7732140bfd8be21f5f29d5bf334ae987c945276639/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d", size = 150778 }, + { url = "https://files.pythonhosted.org/packages/39/f4/d9f4f712d0951dcbfd42920d3db81b00dd23b6ab520419626f4023334056/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807", size = 146453 }, + { url = "https://files.pythonhosted.org/packages/49/2b/999d0314e4ee0cff3cb83e6bc9aeddd397eeed693edb4facb901eb8fbb69/charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f", size = 95479 }, + { url = "https://files.pythonhosted.org/packages/2d/ce/3cbed41cff67e455a386fb5e5dd8906cdda2ed92fbc6297921f2e4419309/charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f", size = 102790 }, + { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995 }, + { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471 }, + { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831 }, + { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335 }, + { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862 }, + { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673 }, + { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211 }, + { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039 }, + { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939 }, + { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075 }, + { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340 }, + { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205 }, + { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441 }, + { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 }, + { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 }, + { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 }, + { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 }, + { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 }, + { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 }, + { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 }, + { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 }, + { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 }, + { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 }, + { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 }, + { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 }, + { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 }, + { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698 }, + { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162 }, + { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263 }, + { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966 }, + { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992 }, + { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162 }, + { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972 }, + { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095 }, + { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668 }, + { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073 }, + { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732 }, + { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391 }, + { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702 }, + { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, +] + +[[package]] +name = "comm" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/a8/fb783cb0abe2b5fded9f55e5703015cdf1c9c85b3669087c538dd15a6a86/comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e", size = 6210 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/75/49e5bfe642f71f272236b5b2d2691cf915a7283cc0ceda56357b61daa538/comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3", size = 7180 }, +] + +[[package]] +name = "contourpy" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/c2/fc7193cc5383637ff390a712e88e4ded0452c9fbcf84abe3de5ea3df1866/contourpy-1.3.1.tar.gz", hash = "sha256:dfd97abd83335045a913e3bcc4a09c0ceadbe66580cf573fe961f4a825efa699", size = 13465753 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/80937fe3efe0edacf67c9a20b955139a1a622730042c1ea991956f2704ad/contourpy-1.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a045f341a77b77e1c5de31e74e966537bba9f3c4099b35bf4c2e3939dd54cdab", size = 268466 }, + { url = "https://files.pythonhosted.org/packages/82/1d/e3eaebb4aa2d7311528c048350ca8e99cdacfafd99da87bc0a5f8d81f2c2/contourpy-1.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:500360b77259914f7805af7462e41f9cb7ca92ad38e9f94d6c8641b089338124", size = 253314 }, + { url = "https://files.pythonhosted.org/packages/de/f3/d796b22d1a2b587acc8100ba8c07fb7b5e17fde265a7bb05ab967f4c935a/contourpy-1.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2f926efda994cdf3c8d3fdb40b9962f86edbc4457e739277b961eced3d0b4c1", size = 312003 }, + { url = "https://files.pythonhosted.org/packages/bf/f5/0e67902bc4394daee8daa39c81d4f00b50e063ee1a46cb3938cc65585d36/contourpy-1.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:adce39d67c0edf383647a3a007de0a45fd1b08dedaa5318404f1a73059c2512b", size = 351896 }, + { url = "https://files.pythonhosted.org/packages/1f/d6/e766395723f6256d45d6e67c13bb638dd1fa9dc10ef912dc7dd3dcfc19de/contourpy-1.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abbb49fb7dac584e5abc6636b7b2a7227111c4f771005853e7d25176daaf8453", size = 320814 }, + { url = "https://files.pythonhosted.org/packages/a9/57/86c500d63b3e26e5b73a28b8291a67c5608d4aa87ebd17bd15bb33c178bc/contourpy-1.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0cffcbede75c059f535725c1680dfb17b6ba8753f0c74b14e6a9c68c29d7ea3", size = 324969 }, + { url = "https://files.pythonhosted.org/packages/b8/62/bb146d1289d6b3450bccc4642e7f4413b92ebffd9bf2e91b0404323704a7/contourpy-1.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab29962927945d89d9b293eabd0d59aea28d887d4f3be6c22deaefbb938a7277", size = 1265162 }, + { url = "https://files.pythonhosted.org/packages/18/04/9f7d132ce49a212c8e767042cc80ae390f728060d2eea47058f55b9eff1c/contourpy-1.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974d8145f8ca354498005b5b981165b74a195abfae9a8129df3e56771961d595", size = 1324328 }, + { url = "https://files.pythonhosted.org/packages/46/23/196813901be3f97c83ababdab1382e13e0edc0bb4e7b49a7bff15fcf754e/contourpy-1.3.1-cp310-cp310-win32.whl", hash = "sha256:ac4578ac281983f63b400f7fe6c101bedc10651650eef012be1ccffcbacf3697", size = 173861 }, + { url = "https://files.pythonhosted.org/packages/e0/82/c372be3fc000a3b2005061ca623a0d1ecd2eaafb10d9e883a2fc8566e951/contourpy-1.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:174e758c66bbc1c8576992cec9599ce8b6672b741b5d336b5c74e35ac382b18e", size = 218566 }, + { url = "https://files.pythonhosted.org/packages/12/bb/11250d2906ee2e8b466b5f93e6b19d525f3e0254ac8b445b56e618527718/contourpy-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3e8b974d8db2c5610fb4e76307e265de0edb655ae8169e8b21f41807ccbeec4b", size = 269555 }, + { url = "https://files.pythonhosted.org/packages/67/71/1e6e95aee21a500415f5d2dbf037bf4567529b6a4e986594d7026ec5ae90/contourpy-1.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:20914c8c973f41456337652a6eeca26d2148aa96dd7ac323b74516988bea89fc", size = 254549 }, + { url = "https://files.pythonhosted.org/packages/31/2c/b88986e8d79ac45efe9d8801ae341525f38e087449b6c2f2e6050468a42c/contourpy-1.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d40d37c1c3a4961b4619dd9d77b12124a453cc3d02bb31a07d58ef684d3d86", size = 313000 }, + { url = "https://files.pythonhosted.org/packages/c4/18/65280989b151fcf33a8352f992eff71e61b968bef7432fbfde3a364f0730/contourpy-1.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:113231fe3825ebf6f15eaa8bc1f5b0ddc19d42b733345eae0934cb291beb88b6", size = 352925 }, + { url = "https://files.pythonhosted.org/packages/f5/c7/5fd0146c93220dbfe1a2e0f98969293b86ca9bc041d6c90c0e065f4619ad/contourpy-1.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dbbc03a40f916a8420e420d63e96a1258d3d1b58cbdfd8d1f07b49fcbd38e85", size = 323693 }, + { url = "https://files.pythonhosted.org/packages/85/fc/7fa5d17daf77306840a4e84668a48ddff09e6bc09ba4e37e85ffc8e4faa3/contourpy-1.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a04ecd68acbd77fa2d39723ceca4c3197cb2969633836ced1bea14e219d077c", size = 326184 }, + { url = "https://files.pythonhosted.org/packages/ef/e7/104065c8270c7397c9571620d3ab880558957216f2b5ebb7e040f85eeb22/contourpy-1.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c414fc1ed8ee1dbd5da626cf3710c6013d3d27456651d156711fa24f24bd1291", size = 1268031 }, + { url = "https://files.pythonhosted.org/packages/e2/4a/c788d0bdbf32c8113c2354493ed291f924d4793c4a2e85b69e737a21a658/contourpy-1.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:31c1b55c1f34f80557d3830d3dd93ba722ce7e33a0b472cba0ec3b6535684d8f", size = 1325995 }, + { url = "https://files.pythonhosted.org/packages/a6/e6/a2f351a90d955f8b0564caf1ebe4b1451a3f01f83e5e3a414055a5b8bccb/contourpy-1.3.1-cp311-cp311-win32.whl", hash = "sha256:f611e628ef06670df83fce17805c344710ca5cde01edfdc72751311da8585375", size = 174396 }, + { url = "https://files.pythonhosted.org/packages/a8/7e/cd93cab453720a5d6cb75588cc17dcdc08fc3484b9de98b885924ff61900/contourpy-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b2bdca22a27e35f16794cf585832e542123296b4687f9fd96822db6bae17bfc9", size = 219787 }, + { url = "https://files.pythonhosted.org/packages/37/6b/175f60227d3e7f5f1549fcb374592be311293132207e451c3d7c654c25fb/contourpy-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ffa84be8e0bd33410b17189f7164c3589c229ce5db85798076a3fa136d0e509", size = 271494 }, + { url = "https://files.pythonhosted.org/packages/6b/6a/7833cfae2c1e63d1d8875a50fd23371394f540ce809d7383550681a1fa64/contourpy-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805617228ba7e2cbbfb6c503858e626ab528ac2a32a04a2fe88ffaf6b02c32bc", size = 255444 }, + { url = "https://files.pythonhosted.org/packages/7f/b3/7859efce66eaca5c14ba7619791b084ed02d868d76b928ff56890d2d059d/contourpy-1.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade08d343436a94e633db932e7e8407fe7de8083967962b46bdfc1b0ced39454", size = 307628 }, + { url = "https://files.pythonhosted.org/packages/48/b2/011415f5e3f0a50b1e285a0bf78eb5d92a4df000553570f0851b6e309076/contourpy-1.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:47734d7073fb4590b4a40122b35917cd77be5722d80683b249dac1de266aac80", size = 347271 }, + { url = "https://files.pythonhosted.org/packages/84/7d/ef19b1db0f45b151ac78c65127235239a8cf21a59d1ce8507ce03e89a30b/contourpy-1.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2ba94a401342fc0f8b948e57d977557fbf4d515f03c67682dd5c6191cb2d16ec", size = 318906 }, + { url = "https://files.pythonhosted.org/packages/ba/99/6794142b90b853a9155316c8f470d2e4821fe6f086b03e372aca848227dd/contourpy-1.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa874e87e4a647fd2e4f514d5e91c7d493697127beb95e77d2f7561f6905bd9", size = 323622 }, + { url = "https://files.pythonhosted.org/packages/3c/0f/37d2c84a900cd8eb54e105f4fa9aebd275e14e266736778bb5dccbf3bbbb/contourpy-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf98051f1045b15c87868dbaea84f92408337d4f81d0e449ee41920ea121d3b", size = 1266699 }, + { url = "https://files.pythonhosted.org/packages/3a/8a/deb5e11dc7d9cc8f0f9c8b29d4f062203f3af230ba83c30a6b161a6effc9/contourpy-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61332c87493b00091423e747ea78200659dc09bdf7fd69edd5e98cef5d3e9a8d", size = 1326395 }, + { url = "https://files.pythonhosted.org/packages/1a/35/7e267ae7c13aaf12322ccc493531f1e7f2eb8fba2927b9d7a05ff615df7a/contourpy-1.3.1-cp312-cp312-win32.whl", hash = "sha256:e914a8cb05ce5c809dd0fe350cfbb4e881bde5e2a38dc04e3afe1b3e58bd158e", size = 175354 }, + { url = "https://files.pythonhosted.org/packages/a1/35/c2de8823211d07e8a79ab018ef03960716c5dff6f4d5bff5af87fd682992/contourpy-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:08d9d449a61cf53033612cb368f3a1b26cd7835d9b8cd326647efe43bca7568d", size = 220971 }, + { url = "https://files.pythonhosted.org/packages/9a/e7/de62050dce687c5e96f946a93546910bc67e483fe05324439e329ff36105/contourpy-1.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a761d9ccfc5e2ecd1bf05534eda382aa14c3e4f9205ba5b1684ecfe400716ef2", size = 271548 }, + { url = "https://files.pythonhosted.org/packages/78/4d/c2a09ae014ae984c6bdd29c11e74d3121b25eaa117eca0bb76340efd7e1c/contourpy-1.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:523a8ee12edfa36f6d2a49407f705a6ef4c5098de4f498619787e272de93f2d5", size = 255576 }, + { url = "https://files.pythonhosted.org/packages/ab/8a/915380ee96a5638bda80cd061ccb8e666bfdccea38d5741cb69e6dbd61fc/contourpy-1.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece6df05e2c41bd46776fbc712e0996f7c94e0d0543af1656956d150c4ca7c81", size = 306635 }, + { url = "https://files.pythonhosted.org/packages/29/5c/c83ce09375428298acd4e6582aeb68b1e0d1447f877fa993d9bf6cd3b0a0/contourpy-1.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:573abb30e0e05bf31ed067d2f82500ecfdaec15627a59d63ea2d95714790f5c2", size = 345925 }, + { url = "https://files.pythonhosted.org/packages/29/63/5b52f4a15e80c66c8078a641a3bfacd6e07106835682454647aca1afc852/contourpy-1.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fa36448e6a3a1a9a2ba23c02012c43ed88905ec80163f2ffe2421c7192a5d7", size = 318000 }, + { url = "https://files.pythonhosted.org/packages/9a/e2/30ca086c692691129849198659bf0556d72a757fe2769eb9620a27169296/contourpy-1.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ea9924d28fc5586bf0b42d15f590b10c224117e74409dd7a0be3b62b74a501c", size = 322689 }, + { url = "https://files.pythonhosted.org/packages/6b/77/f37812ef700f1f185d348394debf33f22d531e714cf6a35d13d68a7003c7/contourpy-1.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b75aa69cb4d6f137b36f7eb2ace9280cfb60c55dc5f61c731fdf6f037f958a3", size = 1268413 }, + { url = "https://files.pythonhosted.org/packages/3f/6d/ce84e79cdd128542ebeb268f84abb4b093af78e7f8ec504676673d2675bc/contourpy-1.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:041b640d4ec01922083645a94bb3b2e777e6b626788f4095cf21abbe266413c1", size = 1326530 }, + { url = "https://files.pythonhosted.org/packages/72/22/8282f4eae20c73c89bee7a82a19c4e27af9b57bb602ecaa00713d5bdb54d/contourpy-1.3.1-cp313-cp313-win32.whl", hash = "sha256:36987a15e8ace5f58d4d5da9dca82d498c2bbb28dff6e5d04fbfcc35a9cb3a82", size = 175315 }, + { url = "https://files.pythonhosted.org/packages/e3/d5/28bca491f65312b438fbf076589dcde7f6f966b196d900777f5811b9c4e2/contourpy-1.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:a7895f46d47671fa7ceec40f31fae721da51ad34bdca0bee83e38870b1f47ffd", size = 220987 }, + { url = "https://files.pythonhosted.org/packages/2f/24/a4b285d6adaaf9746e4700932f579f1a7b6f9681109f694cfa233ae75c4e/contourpy-1.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ddeb796389dadcd884c7eb07bd14ef12408aaae358f0e2ae24114d797eede30", size = 285001 }, + { url = "https://files.pythonhosted.org/packages/48/1d/fb49a401b5ca4f06ccf467cd6c4f1fd65767e63c21322b29b04ec40b40b9/contourpy-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19c1555a6801c2f084c7ddc1c6e11f02eb6a6016ca1318dd5452ba3f613a1751", size = 268553 }, + { url = "https://files.pythonhosted.org/packages/79/1e/4aef9470d13fd029087388fae750dccb49a50c012a6c8d1d634295caa644/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841ad858cff65c2c04bf93875e384ccb82b654574a6d7f30453a04f04af71342", size = 310386 }, + { url = "https://files.pythonhosted.org/packages/b0/34/910dc706ed70153b60392b5305c708c9810d425bde12499c9184a1100888/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4318af1c925fb9a4fb190559ef3eec206845f63e80fb603d47f2d6d67683901c", size = 349806 }, + { url = "https://files.pythonhosted.org/packages/31/3c/faee6a40d66d7f2a87f7102236bf4780c57990dd7f98e5ff29881b1b1344/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14c102b0eab282427b662cb590f2e9340a9d91a1c297f48729431f2dcd16e14f", size = 321108 }, + { url = "https://files.pythonhosted.org/packages/17/69/390dc9b20dd4bb20585651d7316cc3054b7d4a7b4f8b710b2b698e08968d/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e806338bfeaa006acbdeba0ad681a10be63b26e1b17317bfac3c5d98f36cda", size = 327291 }, + { url = "https://files.pythonhosted.org/packages/ef/74/7030b67c4e941fe1e5424a3d988080e83568030ce0355f7c9fc556455b01/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4d76d5993a34ef3df5181ba3c92fabb93f1eaa5729504fb03423fcd9f3177242", size = 1263752 }, + { url = "https://files.pythonhosted.org/packages/f0/ed/92d86f183a8615f13f6b9cbfc5d4298a509d6ce433432e21da838b4b63f4/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:89785bb2a1980c1bd87f0cb1517a71cde374776a5f150936b82580ae6ead44a1", size = 1318403 }, + { url = "https://files.pythonhosted.org/packages/b3/0e/c8e4950c77dcfc897c71d61e56690a0a9df39543d2164040301b5df8e67b/contourpy-1.3.1-cp313-cp313t-win32.whl", hash = "sha256:8eb96e79b9f3dcadbad2a3891672f81cdcab7f95b27f28f1c67d75f045b6b4f1", size = 185117 }, + { url = "https://files.pythonhosted.org/packages/c1/31/1ae946f11dfbd229222e6d6ad8e7bd1891d3d48bde5fbf7a0beb9491f8e3/contourpy-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:287ccc248c9e0d0566934e7d606201abd74761b5703d804ff3df8935f523d546", size = 236668 }, + { url = "https://files.pythonhosted.org/packages/3e/4f/e56862e64b52b55b5ddcff4090085521fc228ceb09a88390a2b103dccd1b/contourpy-1.3.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b457d6430833cee8e4b8e9b6f07aa1c161e5e0d52e118dc102c8f9bd7dd060d6", size = 265605 }, + { url = "https://files.pythonhosted.org/packages/b0/2e/52bfeeaa4541889f23d8eadc6386b442ee2470bd3cff9baa67deb2dd5c57/contourpy-1.3.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb76c1a154b83991a3cbbf0dfeb26ec2833ad56f95540b442c73950af2013750", size = 315040 }, + { url = "https://files.pythonhosted.org/packages/52/94/86bfae441707205634d80392e873295652fc313dfd93c233c52c4dc07874/contourpy-1.3.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:44a29502ca9c7b5ba389e620d44f2fbe792b1fb5734e8b931ad307071ec58c53", size = 218221 }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 }, +] + +[[package]] +name = "debugpy" +version = "1.8.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bc/e7/666f4c9b0e24796af50aadc28d36d21c2e01e831a934535f956e09b3650c/debugpy-1.8.11.tar.gz", hash = "sha256:6ad2688b69235c43b020e04fecccdf6a96c8943ca9c2fb340b8adc103c655e57", size = 1640124 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/e6/4cf7422eaa591b4c7d6a9fde224095dac25283fdd99d90164f28714242b0/debugpy-1.8.11-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:2b26fefc4e31ff85593d68b9022e35e8925714a10ab4858fb1b577a8a48cb8cd", size = 2075100 }, + { url = "https://files.pythonhosted.org/packages/83/3a/e163de1df5995d95760a4d748b02fbefb1c1bf19e915b664017c40435dbf/debugpy-1.8.11-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61bc8b3b265e6949855300e84dc93d02d7a3a637f2aec6d382afd4ceb9120c9f", size = 3559724 }, + { url = "https://files.pythonhosted.org/packages/27/6c/327e19fd1bf428a1efe1a6f97b306689c54c2cebcf871b66674ead718756/debugpy-1.8.11-cp310-cp310-win32.whl", hash = "sha256:c928bbf47f65288574b78518449edaa46c82572d340e2750889bbf8cd92f3737", size = 5178068 }, + { url = "https://files.pythonhosted.org/packages/49/80/359ff8aa388f0bd4a48f0fa9ce3606396d576657ac149c6fba3cc7de8adb/debugpy-1.8.11-cp310-cp310-win_amd64.whl", hash = "sha256:8da1db4ca4f22583e834dcabdc7832e56fe16275253ee53ba66627b86e304da1", size = 5210109 }, + { url = "https://files.pythonhosted.org/packages/7c/58/8e3f7ec86c1b7985a232667b5df8f3b1b1c8401028d8f4d75e025c9556cd/debugpy-1.8.11-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:85de8474ad53ad546ff1c7c7c89230db215b9b8a02754d41cb5a76f70d0be296", size = 2173656 }, + { url = "https://files.pythonhosted.org/packages/d2/03/95738a68ade2358e5a4d63a2fd8e7ed9ad911001cfabbbb33a7f81343945/debugpy-1.8.11-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ffc382e4afa4aee367bf413f55ed17bd91b191dcaf979890af239dda435f2a1", size = 3132464 }, + { url = "https://files.pythonhosted.org/packages/ca/f4/18204891ab67300950615a6ad09b9de236203a9138f52b3b596fa17628ca/debugpy-1.8.11-cp311-cp311-win32.whl", hash = "sha256:40499a9979c55f72f4eb2fc38695419546b62594f8af194b879d2a18439c97a9", size = 5103637 }, + { url = "https://files.pythonhosted.org/packages/3b/90/3775e301cfa573b51eb8a108285681f43f5441dc4c3916feed9f386ef861/debugpy-1.8.11-cp311-cp311-win_amd64.whl", hash = "sha256:987bce16e86efa86f747d5151c54e91b3c1e36acc03ce1ddb50f9d09d16ded0e", size = 5127862 }, + { url = "https://files.pythonhosted.org/packages/c6/ae/2cf26f3111e9d94384d9c01e9d6170188b0aeda15b60a4ac6457f7c8a26f/debugpy-1.8.11-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:84e511a7545d11683d32cdb8f809ef63fc17ea2a00455cc62d0a4dbb4ed1c308", size = 2498756 }, + { url = "https://files.pythonhosted.org/packages/b0/16/ec551789d547541a46831a19aa15c147741133da188e7e6acf77510545a7/debugpy-1.8.11-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce291a5aca4985d82875d6779f61375e959208cdf09fcec40001e65fb0a54768", size = 4219136 }, + { url = "https://files.pythonhosted.org/packages/72/6f/b2b3ce673c55f882d27a6eb04a5f0c68bcad6b742ac08a86d8392ae58030/debugpy-1.8.11-cp312-cp312-win32.whl", hash = "sha256:28e45b3f827d3bf2592f3cf7ae63282e859f3259db44ed2b129093ca0ac7940b", size = 5224440 }, + { url = "https://files.pythonhosted.org/packages/77/09/b1f05be802c1caef5b3efc042fc6a7cadd13d8118b072afd04a9b9e91e06/debugpy-1.8.11-cp312-cp312-win_amd64.whl", hash = "sha256:44b1b8e6253bceada11f714acf4309ffb98bfa9ac55e4fce14f9e5d4484287a1", size = 5264578 }, + { url = "https://files.pythonhosted.org/packages/2e/66/931dc2479aa8fbf362dc6dcee707d895a84b0b2d7b64020135f20b8db1ed/debugpy-1.8.11-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:8988f7163e4381b0da7696f37eec7aca19deb02e500245df68a7159739bbd0d3", size = 2483651 }, + { url = "https://files.pythonhosted.org/packages/10/07/6c171d0fe6b8d237e35598b742f20ba062511b3a4631938cc78eefbbf847/debugpy-1.8.11-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c1f6a173d1140e557347419767d2b14ac1c9cd847e0b4c5444c7f3144697e4e", size = 4213770 }, + { url = "https://files.pythonhosted.org/packages/89/f1/0711da6ac250d4fe3bf7b3e9b14b4a86e82a98b7825075c07e19bab8da3d/debugpy-1.8.11-cp313-cp313-win32.whl", hash = "sha256:bb3b15e25891f38da3ca0740271e63ab9db61f41d4d8541745cfc1824252cb28", size = 5223911 }, + { url = "https://files.pythonhosted.org/packages/56/98/5e27fa39050749ed460025bcd0034a0a5e78a580a14079b164cc3abdeb98/debugpy-1.8.11-cp313-cp313-win_amd64.whl", hash = "sha256:d8768edcbeb34da9e11bcb8b5c2e0958d25218df7a6e56adf415ef262cd7b6d1", size = 5264166 }, + { url = "https://files.pythonhosted.org/packages/77/0a/d29a5aacf47b4383ed569b8478c02d59ee3a01ad91224d2cff8562410e43/debugpy-1.8.11-py2.py3-none-any.whl", hash = "sha256:0e22f846f4211383e6a416d04b4c13ed174d24cc5d43f5fd52e7821d0ebc8920", size = 5226874 }, +] + +[[package]] +name = "decorator" +version = "5.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/0c/8d907af351aa16b42caae42f9d6aa37b900c67308052d10fdce809f8d952/decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330", size = 35016 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/50/83c593b07763e1161326b3b8c6686f0f4b0f24d5526546bee538c89837d6/decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186", size = 9073 }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604 }, +] + +[[package]] +name = "emcee" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/53/1045ee878cb24281387079f8ee4f0ade1622c6aae1ed1fd91a53e4fa5b19/emcee-3.1.6.tar.gz", hash = "sha256:11af4daf6ab8f9ca69681e3c29054665db7bbd87fd4eb8e437d2c3a1248c637d", size = 2871117 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/ef/2196b9bf88ffa1bde45853c72df021fbd07a8fa91a0f59a22d14a050dc04/emcee-3.1.6-py2.py3-none-any.whl", hash = "sha256:f2d63752023bdccf744461450e512a5b417ae7d28f18e12acd76a33de87580cb", size = 47351 }, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, +] + +[[package]] +name = "executing" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/e3/7d45f492c2c4a0e8e0fad57d081a7c8a0286cdd86372b070cca1ec0caa1e/executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab", size = 977485 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/fd/afcd0496feca3276f509df3dbd5dae726fcc756f1a08d9e25abe1733f962/executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf", size = 25805 }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/50/4b769ce1ac4071a1ef6d86b1a3fb56cdc3a37615e8c5519e1af96cdac366/fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4", size = 373939 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924 }, +] + +[[package]] +name = "fonttools" +version = "4.55.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/76/61/a300d1574dc381393424047c0396a0e213db212e28361123af9830d71a8d/fonttools-4.55.3.tar.gz", hash = "sha256:3983313c2a04d6cc1fe9251f8fc647754cf49a61dac6cb1e7249ae67afaafc45", size = 3498155 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/f3/9ac8c6705e4a0ff3c29e524df1caeee6f2987b02fb630129f21cc99a8212/fonttools-4.55.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:1dcc07934a2165ccdc3a5a608db56fb3c24b609658a5b340aee4ecf3ba679dc0", size = 2769857 }, + { url = "https://files.pythonhosted.org/packages/d8/24/e8b8edd280bdb7d0ecc88a5d952b1dec2ee2335be71cc5a33c64871cdfe8/fonttools-4.55.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f7d66c15ba875432a2d2fb419523f5d3d347f91f48f57b8b08a2dfc3c39b8a3f", size = 2299705 }, + { url = "https://files.pythonhosted.org/packages/f8/9e/e1ba20bd3b71870207fd45ca3b90208a7edd8ae3b001081dc31c45adb017/fonttools-4.55.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27e4ae3592e62eba83cd2c4ccd9462dcfa603ff78e09110680a5444c6925d841", size = 4576104 }, + { url = "https://files.pythonhosted.org/packages/34/db/d423bc646e6703fe3e6aea0edd22a2df47b9d188c5f7f1b49070be4d2205/fonttools-4.55.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:62d65a3022c35e404d19ca14f291c89cc5890032ff04f6c17af0bd1927299674", size = 4618282 }, + { url = "https://files.pythonhosted.org/packages/75/a0/e5062ac960a385b984ba74e7b55132e7f2c65e449e8330ab0f595407a3de/fonttools-4.55.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d342e88764fb201286d185093781bf6628bbe380a913c24adf772d901baa8276", size = 4570539 }, + { url = "https://files.pythonhosted.org/packages/1f/33/0d744ff518ebe50020b63e5018b8b278efd6a930c1d2eedda7defc42153b/fonttools-4.55.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:dd68c87a2bfe37c5b33bcda0fba39b65a353876d3b9006fde3adae31f97b3ef5", size = 4742411 }, + { url = "https://files.pythonhosted.org/packages/7e/6c/2f768652dba6b801f1567fc5d1829cda369bcd6e95e315a91e628f91c702/fonttools-4.55.3-cp310-cp310-win32.whl", hash = "sha256:1bc7ad24ff98846282eef1cbeac05d013c2154f977a79886bb943015d2b1b261", size = 2175132 }, + { url = "https://files.pythonhosted.org/packages/19/d1/4dcd865360fb2c499749a913fe80e41c26e8ae18629d87dfffa3de27e831/fonttools-4.55.3-cp310-cp310-win_amd64.whl", hash = "sha256:b54baf65c52952db65df39fcd4820668d0ef4766c0ccdf32879b77f7c804d5c5", size = 2219430 }, + { url = "https://files.pythonhosted.org/packages/4b/18/14be25545600bd100e5b74a3ac39089b7c1cb403dc513b7ca348be3381bf/fonttools-4.55.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8c4491699bad88efe95772543cd49870cf756b019ad56294f6498982408ab03e", size = 2771005 }, + { url = "https://files.pythonhosted.org/packages/b2/51/2e1a5d3871cd7c2ae2054b54e92604e7d6abc3fd3656e9583c399648fe1c/fonttools-4.55.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5323a22eabddf4b24f66d26894f1229261021dacd9d29e89f7872dd8c63f0b8b", size = 2300654 }, + { url = "https://files.pythonhosted.org/packages/73/1a/50109bb2703bc6f774b52ea081db21edf2a9fa4b6d7485faadf9d1b997e9/fonttools-4.55.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5480673f599ad410695ca2ddef2dfefe9df779a9a5cda89503881e503c9c7d90", size = 4877541 }, + { url = "https://files.pythonhosted.org/packages/5d/52/c0b9857fa075da1b8806c5dc2d8342918a8cc2065fd14fbddb3303282693/fonttools-4.55.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da9da6d65cd7aa6b0f806556f4985bcbf603bf0c5c590e61b43aa3e5a0f822d0", size = 4906304 }, + { url = "https://files.pythonhosted.org/packages/0b/1b/55f85c7e962d295e456d5209581c919620ee3e877b95cd86245187a5050f/fonttools-4.55.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e894b5bd60d9f473bed7a8f506515549cc194de08064d829464088d23097331b", size = 4888087 }, + { url = "https://files.pythonhosted.org/packages/83/13/6f2809c612ea2ac51391f92468ff861c63473601530fca96458b453212bf/fonttools-4.55.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:aee3b57643827e237ff6ec6d28d9ff9766bd8b21e08cd13bff479e13d4b14765", size = 5056958 }, + { url = "https://files.pythonhosted.org/packages/c1/28/d0ea9e872fa4208b9dfca686e1dd9ca22f6c9ef33ecff2f0ebc2dbe7c29b/fonttools-4.55.3-cp311-cp311-win32.whl", hash = "sha256:eb6ca911c4c17eb51853143624d8dc87cdcdf12a711fc38bf5bd21521e79715f", size = 2173939 }, + { url = "https://files.pythonhosted.org/packages/be/36/d74ae1020bc41a1dff3e6f5a99f646563beecb97e386d27abdac3ba07650/fonttools-4.55.3-cp311-cp311-win_amd64.whl", hash = "sha256:6314bf82c54c53c71805318fcf6786d986461622dd926d92a465199ff54b1b72", size = 2220363 }, + { url = "https://files.pythonhosted.org/packages/89/58/fbcf5dff7e3ea844bb00c4d806ca1e339e1f2dce5529633bf4842c0c9a1f/fonttools-4.55.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f9e736f60f4911061235603a6119e72053073a12c6d7904011df2d8fad2c0e35", size = 2765380 }, + { url = "https://files.pythonhosted.org/packages/81/dd/da6e329e51919b4f421c8738f3497e2ab08c168e76aaef7b6d5351862bdf/fonttools-4.55.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a8aa2c5e5b8b3bcb2e4538d929f6589a5c6bdb84fd16e2ed92649fb5454f11c", size = 2297940 }, + { url = "https://files.pythonhosted.org/packages/00/44/f5ee560858425c99ef07e04919e736db09d6416408e5a8d3bbfb4a6623fd/fonttools-4.55.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07f8288aacf0a38d174445fc78377a97fb0b83cfe352a90c9d9c1400571963c7", size = 4793327 }, + { url = "https://files.pythonhosted.org/packages/24/da/0a001926d791c55e29ac3c52964957a20dbc1963615446b568b7432891c3/fonttools-4.55.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8d5e8916c0970fbc0f6f1bece0063363bb5857a7f170121a4493e31c3db3314", size = 4865624 }, + { url = "https://files.pythonhosted.org/packages/3d/d8/1edd8b13a427a9fb6418373437caa586c0caa57f260af8e0548f4d11e340/fonttools-4.55.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae3b6600565b2d80b7c05acb8e24d2b26ac407b27a3f2e078229721ba5698427", size = 4774166 }, + { url = "https://files.pythonhosted.org/packages/9c/ec/ade054097976c3d6debc9032e09a351505a0196aa5493edf021be376f75e/fonttools-4.55.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:54153c49913f45065c8d9e6d0c101396725c5621c8aee744719300f79771d75a", size = 5001832 }, + { url = "https://files.pythonhosted.org/packages/e2/cd/233f0e31ad799bb91fc78099c8b4e5ec43b85a131688519640d6bae46f6a/fonttools-4.55.3-cp312-cp312-win32.whl", hash = "sha256:827e95fdbbd3e51f8b459af5ea10ecb4e30af50221ca103bea68218e9615de07", size = 2162228 }, + { url = "https://files.pythonhosted.org/packages/46/45/a498b5291f6c0d91b2394b1ed7447442a57d1c9b9cf8f439aee3c316a56e/fonttools-4.55.3-cp312-cp312-win_amd64.whl", hash = "sha256:e6e8766eeeb2de759e862004aa11a9ea3d6f6d5ec710551a88b476192b64fd54", size = 2209118 }, + { url = "https://files.pythonhosted.org/packages/9c/9f/00142a19bad96eeeb1aed93f567adc19b7f2c1af6f5bc0a1c3de90b4b1ac/fonttools-4.55.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a430178ad3e650e695167cb53242dae3477b35c95bef6525b074d87493c4bf29", size = 2752812 }, + { url = "https://files.pythonhosted.org/packages/b0/20/14b8250d63ba65e162091fb0dda07730f90c303bbf5257e9ddacec7230d9/fonttools-4.55.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:529cef2ce91dc44f8e407cc567fae6e49a1786f2fefefa73a294704c415322a4", size = 2291521 }, + { url = "https://files.pythonhosted.org/packages/34/47/a681cfd10245eb74f65e491a934053ec75c4af639655446558f29818e45e/fonttools-4.55.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e75f12c82127486fac2d8bfbf5bf058202f54bf4f158d367e41647b972342ca", size = 4770980 }, + { url = "https://files.pythonhosted.org/packages/d2/6c/a7066afc19db0705a12efd812e19c32cde2b9514eb714659522f2ebd60b6/fonttools-4.55.3-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:859c358ebf41db18fb72342d3080bce67c02b39e86b9fbcf1610cca14984841b", size = 4845534 }, + { url = "https://files.pythonhosted.org/packages/0c/a2/3c204fbabbfd845d9bdcab9ae35279d41e9a4bf5c80a0a2708f9c5a195d6/fonttools-4.55.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:546565028e244a701f73df6d8dd6be489d01617863ec0c6a42fa25bf45d43048", size = 4753910 }, + { url = "https://files.pythonhosted.org/packages/6e/8c/b4cb3592880340b89e4ef6601b531780bba73862332a6451d78fe135d6cb/fonttools-4.55.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:aca318b77f23523309eec4475d1fbbb00a6b133eb766a8bdc401faba91261abe", size = 4976411 }, + { url = "https://files.pythonhosted.org/packages/fc/a8/4bf98840ff89fcc188470b59daec57322178bf36d2f4f756cd19a42a826b/fonttools-4.55.3-cp313-cp313-win32.whl", hash = "sha256:8c5ec45428edaa7022f1c949a632a6f298edc7b481312fc7dc258921e9399628", size = 2160178 }, + { url = "https://files.pythonhosted.org/packages/e6/57/4cc35004605416df3225ff362f3455cf09765db00df578ae9e46d0fefd23/fonttools-4.55.3-cp313-cp313-win_amd64.whl", hash = "sha256:11e5de1ee0d95af4ae23c1a138b184b7f06e0b6abacabf1d0db41c90b03d834b", size = 2206102 }, + { url = "https://files.pythonhosted.org/packages/99/3b/406d17b1f63e04a82aa621936e6e1c53a8c05458abd66300ac85ea7f9ae9/fonttools-4.55.3-py3-none-any.whl", hash = "sha256:f412604ccbeee81b091b420272841e5ec5ef68967a9790e80bffd0e30b8e2977", size = 1111638 }, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121 }, +] + +[[package]] +name = "h11" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 }, +] + +[[package]] +name = "httpcore" +version = "1.0.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/5c/67594cb0c7055dc50814b21731c22a601101ea3b1b50a9a1b090e11f5d0f/ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215", size = 163367 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/5c/368ae6c01c7628438358e6d337c19b05425727fbb221d2a3c4303c372f42/ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5", size = 117173 }, +] + +[[package]] +name = "ipython" +version = "8.31.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/01/35/6f90fdddff7a08b7b715fccbd2427b5212c9525cd043d26fdc45bee0708d/ipython-8.31.0.tar.gz", hash = "sha256:b6a2274606bec6166405ff05e54932ed6e5cfecaca1fc05f2cacde7bb074d70b", size = 5501011 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/60/d0feb6b6d9fe4ab89fe8fe5b47cbf6cd936bfd9f1e7ffa9d0015425aeed6/ipython-8.31.0-py3-none-any.whl", hash = "sha256:46ec58f8d3d076a61d128fe517a51eb730e3aaf0c184ea8c17d16e366660c6a6", size = 821583 }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321 }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 }, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/92/b3130cbbf5591acf9ade8708c365f3238046ac7cb8ccba6e81abccb0ccff/jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb", size = 244674 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/0f/2ba5fbcd631e3e88689309dbe978c5769e883e4b84ebfe7da30b43275c5a/jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb", size = 134596 }, +] + +[[package]] +name = "json5" +version = "0.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/3d/bbe62f3d0c05a689c711cff57b2e3ac3d3e526380adb7c781989f075115c/json5-0.10.0.tar.gz", hash = "sha256:e66941c8f0a02026943c52c2eb34ebeb2a6f819a0be05920a6f5243cd30fd559", size = 48202 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/42/797895b952b682c3dafe23b1834507ee7f02f4d6299b65aaa61425763278/json5-0.10.0-py3-none-any.whl", hash = "sha256:19b23410220a7271e8377f81ba8aacba2fdd56947fbb137ee5977cbe1f5e8dfa", size = 34049 }, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595 }, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4", size = 325778 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566", size = 88462 }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2024.10.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/10/db/58f950c996c793472e336ff3655b13fbcf1e3b359dcf52dcf3ed3b52c352/jsonschema_specifications-2024.10.1.tar.gz", hash = "sha256:0f38b83639958ce1152d02a7f062902c41c8fd20d558b0c34344292d417ae272", size = 15561 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/0f/8910b19ac0670a0f80ce1008e5e751c4a57e14d2c4c13a482aa6079fa9d6/jsonschema_specifications-2024.10.1-py3-none-any.whl", hash = "sha256:a09a0680616357d9a0ecf05c12ad234479f549239d0f5b55f3deea67475da9bf", size = 18459 }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105 }, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/11/b56381fa6c3f4cc5d2cf54a7dbf98ad9aa0b339ef7a601d6053538b079a7/jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9", size = 87629 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/fb/108ecd1fe961941959ad0ee4e12ee7b8b1477247f30b1fdfd83ceaf017f0/jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409", size = 28965 }, +] + +[[package]] +name = "jupyter-events" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/65/5791c8a979b5646ca29ea50e42b6708908b789f7ff389d1a03c1b93a1c54/jupyter_events-0.11.0.tar.gz", hash = "sha256:c0bc56a37aac29c1fbc3bcfbddb8c8c49533f9cf11f1c4e6adadba936574ab90", size = 62039 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/8c/9b65cb2cd4ea32d885993d5542244641590530836802a2e8c7449a4c61c9/jupyter_events-0.11.0-py3-none-any.whl", hash = "sha256:36399b41ce1ca45fe8b8271067d6a140ffa54cec4028e95491c93b78a855cacf", size = 19423 }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/85/b4/3200b0b09c12bc3b72d943d923323c398eff382d1dcc7c0dbc8b74630e40/jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001", size = 48741 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/e0/7bd7cff65594fd9936e2f9385701e44574fc7d721331ff676ce440b14100/jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da", size = 69146 }, +] + +[[package]] +name = "jupyter-server" +version = "2.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "overrides" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/8c/df09d4ab646141f130f9977b32b206ba8615d1969b2eba6a2e84b7f89137/jupyter_server-2.15.0.tar.gz", hash = "sha256:9d446b8697b4f7337a1b7cdcac40778babdd93ba614b6d68ab1c0c918f1c4084", size = 725227 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/a2/89eeaf0bb954a123a909859fa507fa86f96eb61b62dc30667b60dbd5fdaf/jupyter_server-2.15.0-py3-none-any.whl", hash = "sha256:872d989becf83517012ee669f09604aa4a28097c0bd90b2f424310156c2cdae3", size = 385826 }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/2d/2b32cdbe8d2a602f697a649798554e4f072115438e92249624e532e8aca6/jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa", size = 13656 }, +] + +[[package]] +name = "jupyterlab" +version = "4.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a7/45/1052f842e066902b1d78126df7e2269b1b9408991e1344e167b2e429f9e1/jupyterlab-4.3.4.tar.gz", hash = "sha256:f0bb9b09a04766e3423cccc2fc23169aa2ffedcdf8713e9e0fb33cac0b6859d0", size = 21797583 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/48/af57263e53cfc220e522de047aa0993f53bab734fe812af1e03e33ac6d7c/jupyterlab-4.3.4-py3-none-any.whl", hash = "sha256:b754c2601c5be6adf87cb5a1d8495d653ffb945f021939f77776acaa94dae952", size = 11665373 }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884 }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/c9/a883ce65eb27905ce77ace410d83587c82ea64dc85a48d1f7ed52bcfa68d/jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4", size = 76173 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/09/2032e7d15c544a0e3cd831c51d77a8ca57f7555b2e1b2922142eddb02a84/jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4", size = 59700 }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/5f/4d8e9e852d98ecd26cdf8eaf7ed8bc33174033bba5e07001b289f07308fd/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88c6f252f6816a73b1f8c904f7bbe02fd67c09a69f7cb8a0eecdbf5ce78e63db", size = 124623 }, + { url = "https://files.pythonhosted.org/packages/1d/70/7f5af2a18a76fe92ea14675f8bd88ce53ee79e37900fa5f1a1d8e0b42998/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c72941acb7b67138f35b879bbe85be0f6c6a70cab78fe3ef6db9c024d9223e5b", size = 66720 }, + { url = "https://files.pythonhosted.org/packages/c6/13/e15f804a142353aefd089fadc8f1d985561a15358c97aca27b0979cb0785/kiwisolver-1.4.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce2cf1e5688edcb727fdf7cd1bbd0b6416758996826a8be1d958f91880d0809d", size = 65413 }, + { url = "https://files.pythonhosted.org/packages/ce/6d/67d36c4d2054e83fb875c6b59d0809d5c530de8148846b1370475eeeece9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c8bf637892dc6e6aad2bc6d4d69d08764166e5e3f69d469e55427b6ac001b19d", size = 1650826 }, + { url = "https://files.pythonhosted.org/packages/de/c6/7b9bb8044e150d4d1558423a1568e4f227193662a02231064e3824f37e0a/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:034d2c891f76bd3edbdb3ea11140d8510dca675443da7304205a2eaa45d8334c", size = 1628231 }, + { url = "https://files.pythonhosted.org/packages/b6/38/ad10d437563063eaaedbe2c3540a71101fc7fb07a7e71f855e93ea4de605/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d47b28d1dfe0793d5e96bce90835e17edf9a499b53969b03c6c47ea5985844c3", size = 1408938 }, + { url = "https://files.pythonhosted.org/packages/52/ce/c0106b3bd7f9e665c5f5bc1e07cc95b5dabd4e08e3dad42dbe2faad467e7/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb158fe28ca0c29f2260cca8c43005329ad58452c36f0edf298204de32a9a3ed", size = 1422799 }, + { url = "https://files.pythonhosted.org/packages/d0/87/efb704b1d75dc9758087ba374c0f23d3254505edaedd09cf9d247f7878b9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5536185fce131780ebd809f8e623bf4030ce1b161353166c49a3c74c287897f", size = 1354362 }, + { url = "https://files.pythonhosted.org/packages/eb/b3/fd760dc214ec9a8f208b99e42e8f0130ff4b384eca8b29dd0efc62052176/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:369b75d40abedc1da2c1f4de13f3482cb99e3237b38726710f4a793432b1c5ff", size = 2222695 }, + { url = "https://files.pythonhosted.org/packages/a2/09/a27fb36cca3fc01700687cc45dae7a6a5f8eeb5f657b9f710f788748e10d/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:641f2ddf9358c80faa22e22eb4c9f54bd3f0e442e038728f500e3b978d00aa7d", size = 2370802 }, + { url = "https://files.pythonhosted.org/packages/3d/c3/ba0a0346db35fe4dc1f2f2cf8b99362fbb922d7562e5f911f7ce7a7b60fa/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d561d2d8883e0819445cfe58d7ddd673e4015c3c57261d7bdcd3710d0d14005c", size = 2334646 }, + { url = "https://files.pythonhosted.org/packages/41/52/942cf69e562f5ed253ac67d5c92a693745f0bed3c81f49fc0cbebe4d6b00/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1732e065704b47c9afca7ffa272f845300a4eb959276bf6970dc07265e73b605", size = 2467260 }, + { url = "https://files.pythonhosted.org/packages/32/26/2d9668f30d8a494b0411d4d7d4ea1345ba12deb6a75274d58dd6ea01e951/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bcb1ebc3547619c3b58a39e2448af089ea2ef44b37988caf432447374941574e", size = 2288633 }, + { url = "https://files.pythonhosted.org/packages/98/99/0dd05071654aa44fe5d5e350729961e7bb535372935a45ac89a8924316e6/kiwisolver-1.4.8-cp310-cp310-win_amd64.whl", hash = "sha256:89c107041f7b27844179ea9c85d6da275aa55ecf28413e87624d033cf1f6b751", size = 71885 }, + { url = "https://files.pythonhosted.org/packages/6c/fc/822e532262a97442989335394d441cd1d0448c2e46d26d3e04efca84df22/kiwisolver-1.4.8-cp310-cp310-win_arm64.whl", hash = "sha256:b5773efa2be9eb9fcf5415ea3ab70fc785d598729fd6057bea38d539ead28271", size = 65175 }, + { url = "https://files.pythonhosted.org/packages/da/ed/c913ee28936c371418cb167b128066ffb20bbf37771eecc2c97edf8a6e4c/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a4d3601908c560bdf880f07d94f31d734afd1bb71e96585cace0e38ef44c6d84", size = 124635 }, + { url = "https://files.pythonhosted.org/packages/4c/45/4a7f896f7467aaf5f56ef093d1f329346f3b594e77c6a3c327b2d415f521/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:856b269c4d28a5c0d5e6c1955ec36ebfd1651ac00e1ce0afa3e28da95293b561", size = 66717 }, + { url = "https://files.pythonhosted.org/packages/5f/b4/c12b3ac0852a3a68f94598d4c8d569f55361beef6159dce4e7b624160da2/kiwisolver-1.4.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c2b9a96e0f326205af81a15718a9073328df1173a2619a68553decb7097fd5d7", size = 65413 }, + { url = "https://files.pythonhosted.org/packages/a9/98/1df4089b1ed23d83d410adfdc5947245c753bddfbe06541c4aae330e9e70/kiwisolver-1.4.8-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5020c83e8553f770cb3b5fc13faac40f17e0b205bd237aebd21d53d733adb03", size = 1343994 }, + { url = "https://files.pythonhosted.org/packages/8d/bf/b4b169b050c8421a7c53ea1ea74e4ef9c335ee9013216c558a047f162d20/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dace81d28c787956bfbfbbfd72fdcef014f37d9b48830829e488fdb32b49d954", size = 1434804 }, + { url = "https://files.pythonhosted.org/packages/66/5a/e13bd341fbcf73325ea60fdc8af752addf75c5079867af2e04cc41f34434/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11e1022b524bd48ae56c9b4f9296bce77e15a2e42a502cceba602f804b32bb79", size = 1450690 }, + { url = "https://files.pythonhosted.org/packages/9b/4f/5955dcb376ba4a830384cc6fab7d7547bd6759fe75a09564910e9e3bb8ea/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b9b4d2892fefc886f30301cdd80debd8bb01ecdf165a449eb6e78f79f0fabd6", size = 1376839 }, + { url = "https://files.pythonhosted.org/packages/3a/97/5edbed69a9d0caa2e4aa616ae7df8127e10f6586940aa683a496c2c280b9/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a96c0e790ee875d65e340ab383700e2b4891677b7fcd30a699146f9384a2bb0", size = 1435109 }, + { url = "https://files.pythonhosted.org/packages/13/fc/e756382cb64e556af6c1809a1bbb22c141bbc2445049f2da06b420fe52bf/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:23454ff084b07ac54ca8be535f4174170c1094a4cff78fbae4f73a4bcc0d4dab", size = 2245269 }, + { url = "https://files.pythonhosted.org/packages/76/15/e59e45829d7f41c776d138245cabae6515cb4eb44b418f6d4109c478b481/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:87b287251ad6488e95b4f0b4a79a6d04d3ea35fde6340eb38fbd1ca9cd35bbbc", size = 2393468 }, + { url = "https://files.pythonhosted.org/packages/e9/39/483558c2a913ab8384d6e4b66a932406f87c95a6080112433da5ed668559/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b21dbe165081142b1232a240fc6383fd32cdd877ca6cc89eab93e5f5883e1c25", size = 2355394 }, + { url = "https://files.pythonhosted.org/packages/01/aa/efad1fbca6570a161d29224f14b082960c7e08268a133fe5dc0f6906820e/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:768cade2c2df13db52475bd28d3a3fac8c9eff04b0e9e2fda0f3760f20b3f7fc", size = 2490901 }, + { url = "https://files.pythonhosted.org/packages/c9/4f/15988966ba46bcd5ab9d0c8296914436720dd67fca689ae1a75b4ec1c72f/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d47cfb2650f0e103d4bf68b0b5804c68da97272c84bb12850d877a95c056bd67", size = 2312306 }, + { url = "https://files.pythonhosted.org/packages/2d/27/bdf1c769c83f74d98cbc34483a972f221440703054894a37d174fba8aa68/kiwisolver-1.4.8-cp311-cp311-win_amd64.whl", hash = "sha256:ed33ca2002a779a2e20eeb06aea7721b6e47f2d4b8a8ece979d8ba9e2a167e34", size = 71966 }, + { url = "https://files.pythonhosted.org/packages/4a/c9/9642ea855604aeb2968a8e145fc662edf61db7632ad2e4fb92424be6b6c0/kiwisolver-1.4.8-cp311-cp311-win_arm64.whl", hash = "sha256:16523b40aab60426ffdebe33ac374457cf62863e330a90a0383639ce14bf44b2", size = 65311 }, + { url = "https://files.pythonhosted.org/packages/fc/aa/cea685c4ab647f349c3bc92d2daf7ae34c8e8cf405a6dcd3a497f58a2ac3/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6af5e8815fd02997cb6ad9bbed0ee1e60014438ee1a5c2444c96f87b8843502", size = 124152 }, + { url = "https://files.pythonhosted.org/packages/c5/0b/8db6d2e2452d60d5ebc4ce4b204feeb16176a851fd42462f66ade6808084/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bade438f86e21d91e0cf5dd7c0ed00cda0f77c8c1616bd83f9fc157fa6760d31", size = 66555 }, + { url = "https://files.pythonhosted.org/packages/60/26/d6a0db6785dd35d3ba5bf2b2df0aedc5af089962c6eb2cbf67a15b81369e/kiwisolver-1.4.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b83dc6769ddbc57613280118fb4ce3cd08899cc3369f7d0e0fab518a7cf37fdb", size = 65067 }, + { url = "https://files.pythonhosted.org/packages/c9/ed/1d97f7e3561e09757a196231edccc1bcf59d55ddccefa2afc9c615abd8e0/kiwisolver-1.4.8-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111793b232842991be367ed828076b03d96202c19221b5ebab421ce8bcad016f", size = 1378443 }, + { url = "https://files.pythonhosted.org/packages/29/61/39d30b99954e6b46f760e6289c12fede2ab96a254c443639052d1b573fbc/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:257af1622860e51b1a9d0ce387bf5c2c4f36a90594cb9514f55b074bcc787cfc", size = 1472728 }, + { url = "https://files.pythonhosted.org/packages/0c/3e/804163b932f7603ef256e4a715e5843a9600802bb23a68b4e08c8c0ff61d/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b5637c3f316cab1ec1c9a12b8c5f4750a4c4b71af9157645bf32830e39c03a", size = 1478388 }, + { url = "https://files.pythonhosted.org/packages/8a/9e/60eaa75169a154700be74f875a4d9961b11ba048bef315fbe89cb6999056/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:782bb86f245ec18009890e7cb8d13a5ef54dcf2ebe18ed65f795e635a96a1c6a", size = 1413849 }, + { url = "https://files.pythonhosted.org/packages/bc/b3/9458adb9472e61a998c8c4d95cfdfec91c73c53a375b30b1428310f923e4/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc978a80a0db3a66d25767b03688f1147a69e6237175c0f4ffffaaedf744055a", size = 1475533 }, + { url = "https://files.pythonhosted.org/packages/e4/7a/0a42d9571e35798de80aef4bb43a9b672aa7f8e58643d7bd1950398ffb0a/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:36dbbfd34838500a31f52c9786990d00150860e46cd5041386f217101350f0d3", size = 2268898 }, + { url = "https://files.pythonhosted.org/packages/d9/07/1255dc8d80271400126ed8db35a1795b1a2c098ac3a72645075d06fe5c5d/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eaa973f1e05131de5ff3569bbba7f5fd07ea0595d3870ed4a526d486fe57fa1b", size = 2425605 }, + { url = "https://files.pythonhosted.org/packages/84/df/5a3b4cf13780ef6f6942df67b138b03b7e79e9f1f08f57c49957d5867f6e/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a66f60f8d0c87ab7f59b6fb80e642ebb29fec354a4dfad687ca4092ae69d04f4", size = 2375801 }, + { url = "https://files.pythonhosted.org/packages/8f/10/2348d068e8b0f635c8c86892788dac7a6b5c0cb12356620ab575775aad89/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858416b7fb777a53f0c59ca08190ce24e9abbd3cffa18886a5781b8e3e26f65d", size = 2520077 }, + { url = "https://files.pythonhosted.org/packages/32/d8/014b89fee5d4dce157d814303b0fce4d31385a2af4c41fed194b173b81ac/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:085940635c62697391baafaaeabdf3dd7a6c3643577dde337f4d66eba021b2b8", size = 2338410 }, + { url = "https://files.pythonhosted.org/packages/bd/72/dfff0cc97f2a0776e1c9eb5bef1ddfd45f46246c6533b0191887a427bca5/kiwisolver-1.4.8-cp312-cp312-win_amd64.whl", hash = "sha256:01c3d31902c7db5fb6182832713d3b4122ad9317c2c5877d0539227d96bb2e50", size = 71853 }, + { url = "https://files.pythonhosted.org/packages/dc/85/220d13d914485c0948a00f0b9eb419efaf6da81b7d72e88ce2391f7aed8d/kiwisolver-1.4.8-cp312-cp312-win_arm64.whl", hash = "sha256:a3c44cb68861de93f0c4a8175fbaa691f0aa22550c331fefef02b618a9dcb476", size = 65424 }, + { url = "https://files.pythonhosted.org/packages/79/b3/e62464a652f4f8cd9006e13d07abad844a47df1e6537f73ddfbf1bc997ec/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1c8ceb754339793c24aee1c9fb2485b5b1f5bb1c2c214ff13368431e51fc9a09", size = 124156 }, + { url = "https://files.pythonhosted.org/packages/8d/2d/f13d06998b546a2ad4f48607a146e045bbe48030774de29f90bdc573df15/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a62808ac74b5e55a04a408cda6156f986cefbcf0ada13572696b507cc92fa1", size = 66555 }, + { url = "https://files.pythonhosted.org/packages/59/e3/b8bd14b0a54998a9fd1e8da591c60998dc003618cb19a3f94cb233ec1511/kiwisolver-1.4.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:68269e60ee4929893aad82666821aaacbd455284124817af45c11e50a4b42e3c", size = 65071 }, + { url = "https://files.pythonhosted.org/packages/f0/1c/6c86f6d85ffe4d0ce04228d976f00674f1df5dc893bf2dd4f1928748f187/kiwisolver-1.4.8-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34d142fba9c464bc3bbfeff15c96eab0e7310343d6aefb62a79d51421fcc5f1b", size = 1378053 }, + { url = "https://files.pythonhosted.org/packages/4e/b9/1c6e9f6dcb103ac5cf87cb695845f5fa71379021500153566d8a8a9fc291/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc373e0eef45b59197de815b1b28ef89ae3955e7722cc9710fb91cd77b7f47", size = 1472278 }, + { url = "https://files.pythonhosted.org/packages/ee/81/aca1eb176de671f8bda479b11acdc42c132b61a2ac861c883907dde6debb/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77e6f57a20b9bd4e1e2cedda4d0b986ebd0216236f0106e55c28aea3d3d69b16", size = 1478139 }, + { url = "https://files.pythonhosted.org/packages/49/f4/e081522473671c97b2687d380e9e4c26f748a86363ce5af48b4a28e48d06/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08e77738ed7538f036cd1170cbed942ef749137b1311fa2bbe2a7fda2f6bf3cc", size = 1413517 }, + { url = "https://files.pythonhosted.org/packages/8f/e9/6a7d025d8da8c4931522922cd706105aa32b3291d1add8c5427cdcd66e63/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5ce1e481a74b44dd5e92ff03ea0cb371ae7a0268318e202be06c8f04f4f1246", size = 1474952 }, + { url = "https://files.pythonhosted.org/packages/82/13/13fa685ae167bee5d94b415991c4fc7bb0a1b6ebea6e753a87044b209678/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc2ace710ba7c1dfd1a3b42530b62b9ceed115f19a1656adefce7b1782a37794", size = 2269132 }, + { url = "https://files.pythonhosted.org/packages/ef/92/bb7c9395489b99a6cb41d502d3686bac692586db2045adc19e45ee64ed23/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3452046c37c7692bd52b0e752b87954ef86ee2224e624ef7ce6cb21e8c41cc1b", size = 2425997 }, + { url = "https://files.pythonhosted.org/packages/ed/12/87f0e9271e2b63d35d0d8524954145837dd1a6c15b62a2d8c1ebe0f182b4/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e9a60b50fe8b2ec6f448fe8d81b07e40141bfced7f896309df271a0b92f80f3", size = 2376060 }, + { url = "https://files.pythonhosted.org/packages/02/6e/c8af39288edbce8bf0fa35dee427b082758a4b71e9c91ef18fa667782138/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:918139571133f366e8362fa4a297aeba86c7816b7ecf0bc79168080e2bd79957", size = 2520471 }, + { url = "https://files.pythonhosted.org/packages/13/78/df381bc7b26e535c91469f77f16adcd073beb3e2dd25042efd064af82323/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e063ef9f89885a1d68dd8b2e18f5ead48653176d10a0e324e3b0030e3a69adeb", size = 2338793 }, + { url = "https://files.pythonhosted.org/packages/d0/dc/c1abe38c37c071d0fc71c9a474fd0b9ede05d42f5a458d584619cfd2371a/kiwisolver-1.4.8-cp313-cp313-win_amd64.whl", hash = "sha256:a17b7c4f5b2c51bb68ed379defd608a03954a1845dfed7cc0117f1cc8a9b7fd2", size = 71855 }, + { url = "https://files.pythonhosted.org/packages/a0/b6/21529d595b126ac298fdd90b705d87d4c5693de60023e0efcb4f387ed99e/kiwisolver-1.4.8-cp313-cp313-win_arm64.whl", hash = "sha256:3cd3bc628b25f74aedc6d374d5babf0166a92ff1317f46267f12d2ed54bc1d30", size = 65430 }, + { url = "https://files.pythonhosted.org/packages/34/bd/b89380b7298e3af9b39f49334e3e2a4af0e04819789f04b43d560516c0c8/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370fd2df41660ed4e26b8c9d6bbcad668fbe2560462cba151a721d49e5b6628c", size = 126294 }, + { url = "https://files.pythonhosted.org/packages/83/41/5857dc72e5e4148eaac5aa76e0703e594e4465f8ab7ec0fc60e3a9bb8fea/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:84a2f830d42707de1d191b9490ac186bf7997a9495d4e9072210a1296345f7dc", size = 67736 }, + { url = "https://files.pythonhosted.org/packages/e1/d1/be059b8db56ac270489fb0b3297fd1e53d195ba76e9bbb30e5401fa6b759/kiwisolver-1.4.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7a3ad337add5148cf51ce0b55642dc551c0b9d6248458a757f98796ca7348712", size = 66194 }, + { url = "https://files.pythonhosted.org/packages/e1/83/4b73975f149819eb7dcf9299ed467eba068ecb16439a98990dcb12e63fdd/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7506488470f41169b86d8c9aeff587293f530a23a23a49d6bc64dab66bedc71e", size = 1465942 }, + { url = "https://files.pythonhosted.org/packages/c7/2c/30a5cdde5102958e602c07466bce058b9d7cb48734aa7a4327261ac8e002/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f0121b07b356a22fb0414cec4666bbe36fd6d0d759db3d37228f496ed67c880", size = 1595341 }, + { url = "https://files.pythonhosted.org/packages/ff/9b/1e71db1c000385aa069704f5990574b8244cce854ecd83119c19e83c9586/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6d6bd87df62c27d4185de7c511c6248040afae67028a8a22012b010bc7ad062", size = 1598455 }, + { url = "https://files.pythonhosted.org/packages/85/92/c8fec52ddf06231b31cbb779af77e99b8253cd96bd135250b9498144c78b/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:291331973c64bb9cce50bbe871fb2e675c4331dab4f31abe89f175ad7679a4d7", size = 1522138 }, + { url = "https://files.pythonhosted.org/packages/0b/51/9eb7e2cd07a15d8bdd976f6190c0164f92ce1904e5c0c79198c4972926b7/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:893f5525bb92d3d735878ec00f781b2de998333659507d29ea4466208df37bed", size = 1582857 }, + { url = "https://files.pythonhosted.org/packages/0f/95/c5a00387a5405e68ba32cc64af65ce881a39b98d73cc394b24143bebc5b8/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b47a465040146981dc9db8647981b8cb96366fbc8d452b031e4f8fdffec3f26d", size = 2293129 }, + { url = "https://files.pythonhosted.org/packages/44/83/eeb7af7d706b8347548313fa3a3a15931f404533cc54fe01f39e830dd231/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:99cea8b9dd34ff80c521aef46a1dddb0dcc0283cf18bde6d756f1e6f31772165", size = 2421538 }, + { url = "https://files.pythonhosted.org/packages/05/f9/27e94c1b3eb29e6933b6986ffc5fa1177d2cd1f0c8efc5f02c91c9ac61de/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:151dffc4865e5fe6dafce5480fab84f950d14566c480c08a53c663a0020504b6", size = 2390661 }, + { url = "https://files.pythonhosted.org/packages/d9/d4/3c9735faa36ac591a4afcc2980d2691000506050b7a7e80bcfe44048daa7/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:577facaa411c10421314598b50413aa1ebcf5126f704f1e5d72d7e4e9f020d90", size = 2546710 }, + { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213 }, + { url = "https://files.pythonhosted.org/packages/1f/f9/ae81c47a43e33b93b0a9819cac6723257f5da2a5a60daf46aa5c7226ea85/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e7a019419b7b510f0f7c9dceff8c5eae2392037eae483a7f9162625233802b0a", size = 60403 }, + { url = "https://files.pythonhosted.org/packages/58/ca/f92b5cb6f4ce0c1ebfcfe3e2e42b96917e16f7090e45b21102941924f18f/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:286b18e86682fd2217a48fc6be6b0f20c1d0ed10958d8dc53453ad58d7be0bf8", size = 58657 }, + { url = "https://files.pythonhosted.org/packages/80/28/ae0240f732f0484d3a4dc885d055653c47144bdf59b670aae0ec3c65a7c8/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4191ee8dfd0be1c3666ccbac178c5a05d5f8d689bbe3fc92f3c4abec817f8fe0", size = 84948 }, + { url = "https://files.pythonhosted.org/packages/5d/eb/78d50346c51db22c7203c1611f9b513075f35c4e0e4877c5dde378d66043/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd2785b9391f2873ad46088ed7599a6a71e762e1ea33e87514b1a441ed1da1c", size = 81186 }, + { url = "https://files.pythonhosted.org/packages/43/f8/7259f18c77adca88d5f64f9a522792e178b2691f3748817a8750c2d216ef/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c07b29089b7ba090b6f1a669f1411f27221c3662b3a1b7010e67b59bb5a6f10b", size = 80279 }, + { url = "https://files.pythonhosted.org/packages/3a/1d/50ad811d1c5dae091e4cf046beba925bcae0a610e79ae4c538f996f63ed5/kiwisolver-1.4.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:65ea09a5a3faadd59c2ce96dc7bf0f364986a315949dc6374f04396b0d60e09b", size = 71762 }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357 }, + { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393 }, + { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732 }, + { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866 }, + { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964 }, + { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977 }, + { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366 }, + { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091 }, + { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065 }, + { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514 }, + { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353 }, + { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392 }, + { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984 }, + { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120 }, + { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032 }, + { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057 }, + { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359 }, + { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306 }, + { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094 }, + { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521 }, + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097 }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601 }, + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 }, + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 }, + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 }, + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 }, + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 }, + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 }, + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 }, + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101 }, + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603 }, + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 }, + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 }, + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 }, + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 }, + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 }, + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 }, + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 }, + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 }, + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208 }, + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739 }, +] + +[[package]] +name = "matplotlib" +version = "3.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/68/dd/fa2e1a45fce2d09f4aea3cee169760e672c8262325aa5796c49d543dc7e6/matplotlib-3.10.0.tar.gz", hash = "sha256:b886d02a581b96704c9d1ffe55709e49b4d2d52709ccebc4be42db856e511278", size = 36686418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/09/ec/3cdff7b5239adaaacefcc4f77c316dfbbdf853c4ed2beec467e0fec31b9f/matplotlib-3.10.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2c5829a5a1dd5a71f0e31e6e8bb449bc0ee9dbfb05ad28fc0c6b55101b3a4be6", size = 8160551 }, + { url = "https://files.pythonhosted.org/packages/41/f2/b518f2c7f29895c9b167bf79f8529c63383ae94eaf49a247a4528e9a148d/matplotlib-3.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2a43cbefe22d653ab34bb55d42384ed30f611bcbdea1f8d7f431011a2e1c62e", size = 8034853 }, + { url = "https://files.pythonhosted.org/packages/ed/8d/45754b4affdb8f0d1a44e4e2bcd932cdf35b256b60d5eda9f455bb293ed0/matplotlib-3.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:607b16c8a73943df110f99ee2e940b8a1cbf9714b65307c040d422558397dac5", size = 8446724 }, + { url = "https://files.pythonhosted.org/packages/09/5a/a113495110ae3e3395c72d82d7bc4802902e46dc797f6b041e572f195c56/matplotlib-3.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01d2b19f13aeec2e759414d3bfe19ddfb16b13a1250add08d46d5ff6f9be83c6", size = 8583905 }, + { url = "https://files.pythonhosted.org/packages/12/b1/8b1655b4c9ed4600c817c419f7eaaf70082630efd7556a5b2e77a8a3cdaf/matplotlib-3.10.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e6c6461e1fc63df30bf6f80f0b93f5b6784299f721bc28530477acd51bfc3d1", size = 9395223 }, + { url = "https://files.pythonhosted.org/packages/5a/85/b9a54d64585a6b8737a78a61897450403c30f39e0bd3214270bb0b96f002/matplotlib-3.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:994c07b9d9fe8d25951e3202a68c17900679274dadfc1248738dcfa1bd40d7f3", size = 8025355 }, + { url = "https://files.pythonhosted.org/packages/0c/f1/e37f6c84d252867d7ddc418fff70fc661cfd363179263b08e52e8b748e30/matplotlib-3.10.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:fd44fc75522f58612ec4a33958a7e5552562b7705b42ef1b4f8c0818e304a363", size = 8171677 }, + { url = "https://files.pythonhosted.org/packages/c7/8b/92e9da1f28310a1f6572b5c55097b0c0ceb5e27486d85fb73b54f5a9b939/matplotlib-3.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c58a9622d5dbeb668f407f35f4e6bfac34bb9ecdcc81680c04d0258169747997", size = 8044945 }, + { url = "https://files.pythonhosted.org/packages/c5/cb/49e83f0fd066937a5bd3bc5c5d63093703f3637b2824df8d856e0558beef/matplotlib-3.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:845d96568ec873be63f25fa80e9e7fae4be854a66a7e2f0c8ccc99e94a8bd4ef", size = 8458269 }, + { url = "https://files.pythonhosted.org/packages/b2/7d/2d873209536b9ee17340754118a2a17988bc18981b5b56e6715ee07373ac/matplotlib-3.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5439f4c5a3e2e8eab18e2f8c3ef929772fd5641876db71f08127eed95ab64683", size = 8599369 }, + { url = "https://files.pythonhosted.org/packages/b8/03/57d6cbbe85c61fe4cbb7c94b54dce443d68c21961830833a1f34d056e5ea/matplotlib-3.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4673ff67a36152c48ddeaf1135e74ce0d4bce1bbf836ae40ed39c29edf7e2765", size = 9405992 }, + { url = "https://files.pythonhosted.org/packages/14/cf/e382598f98be11bf51dd0bc60eca44a517f6793e3dc8b9d53634a144620c/matplotlib-3.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:7e8632baebb058555ac0cde75db885c61f1212e47723d63921879806b40bec6a", size = 8034580 }, + { url = "https://files.pythonhosted.org/packages/44/c7/6b2d8cb7cc251d53c976799cacd3200add56351c175ba89ab9cbd7c1e68a/matplotlib-3.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4659665bc7c9b58f8c00317c3c2a299f7f258eeae5a5d56b4c64226fca2f7c59", size = 8172465 }, + { url = "https://files.pythonhosted.org/packages/42/2a/6d66d0fba41e13e9ca6512a0a51170f43e7e7ed3a8dfa036324100775612/matplotlib-3.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d44cb942af1693cced2604c33a9abcef6205601c445f6d0dc531d813af8a2f5a", size = 8043300 }, + { url = "https://files.pythonhosted.org/packages/90/60/2a60342b27b90a16bada939a85e29589902b41073f59668b904b15ea666c/matplotlib-3.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a994f29e968ca002b50982b27168addfd65f0105610b6be7fa515ca4b5307c95", size = 8448936 }, + { url = "https://files.pythonhosted.org/packages/a7/b2/d872fc3d753516870d520595ddd8ce4dd44fa797a240999f125f58521ad7/matplotlib-3.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b0558bae37f154fffda54d779a592bc97ca8b4701f1c710055b609a3bac44c8", size = 8594151 }, + { url = "https://files.pythonhosted.org/packages/f4/bd/b2f60cf7f57d014ab33e4f74602a2b5bdc657976db8196bbc022185f6f9c/matplotlib-3.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:503feb23bd8c8acc75541548a1d709c059b7184cde26314896e10a9f14df5f12", size = 9400347 }, + { url = "https://files.pythonhosted.org/packages/9f/6e/264673e64001b99d747aff5a288eca82826c024437a3694e19aed1decf46/matplotlib-3.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:c40ba2eb08b3f5de88152c2333c58cee7edcead0a2a0d60fcafa116b17117adc", size = 8039144 }, + { url = "https://files.pythonhosted.org/packages/72/11/1b2a094d95dcb6e6edd4a0b238177c439006c6b7a9fe8d31801237bf512f/matplotlib-3.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96f2886f5c1e466f21cc41b70c5a0cd47bfa0015eb2d5793c88ebce658600e25", size = 8173073 }, + { url = "https://files.pythonhosted.org/packages/0d/c4/87b6ad2723070511a411ea719f9c70fde64605423b184face4e94986de9d/matplotlib-3.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:12eaf48463b472c3c0f8dbacdbf906e573013df81a0ab82f0616ea4b11281908", size = 8043892 }, + { url = "https://files.pythonhosted.org/packages/57/69/cb0812a136550b21361335e9ffb7d459bf6d13e03cb7b015555d5143d2d6/matplotlib-3.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fbbabc82fde51391c4da5006f965e36d86d95f6ee83fb594b279564a4c5d0d2", size = 8450532 }, + { url = "https://files.pythonhosted.org/packages/ea/3a/bab9deb4fb199c05e9100f94d7f1c702f78d3241e6a71b784d2b88d7bebd/matplotlib-3.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad2e15300530c1a94c63cfa546e3b7864bd18ea2901317bae8bbf06a5ade6dcf", size = 8593905 }, + { url = "https://files.pythonhosted.org/packages/8b/66/742fd242f989adc1847ddf5f445815f73ad7c46aa3440690cc889cfa423c/matplotlib-3.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3547d153d70233a8496859097ef0312212e2689cdf8d7ed764441c77604095ae", size = 9399609 }, + { url = "https://files.pythonhosted.org/packages/fa/d6/54cee7142cef7d910a324a7aedf335c0c147b03658b54d49ec48166f10a6/matplotlib-3.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:c55b20591ced744aa04e8c3e4b7543ea4d650b6c3c4b208c08a05b4010e8b442", size = 8039076 }, + { url = "https://files.pythonhosted.org/packages/43/14/815d072dc36e88753433bfd0385113405efb947e6895ff7b4d2e8614a33b/matplotlib-3.10.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ade1003376731a971e398cc4ef38bb83ee8caf0aee46ac6daa4b0506db1fd06", size = 8211000 }, + { url = "https://files.pythonhosted.org/packages/9a/76/34e75f364194ec352678adcb540964be6f35ec7d3d8c75ebcb17e6839359/matplotlib-3.10.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:95b710fea129c76d30be72c3b38f330269363fbc6e570a5dd43580487380b5ff", size = 8087707 }, + { url = "https://files.pythonhosted.org/packages/c3/2b/b6bc0dff6a72d333bc7df94a66e6ce662d224e43daa8ad8ae4eaa9a77f55/matplotlib-3.10.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cdbaf909887373c3e094b0318d7ff230b2ad9dcb64da7ade654182872ab2593", size = 8477384 }, + { url = "https://files.pythonhosted.org/packages/c2/2d/b5949fb2b76e9b47ab05e25a5f5f887c70de20d8b0cbc704a4e2ee71c786/matplotlib-3.10.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d907fddb39f923d011875452ff1eca29a9e7f21722b873e90db32e5d8ddff12e", size = 8610334 }, + { url = "https://files.pythonhosted.org/packages/d6/9a/6e3c799d5134d9af44b01c787e1360bee38cf51850506ea2e743a787700b/matplotlib-3.10.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3b427392354d10975c1d0f4ee18aa5844640b512d5311ef32efd4dd7db106ede", size = 9406777 }, + { url = "https://files.pythonhosted.org/packages/0e/dd/e6ae97151e5ed648ab2ea48885bc33d39202b640eec7a2910e2c843f7ac0/matplotlib-3.10.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5fd41b0ec7ee45cd960a8e71aea7c946a28a0b8a4dcee47d2856b2af051f334c", size = 8109742 }, + { url = "https://files.pythonhosted.org/packages/32/5f/29def7ce4e815ab939b56280976ee35afffb3bbdb43f332caee74cb8c951/matplotlib-3.10.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:81713dd0d103b379de4516b861d964b1d789a144103277769238c732229d7f03", size = 8155500 }, + { url = "https://files.pythonhosted.org/packages/de/6d/d570383c9f7ca799d0a54161446f9ce7b17d6c50f2994b653514bcaa108f/matplotlib-3.10.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:359f87baedb1f836ce307f0e850d12bb5f1936f70d035561f90d41d305fdacea", size = 8032398 }, + { url = "https://files.pythonhosted.org/packages/c9/b4/680aa700d99b48e8c4393fa08e9ab8c49c0555ee6f4c9c0a5e8ea8dfde5d/matplotlib-3.10.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ae80dc3a4add4665cf2faa90138384a7ffe2a4e37c58d83e115b54287c4f06ef", size = 8587361 }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, +] + +[[package]] +name = "mistune" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/6e/96fc7cb3288666c5de2c396eb0e338dc95f7a8e4920e43e38783a22d0084/mistune-3.1.0.tar.gz", hash = "sha256:dbcac2f78292b9dc066cd03b7a3a26b62d85f8159f2ea5fd28e55df79908d667", size = 94401 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b4/b3/743ffc3f59da380da504d84ccd1faf9a857a1445991ff19bf2ec754163c2/mistune-3.1.0-py3-none-any.whl", hash = "sha256:b05198cf6d671b3deba6c87ec6cf0d4eb7b72c524636eddb6dbf13823b52cee1", size = 53694 }, +] + +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434 }, +] + +[[package]] +name = "nbconvert" +version = "7.16.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/2c/d026c0367f2be2463d4c2f5b538e28add2bc67bc13730abb7f364ae4eb8b/nbconvert-7.16.5.tar.gz", hash = "sha256:c83467bb5777fdfaac5ebbb8e864f300b277f68692ecc04d6dab72f2d8442344", size = 856367 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/9e/2dcc9fe00cf55d95a8deae69384e9cea61816126e345754f6c75494d32ec/nbconvert-7.16.5-py3-none-any.whl", hash = "sha256:e12eac052d6fd03040af4166c563d76e7aeead2e9aadf5356db552a1784bd547", size = 258061 }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454 }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195 }, +] + +[[package]] +name = "notebook" +version = "7.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ea/04/ac488379d5afef43402b3fb4be2857db1a09804fecf98b9b714c741b225b/notebook-7.3.2.tar.gz", hash = "sha256:705e83a1785f45b383bf3ee13cb76680b92d24f56fb0c7d2136fe1d850cd3ca8", size = 12781804 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/9b/76e50ee18f183ea5fe1784a9eeaa50f2c71802e4740d6e959592b0993298/notebook-7.3.2-py3-none-any.whl", hash = "sha256:e5f85fc59b69d3618d73cf27544418193ff8e8058d5bf61d315ce4f473556288", size = 13163630 }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307 }, +] + +[[package]] +name = "numpy" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/fdbf6a7871703df6160b5cf3dd774074b086d278172285c52c2758b76305/numpy-2.2.1.tar.gz", hash = "sha256:45681fd7128c8ad1c379f0ca0776a8b0c6583d2f69889ddac01559dfe4390918", size = 20227662 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/c4/5588367dc9f91e1a813beb77de46ea8cab13f778e1b3a0e661ab031aba44/numpy-2.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5edb4e4caf751c1518e6a26a83501fda79bff41cc59dac48d70e6d65d4ec4440", size = 21213214 }, + { url = "https://files.pythonhosted.org/packages/d8/8b/32dd9f08419023a4cf856c5ad0b4eba9b830da85eafdef841a104c4fc05a/numpy-2.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa3017c40d513ccac9621a2364f939d39e550c542eb2a894b4c8da92b38896ab", size = 14352248 }, + { url = "https://files.pythonhosted.org/packages/84/2d/0e895d02940ba6e12389f0ab5cac5afcf8dc2dc0ade4e8cad33288a721bd/numpy-2.2.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:61048b4a49b1c93fe13426e04e04fdf5a03f456616f6e98c7576144677598675", size = 5391007 }, + { url = "https://files.pythonhosted.org/packages/11/b9/7f1e64a0d46d9c2af6d17966f641fb12d5b8ea3003f31b2308f3e3b9a6aa/numpy-2.2.1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:7671dc19c7019103ca44e8d94917eba8534c76133523ca8406822efdd19c9308", size = 6926174 }, + { url = "https://files.pythonhosted.org/packages/2e/8c/043fa4418bc9364e364ab7aba8ff6ef5f6b9171ade22de8fbcf0e2fa4165/numpy-2.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4250888bcb96617e00bfa28ac24850a83c9f3a16db471eca2ee1f1714df0f957", size = 14330914 }, + { url = "https://files.pythonhosted.org/packages/f7/b6/d8110985501ca8912dfc1c3bbef99d66e62d487f72e46b2337494df77364/numpy-2.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7746f235c47abc72b102d3bce9977714c2444bdfaea7888d241b4c4bb6a78bf", size = 16379607 }, + { url = "https://files.pythonhosted.org/packages/e2/57/bdca9fb8bdaa810c3a4ff2eb3231379b77f618a7c0d24be9f7070db50775/numpy-2.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:059e6a747ae84fce488c3ee397cee7e5f905fd1bda5fb18c66bc41807ff119b2", size = 15541760 }, + { url = "https://files.pythonhosted.org/packages/97/55/3b9147b3cbc3b6b1abc2a411dec5337a46c873deca0dd0bf5bef9d0579cc/numpy-2.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f62aa6ee4eb43b024b0e5a01cf65a0bb078ef8c395e8713c6e8a12a697144528", size = 18168476 }, + { url = "https://files.pythonhosted.org/packages/00/e7/7c2cde16c9b87a8e14fdd262ca7849c4681cf48c8a774505f7e6f5e3b643/numpy-2.2.1-cp310-cp310-win32.whl", hash = "sha256:48fd472630715e1c1c89bf1feab55c29098cb403cc184b4859f9c86d4fcb6a95", size = 6570985 }, + { url = "https://files.pythonhosted.org/packages/a1/a8/554b0e99fc4ac11ec481254781a10da180d0559c2ebf2c324232317349ee/numpy-2.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:b541032178a718c165a49638d28272b771053f628382d5e9d1c93df23ff58dbf", size = 12913384 }, + { url = "https://files.pythonhosted.org/packages/59/14/645887347124e101d983e1daf95b48dc3e136bf8525cb4257bf9eab1b768/numpy-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:40f9e544c1c56ba8f1cf7686a8c9b5bb249e665d40d626a23899ba6d5d9e1484", size = 21217379 }, + { url = "https://files.pythonhosted.org/packages/9f/fd/2279000cf29f58ccfd3778cbf4670dfe3f7ce772df5e198c5abe9e88b7d7/numpy-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f9b57eaa3b0cd8db52049ed0330747b0364e899e8a606a624813452b8203d5f7", size = 14388520 }, + { url = "https://files.pythonhosted.org/packages/58/b0/034eb5d5ba12d66ab658ff3455a31f20add0b78df8203c6a7451bd1bee21/numpy-2.2.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bc8a37ad5b22c08e2dbd27df2b3ef7e5c0864235805b1e718a235bcb200cf1cb", size = 5389286 }, + { url = "https://files.pythonhosted.org/packages/5d/69/6f3cccde92e82e7835fdb475c2bf439761cbf8a1daa7c07338e1e132dfec/numpy-2.2.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:9036d6365d13b6cbe8f27a0eaf73ddcc070cae584e5ff94bb45e3e9d729feab5", size = 6930345 }, + { url = "https://files.pythonhosted.org/packages/d1/72/1cd38e91ab563e67f584293fcc6aca855c9ae46dba42e6b5ff4600022899/numpy-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51faf345324db860b515d3f364eaa93d0e0551a88d6218a7d61286554d190d73", size = 14335748 }, + { url = "https://files.pythonhosted.org/packages/f2/d4/f999444e86986f3533e7151c272bd8186c55dda554284def18557e013a2a/numpy-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38efc1e56b73cc9b182fe55e56e63b044dd26a72128fd2fbd502f75555d92591", size = 16391057 }, + { url = "https://files.pythonhosted.org/packages/99/7b/85cef6a3ae1b19542b7afd97d0b296526b6ef9e3c43ea0c4d9c4404fb2d0/numpy-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:31b89fa67a8042e96715c68e071a1200c4e172f93b0fbe01a14c0ff3ff820fc8", size = 15556943 }, + { url = "https://files.pythonhosted.org/packages/69/7e/b83cc884c3508e91af78760f6b17ab46ad649831b1fa35acb3eb26d9e6d2/numpy-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4c86e2a209199ead7ee0af65e1d9992d1dce7e1f63c4b9a616500f93820658d0", size = 18180785 }, + { url = "https://files.pythonhosted.org/packages/b2/9f/eb4a9a38867de059dcd4b6e18d47c3867fbd3795d4c9557bb49278f94087/numpy-2.2.1-cp311-cp311-win32.whl", hash = "sha256:b34d87e8a3090ea626003f87f9392b3929a7bbf4104a05b6667348b6bd4bf1cd", size = 6568983 }, + { url = "https://files.pythonhosted.org/packages/6d/1e/be3b9f3073da2f8c7fa361fcdc231b548266b0781029fdbaf75eeab997fd/numpy-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:360137f8fb1b753c5cde3ac388597ad680eccbbbb3865ab65efea062c4a1fd16", size = 12917260 }, + { url = "https://files.pythonhosted.org/packages/62/12/b928871c570d4a87ab13d2cc19f8817f17e340d5481621930e76b80ffb7d/numpy-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:694f9e921a0c8f252980e85bce61ebbd07ed2b7d4fa72d0e4246f2f8aa6642ab", size = 20909861 }, + { url = "https://files.pythonhosted.org/packages/3d/c3/59df91ae1d8ad7c5e03efd63fd785dec62d96b0fe56d1f9ab600b55009af/numpy-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3683a8d166f2692664262fd4900f207791d005fb088d7fdb973cc8d663626faa", size = 14095776 }, + { url = "https://files.pythonhosted.org/packages/af/4e/8ed5868efc8e601fb69419644a280e9c482b75691466b73bfaab7d86922c/numpy-2.2.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:780077d95eafc2ccc3ced969db22377b3864e5b9a0ea5eb347cc93b3ea900315", size = 5126239 }, + { url = "https://files.pythonhosted.org/packages/1a/74/dd0bbe650d7bc0014b051f092f2de65e34a8155aabb1287698919d124d7f/numpy-2.2.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:55ba24ebe208344aa7a00e4482f65742969a039c2acfcb910bc6fcd776eb4355", size = 6659296 }, + { url = "https://files.pythonhosted.org/packages/7f/11/4ebd7a3f4a655764dc98481f97bd0a662fb340d1001be6050606be13e162/numpy-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b1d07b53b78bf84a96898c1bc139ad7f10fda7423f5fd158fd0f47ec5e01ac7", size = 14047121 }, + { url = "https://files.pythonhosted.org/packages/7f/a7/c1f1d978166eb6b98ad009503e4d93a8c1962d0eb14a885c352ee0276a54/numpy-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5062dc1a4e32a10dc2b8b13cedd58988261416e811c1dc4dbdea4f57eea61b0d", size = 16096599 }, + { url = "https://files.pythonhosted.org/packages/3d/6d/0e22afd5fcbb4d8d0091f3f46bf4e8906399c458d4293da23292c0ba5022/numpy-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:fce4f615f8ca31b2e61aa0eb5865a21e14f5629515c9151850aa936c02a1ee51", size = 15243932 }, + { url = "https://files.pythonhosted.org/packages/03/39/e4e5832820131ba424092b9610d996b37e5557180f8e2d6aebb05c31ae54/numpy-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:67d4cda6fa6ffa073b08c8372aa5fa767ceb10c9a0587c707505a6d426f4e046", size = 17861032 }, + { url = "https://files.pythonhosted.org/packages/5f/8a/3794313acbf5e70df2d5c7d2aba8718676f8d054a05abe59e48417fb2981/numpy-2.2.1-cp312-cp312-win32.whl", hash = "sha256:32cb94448be47c500d2c7a95f93e2f21a01f1fd05dd2beea1ccd049bb6001cd2", size = 6274018 }, + { url = "https://files.pythonhosted.org/packages/17/c1/c31d3637f2641e25c7a19adf2ae822fdaf4ddd198b05d79a92a9ce7cb63e/numpy-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:ba5511d8f31c033a5fcbda22dd5c813630af98c70b2661f2d2c654ae3cdfcfc8", size = 12613843 }, + { url = "https://files.pythonhosted.org/packages/20/d6/91a26e671c396e0c10e327b763485ee295f5a5a7a48c553f18417e5a0ed5/numpy-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f1d09e520217618e76396377c81fba6f290d5f926f50c35f3a5f72b01a0da780", size = 20896464 }, + { url = "https://files.pythonhosted.org/packages/8c/40/5792ccccd91d45e87d9e00033abc4f6ca8a828467b193f711139ff1f1cd9/numpy-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3ecc47cd7f6ea0336042be87d9e7da378e5c7e9b3c8ad0f7c966f714fc10d821", size = 14111350 }, + { url = "https://files.pythonhosted.org/packages/c0/2a/fb0a27f846cb857cef0c4c92bef89f133a3a1abb4e16bba1c4dace2e9b49/numpy-2.2.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f419290bc8968a46c4933158c91a0012b7a99bb2e465d5ef5293879742f8797e", size = 5111629 }, + { url = "https://files.pythonhosted.org/packages/eb/e5/8e81bb9d84db88b047baf4e8b681a3e48d6390bc4d4e4453eca428ecbb49/numpy-2.2.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5b6c390bfaef8c45a260554888966618328d30e72173697e5cabe6b285fb2348", size = 6645865 }, + { url = "https://files.pythonhosted.org/packages/7a/1a/a90ceb191dd2f9e2897c69dde93ccc2d57dd21ce2acbd7b0333e8eea4e8d/numpy-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:526fc406ab991a340744aad7e25251dd47a6720a685fa3331e5c59fef5282a59", size = 14043508 }, + { url = "https://files.pythonhosted.org/packages/f1/5a/e572284c86a59dec0871a49cd4e5351e20b9c751399d5f1d79628c0542cb/numpy-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f74e6fdeb9a265624ec3a3918430205dff1df7e95a230779746a6af78bc615af", size = 16094100 }, + { url = "https://files.pythonhosted.org/packages/0c/2c/a79d24f364788386d85899dd280a94f30b0950be4b4a545f4fa4ed1d4ca7/numpy-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:53c09385ff0b72ba79d8715683c1168c12e0b6e84fb0372e97553d1ea91efe51", size = 15239691 }, + { url = "https://files.pythonhosted.org/packages/cf/79/1e20fd1c9ce5a932111f964b544facc5bb9bde7865f5b42f00b4a6a9192b/numpy-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f3eac17d9ec51be534685ba877b6ab5edc3ab7ec95c8f163e5d7b39859524716", size = 17856571 }, + { url = "https://files.pythonhosted.org/packages/be/5b/cc155e107f75d694f562bdc84a26cc930569f3dfdfbccb3420b626065777/numpy-2.2.1-cp313-cp313-win32.whl", hash = "sha256:9ad014faa93dbb52c80d8f4d3dcf855865c876c9660cb9bd7553843dd03a4b1e", size = 6270841 }, + { url = "https://files.pythonhosted.org/packages/44/be/0e5cd009d2162e4138d79a5afb3b5d2341f0fe4777ab6e675aa3d4a42e21/numpy-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:164a829b6aacf79ca47ba4814b130c4020b202522a93d7bff2202bfb33b61c60", size = 12606618 }, + { url = "https://files.pythonhosted.org/packages/a8/87/04ddf02dd86fb17c7485a5f87b605c4437966d53de1e3745d450343a6f56/numpy-2.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4dfda918a13cc4f81e9118dea249e192ab167a0bb1966272d5503e39234d694e", size = 20921004 }, + { url = "https://files.pythonhosted.org/packages/6e/3e/d0e9e32ab14005425d180ef950badf31b862f3839c5b927796648b11f88a/numpy-2.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:733585f9f4b62e9b3528dd1070ec4f52b8acf64215b60a845fa13ebd73cd0712", size = 14119910 }, + { url = "https://files.pythonhosted.org/packages/b5/5b/aa2d1905b04a8fb681e08742bb79a7bddfc160c7ce8e1ff6d5c821be0236/numpy-2.2.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:89b16a18e7bba224ce5114db863e7029803c179979e1af6ad6a6b11f70545008", size = 5153612 }, + { url = "https://files.pythonhosted.org/packages/ce/35/6831808028df0648d9b43c5df7e1051129aa0d562525bacb70019c5f5030/numpy-2.2.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:676f4eebf6b2d430300f1f4f4c2461685f8269f94c89698d832cdf9277f30b84", size = 6668401 }, + { url = "https://files.pythonhosted.org/packages/b1/38/10ef509ad63a5946cc042f98d838daebfe7eaf45b9daaf13df2086b15ff9/numpy-2.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27f5cdf9f493b35f7e41e8368e7d7b4bbafaf9660cba53fb21d2cd174ec09631", size = 14014198 }, + { url = "https://files.pythonhosted.org/packages/df/f8/c80968ae01df23e249ee0a4487fae55a4c0fe2f838dfe9cc907aa8aea0fa/numpy-2.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1ad395cf254c4fbb5b2132fee391f361a6e8c1adbd28f2cd8e79308a615fe9d", size = 16076211 }, + { url = "https://files.pythonhosted.org/packages/09/69/05c169376016a0b614b432967ac46ff14269eaffab80040ec03ae1ae8e2c/numpy-2.2.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:08ef779aed40dbc52729d6ffe7dd51df85796a702afbf68a4f4e41fafdc8bda5", size = 15220266 }, + { url = "https://files.pythonhosted.org/packages/f1/ff/94a4ce67ea909f41cf7ea712aebbe832dc67decad22944a1020bb398a5ee/numpy-2.2.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:26c9c4382b19fcfbbed3238a14abf7ff223890ea1936b8890f058e7ba35e8d71", size = 17852844 }, + { url = "https://files.pythonhosted.org/packages/46/72/8a5dbce4020dfc595592333ef2fbb0a187d084ca243b67766d29d03e0096/numpy-2.2.1-cp313-cp313t-win32.whl", hash = "sha256:93cf4e045bae74c90ca833cba583c14b62cb4ba2cba0abd2b141ab52548247e2", size = 6326007 }, + { url = "https://files.pythonhosted.org/packages/7b/9c/4fce9cf39dde2562584e4cfd351a0140240f82c0e3569ce25a250f47037d/numpy-2.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:bff7d8ec20f5f42607599f9994770fa65d76edca264a87b5e4ea5629bce12268", size = 12693107 }, + { url = "https://files.pythonhosted.org/packages/f1/65/d36a76b811ffe0a4515e290cb05cb0e22171b1b0f0db6bee9141cf023545/numpy-2.2.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7ba9cc93a91d86365a5d270dee221fdc04fb68d7478e6bf6af650de78a8339e3", size = 21044672 }, + { url = "https://files.pythonhosted.org/packages/aa/3f/b644199f165063154df486d95198d814578f13dd4d8c1651e075bf1cb8af/numpy-2.2.1-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:3d03883435a19794e41f147612a77a8f56d4e52822337844fff3d4040a142964", size = 6789873 }, + { url = "https://files.pythonhosted.org/packages/d7/df/2adb0bb98a3cbe8a6c3c6d1019aede1f1d8b83927ced228a46cc56c7a206/numpy-2.2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4511d9e6071452b944207c8ce46ad2f897307910b402ea5fa975da32e0102800", size = 16194933 }, + { url = "https://files.pythonhosted.org/packages/13/3e/1959d5219a9e6d200638d924cedda6a606392f7186a4ed56478252e70d55/numpy-2.2.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5c5cc0cbabe9452038ed984d05ac87910f89370b9242371bd9079cb4af61811e", size = 12820057 }, +] + +[[package]] +name = "overrides" +version = "7.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/86/b585f53236dec60aba864e050778b25045f857e17f6e5ea0ae95fe80edd2/overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a", size = 22812 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/ab/fc8290c6a4c722e5514d80f62b2dc4c4df1a68a41d1364e625c35990fcf3/overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49", size = 17832 }, +] + +[[package]] +name = "packaging" +version = "24.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, +] + +[[package]] +name = "pandas" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 }, + { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897 }, + { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908 }, + { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 }, + { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292 }, + { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 }, + { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 }, + { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 }, + { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274 }, + { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836 }, + { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 }, + { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420 }, + { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 }, + { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 }, + { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 }, + { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 }, + { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 }, + { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 }, + { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 }, + { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 }, + { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 }, + { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 }, + { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 }, + { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 }, + { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 }, + { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 }, + { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 }, + { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 }, + { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 }, + { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 }, + { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 }, + { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 }, + { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 }, + { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663 }, +] + +[[package]] +name = "parso" +version = "0.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650 }, +] + +[[package]] +name = "pdoc" +version = "15.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jinja2" }, + { name = "markupsafe" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bf/16/1b542af6f18a27de059f722c487a596681127897b6d31f78e46d6e5bf2fe/pdoc-15.0.1.tar.gz", hash = "sha256:3b08382c9d312243ee6c2a1813d0ff517a6ab84d596fa2c6c6b5255b17c3d666", size = 154174 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/4d/60d856a1b12fbf6ac1539efccfa138e57c6b88675c9867d84bbb46455cc1/pdoc-15.0.1-py3-none-any.whl", hash = "sha256:fd437ab8eb55f9b942226af7865a3801e2fb731665199b74fd9a44737dbe20f9", size = 144186 }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 }, +] + +[[package]] +name = "pillow" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/af/c097e544e7bd278333db77933e535098c259609c4eb3b85381109602fb5b/pillow-11.1.0.tar.gz", hash = "sha256:368da70808b36d73b4b390a8ffac11069f8a5c85f29eff1f1b01bcf3ef5b2a20", size = 46742715 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/1c/2dcea34ac3d7bc96a1fd1bd0a6e06a57c67167fec2cff8d95d88229a8817/pillow-11.1.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:e1abe69aca89514737465752b4bcaf8016de61b3be1397a8fc260ba33321b3a8", size = 3229983 }, + { url = "https://files.pythonhosted.org/packages/14/ca/6bec3df25e4c88432681de94a3531cc738bd85dea6c7aa6ab6f81ad8bd11/pillow-11.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c640e5a06869c75994624551f45e5506e4256562ead981cce820d5ab39ae2192", size = 3101831 }, + { url = "https://files.pythonhosted.org/packages/d4/2c/668e18e5521e46eb9667b09e501d8e07049eb5bfe39d56be0724a43117e6/pillow-11.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a07dba04c5e22824816b2615ad7a7484432d7f540e6fa86af60d2de57b0fcee2", size = 4314074 }, + { url = "https://files.pythonhosted.org/packages/02/80/79f99b714f0fc25f6a8499ecfd1f810df12aec170ea1e32a4f75746051ce/pillow-11.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e267b0ed063341f3e60acd25c05200df4193e15a4a5807075cd71225a2386e26", size = 4394933 }, + { url = "https://files.pythonhosted.org/packages/81/aa/8d4ad25dc11fd10a2001d5b8a80fdc0e564ac33b293bdfe04ed387e0fd95/pillow-11.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:bd165131fd51697e22421d0e467997ad31621b74bfc0b75956608cb2906dda07", size = 4353349 }, + { url = "https://files.pythonhosted.org/packages/84/7a/cd0c3eaf4a28cb2a74bdd19129f7726277a7f30c4f8424cd27a62987d864/pillow-11.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:abc56501c3fd148d60659aae0af6ddc149660469082859fa7b066a298bde9482", size = 4476532 }, + { url = "https://files.pythonhosted.org/packages/8f/8b/a907fdd3ae8f01c7670dfb1499c53c28e217c338b47a813af8d815e7ce97/pillow-11.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:54ce1c9a16a9561b6d6d8cb30089ab1e5eb66918cb47d457bd996ef34182922e", size = 4279789 }, + { url = "https://files.pythonhosted.org/packages/6f/9a/9f139d9e8cccd661c3efbf6898967a9a337eb2e9be2b454ba0a09533100d/pillow-11.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:73ddde795ee9b06257dac5ad42fcb07f3b9b813f8c1f7f870f402f4dc54b5269", size = 4413131 }, + { url = "https://files.pythonhosted.org/packages/a8/68/0d8d461f42a3f37432203c8e6df94da10ac8081b6d35af1c203bf3111088/pillow-11.1.0-cp310-cp310-win32.whl", hash = "sha256:3a5fe20a7b66e8135d7fd617b13272626a28278d0e578c98720d9ba4b2439d49", size = 2291213 }, + { url = "https://files.pythonhosted.org/packages/14/81/d0dff759a74ba87715509af9f6cb21fa21d93b02b3316ed43bda83664db9/pillow-11.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:b6123aa4a59d75f06e9dd3dac5bf8bc9aa383121bb3dd9a7a612e05eabc9961a", size = 2625725 }, + { url = "https://files.pythonhosted.org/packages/ce/1f/8d50c096a1d58ef0584ddc37e6f602828515219e9d2428e14ce50f5ecad1/pillow-11.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:a76da0a31da6fcae4210aa94fd779c65c75786bc9af06289cd1c184451ef7a65", size = 2375213 }, + { url = "https://files.pythonhosted.org/packages/dd/d6/2000bfd8d5414fb70cbbe52c8332f2283ff30ed66a9cde42716c8ecbe22c/pillow-11.1.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e06695e0326d05b06833b40b7ef477e475d0b1ba3a6d27da1bb48c23209bf457", size = 3229968 }, + { url = "https://files.pythonhosted.org/packages/d9/45/3fe487010dd9ce0a06adf9b8ff4f273cc0a44536e234b0fad3532a42c15b/pillow-11.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96f82000e12f23e4f29346e42702b6ed9a2f2fea34a740dd5ffffcc8c539eb35", size = 3101806 }, + { url = "https://files.pythonhosted.org/packages/e3/72/776b3629c47d9d5f1c160113158a7a7ad177688d3a1159cd3b62ded5a33a/pillow-11.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3cd561ded2cf2bbae44d4605837221b987c216cff94f49dfeed63488bb228d2", size = 4322283 }, + { url = "https://files.pythonhosted.org/packages/e4/c2/e25199e7e4e71d64eeb869f5b72c7ddec70e0a87926398785ab944d92375/pillow-11.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f189805c8be5ca5add39e6f899e6ce2ed824e65fb45f3c28cb2841911da19070", size = 4402945 }, + { url = "https://files.pythonhosted.org/packages/c1/ed/51d6136c9d5911f78632b1b86c45241c712c5a80ed7fa7f9120a5dff1eba/pillow-11.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:dd0052e9db3474df30433f83a71b9b23bd9e4ef1de13d92df21a52c0303b8ab6", size = 4361228 }, + { url = "https://files.pythonhosted.org/packages/48/a4/fbfe9d5581d7b111b28f1d8c2762dee92e9821bb209af9fa83c940e507a0/pillow-11.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:837060a8599b8f5d402e97197d4924f05a2e0d68756998345c829c33186217b1", size = 4484021 }, + { url = "https://files.pythonhosted.org/packages/39/db/0b3c1a5018117f3c1d4df671fb8e47d08937f27519e8614bbe86153b65a5/pillow-11.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:aa8dd43daa836b9a8128dbe7d923423e5ad86f50a7a14dc688194b7be5c0dea2", size = 4287449 }, + { url = "https://files.pythonhosted.org/packages/d9/58/bc128da7fea8c89fc85e09f773c4901e95b5936000e6f303222490c052f3/pillow-11.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0a2f91f8a8b367e7a57c6e91cd25af510168091fb89ec5146003e424e1558a96", size = 4419972 }, + { url = "https://files.pythonhosted.org/packages/5f/bb/58f34379bde9fe197f51841c5bbe8830c28bbb6d3801f16a83b8f2ad37df/pillow-11.1.0-cp311-cp311-win32.whl", hash = "sha256:c12fc111ef090845de2bb15009372175d76ac99969bdf31e2ce9b42e4b8cd88f", size = 2291201 }, + { url = "https://files.pythonhosted.org/packages/3a/c6/fce9255272bcf0c39e15abd2f8fd8429a954cf344469eaceb9d0d1366913/pillow-11.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fbd43429d0d7ed6533b25fc993861b8fd512c42d04514a0dd6337fb3ccf22761", size = 2625686 }, + { url = "https://files.pythonhosted.org/packages/c8/52/8ba066d569d932365509054859f74f2a9abee273edcef5cd75e4bc3e831e/pillow-11.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:f7955ecf5609dee9442cbface754f2c6e541d9e6eda87fad7f7a989b0bdb9d71", size = 2375194 }, + { url = "https://files.pythonhosted.org/packages/95/20/9ce6ed62c91c073fcaa23d216e68289e19d95fb8188b9fb7a63d36771db8/pillow-11.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2062ffb1d36544d42fcaa277b069c88b01bb7298f4efa06731a7fd6cc290b81a", size = 3226818 }, + { url = "https://files.pythonhosted.org/packages/b9/d8/f6004d98579a2596c098d1e30d10b248798cceff82d2b77aa914875bfea1/pillow-11.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a85b653980faad27e88b141348707ceeef8a1186f75ecc600c395dcac19f385b", size = 3101662 }, + { url = "https://files.pythonhosted.org/packages/08/d9/892e705f90051c7a2574d9f24579c9e100c828700d78a63239676f960b74/pillow-11.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9409c080586d1f683df3f184f20e36fb647f2e0bc3988094d4fd8c9f4eb1b3b3", size = 4329317 }, + { url = "https://files.pythonhosted.org/packages/8c/aa/7f29711f26680eab0bcd3ecdd6d23ed6bce180d82e3f6380fb7ae35fcf3b/pillow-11.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fdadc077553621911f27ce206ffcbec7d3f8d7b50e0da39f10997e8e2bb7f6a", size = 4412999 }, + { url = "https://files.pythonhosted.org/packages/c8/c4/8f0fe3b9e0f7196f6d0bbb151f9fba323d72a41da068610c4c960b16632a/pillow-11.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:93a18841d09bcdd774dcdc308e4537e1f867b3dec059c131fde0327899734aa1", size = 4368819 }, + { url = "https://files.pythonhosted.org/packages/38/0d/84200ed6a871ce386ddc82904bfadc0c6b28b0c0ec78176871a4679e40b3/pillow-11.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:9aa9aeddeed452b2f616ff5507459e7bab436916ccb10961c4a382cd3e03f47f", size = 4496081 }, + { url = "https://files.pythonhosted.org/packages/84/9c/9bcd66f714d7e25b64118e3952d52841a4babc6d97b6d28e2261c52045d4/pillow-11.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3cdcdb0b896e981678eee140d882b70092dac83ac1cdf6b3a60e2216a73f2b91", size = 4296513 }, + { url = "https://files.pythonhosted.org/packages/db/61/ada2a226e22da011b45f7104c95ebda1b63dcbb0c378ad0f7c2a710f8fd2/pillow-11.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36ba10b9cb413e7c7dfa3e189aba252deee0602c86c309799da5a74009ac7a1c", size = 4431298 }, + { url = "https://files.pythonhosted.org/packages/e7/c4/fc6e86750523f367923522014b821c11ebc5ad402e659d8c9d09b3c9d70c/pillow-11.1.0-cp312-cp312-win32.whl", hash = "sha256:cfd5cd998c2e36a862d0e27b2df63237e67273f2fc78f47445b14e73a810e7e6", size = 2291630 }, + { url = "https://files.pythonhosted.org/packages/08/5c/2104299949b9d504baf3f4d35f73dbd14ef31bbd1ddc2c1b66a5b7dfda44/pillow-11.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:a697cd8ba0383bba3d2d3ada02b34ed268cb548b369943cd349007730c92bddf", size = 2626369 }, + { url = "https://files.pythonhosted.org/packages/37/f3/9b18362206b244167c958984b57c7f70a0289bfb59a530dd8af5f699b910/pillow-11.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:4dd43a78897793f60766563969442020e90eb7847463eca901e41ba186a7d4a5", size = 2375240 }, + { url = "https://files.pythonhosted.org/packages/b3/31/9ca79cafdce364fd5c980cd3416c20ce1bebd235b470d262f9d24d810184/pillow-11.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ae98e14432d458fc3de11a77ccb3ae65ddce70f730e7c76140653048c71bfcbc", size = 3226640 }, + { url = "https://files.pythonhosted.org/packages/ac/0f/ff07ad45a1f172a497aa393b13a9d81a32e1477ef0e869d030e3c1532521/pillow-11.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cc1331b6d5a6e144aeb5e626f4375f5b7ae9934ba620c0ac6b3e43d5e683a0f0", size = 3101437 }, + { url = "https://files.pythonhosted.org/packages/08/2f/9906fca87a68d29ec4530be1f893149e0cb64a86d1f9f70a7cfcdfe8ae44/pillow-11.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:758e9d4ef15d3560214cddbc97b8ef3ef86ce04d62ddac17ad39ba87e89bd3b1", size = 4326605 }, + { url = "https://files.pythonhosted.org/packages/b0/0f/f3547ee15b145bc5c8b336401b2d4c9d9da67da9dcb572d7c0d4103d2c69/pillow-11.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b523466b1a31d0dcef7c5be1f20b942919b62fd6e9a9be199d035509cbefc0ec", size = 4411173 }, + { url = "https://files.pythonhosted.org/packages/b1/df/bf8176aa5db515c5de584c5e00df9bab0713548fd780c82a86cba2c2fedb/pillow-11.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:9044b5e4f7083f209c4e35aa5dd54b1dd5b112b108648f5c902ad586d4f945c5", size = 4369145 }, + { url = "https://files.pythonhosted.org/packages/de/7c/7433122d1cfadc740f577cb55526fdc39129a648ac65ce64db2eb7209277/pillow-11.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:3764d53e09cdedd91bee65c2527815d315c6b90d7b8b79759cc48d7bf5d4f114", size = 4496340 }, + { url = "https://files.pythonhosted.org/packages/25/46/dd94b93ca6bd555588835f2504bd90c00d5438fe131cf01cfa0c5131a19d/pillow-11.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31eba6bbdd27dde97b0174ddf0297d7a9c3a507a8a1480e1e60ef914fe23d352", size = 4296906 }, + { url = "https://files.pythonhosted.org/packages/a8/28/2f9d32014dfc7753e586db9add35b8a41b7a3b46540e965cb6d6bc607bd2/pillow-11.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b5d658fbd9f0d6eea113aea286b21d3cd4d3fd978157cbf2447a6035916506d3", size = 4431759 }, + { url = "https://files.pythonhosted.org/packages/33/48/19c2cbe7403870fbe8b7737d19eb013f46299cdfe4501573367f6396c775/pillow-11.1.0-cp313-cp313-win32.whl", hash = "sha256:f86d3a7a9af5d826744fabf4afd15b9dfef44fe69a98541f666f66fbb8d3fef9", size = 2291657 }, + { url = "https://files.pythonhosted.org/packages/3b/ad/285c556747d34c399f332ba7c1a595ba245796ef3e22eae190f5364bb62b/pillow-11.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:593c5fd6be85da83656b93ffcccc2312d2d149d251e98588b14fbc288fd8909c", size = 2626304 }, + { url = "https://files.pythonhosted.org/packages/e5/7b/ef35a71163bf36db06e9c8729608f78dedf032fc8313d19bd4be5c2588f3/pillow-11.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:11633d58b6ee5733bde153a8dafd25e505ea3d32e261accd388827ee987baf65", size = 2375117 }, + { url = "https://files.pythonhosted.org/packages/79/30/77f54228401e84d6791354888549b45824ab0ffde659bafa67956303a09f/pillow-11.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:70ca5ef3b3b1c4a0812b5c63c57c23b63e53bc38e758b37a951e5bc466449861", size = 3230060 }, + { url = "https://files.pythonhosted.org/packages/ce/b1/56723b74b07dd64c1010fee011951ea9c35a43d8020acd03111f14298225/pillow-11.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8000376f139d4d38d6851eb149b321a52bb8893a88dae8ee7d95840431977081", size = 3106192 }, + { url = "https://files.pythonhosted.org/packages/e1/cd/7bf7180e08f80a4dcc6b4c3a0aa9e0b0ae57168562726a05dc8aa8fa66b0/pillow-11.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ee85f0696a17dd28fbcfceb59f9510aa71934b483d1f5601d1030c3c8304f3c", size = 4446805 }, + { url = "https://files.pythonhosted.org/packages/97/42/87c856ea30c8ed97e8efbe672b58c8304dee0573f8c7cab62ae9e31db6ae/pillow-11.1.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:dd0e081319328928531df7a0e63621caf67652c8464303fd102141b785ef9547", size = 4530623 }, + { url = "https://files.pythonhosted.org/packages/ff/41/026879e90c84a88e33fb00cc6bd915ac2743c67e87a18f80270dfe3c2041/pillow-11.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e63e4e5081de46517099dc30abe418122f54531a6ae2ebc8680bcd7096860eab", size = 4465191 }, + { url = "https://files.pythonhosted.org/packages/e5/fb/a7960e838bc5df57a2ce23183bfd2290d97c33028b96bde332a9057834d3/pillow-11.1.0-cp313-cp313t-win32.whl", hash = "sha256:dda60aa465b861324e65a78c9f5cf0f4bc713e4309f83bc387be158b077963d9", size = 2295494 }, + { url = "https://files.pythonhosted.org/packages/d7/6c/6ec83ee2f6f0fda8d4cf89045c6be4b0373ebfc363ba8538f8c999f63fcd/pillow-11.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ad5db5781c774ab9a9b2c4302bbf0c1014960a0a7be63278d13ae6fdf88126fe", size = 2631595 }, + { url = "https://files.pythonhosted.org/packages/cf/6c/41c21c6c8af92b9fea313aa47c75de49e2f9a467964ee33eb0135d47eb64/pillow-11.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:67cd427c68926108778a9005f2a04adbd5e67c442ed21d95389fe1d595458756", size = 2377651 }, + { url = "https://files.pythonhosted.org/packages/fa/c5/389961578fb677b8b3244fcd934f720ed25a148b9a5cc81c91bdf59d8588/pillow-11.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8c730dc3a83e5ac137fbc92dfcfe1511ce3b2b5d7578315b63dbbb76f7f51d90", size = 3198345 }, + { url = "https://files.pythonhosted.org/packages/c4/fa/803c0e50ffee74d4b965229e816af55276eac1d5806712de86f9371858fd/pillow-11.1.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:7d33d2fae0e8b170b6a6c57400e077412240f6f5bb2a342cf1ee512a787942bb", size = 3072938 }, + { url = "https://files.pythonhosted.org/packages/dc/67/2a3a5f8012b5d8c63fe53958ba906c1b1d0482ebed5618057ef4d22f8076/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8d65b38173085f24bc07f8b6c505cbb7418009fa1a1fcb111b1f4961814a442", size = 3400049 }, + { url = "https://files.pythonhosted.org/packages/e5/a0/514f0d317446c98c478d1872497eb92e7cde67003fed74f696441e647446/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:015c6e863faa4779251436db398ae75051469f7c903b043a48f078e437656f83", size = 3422431 }, + { url = "https://files.pythonhosted.org/packages/cd/00/20f40a935514037b7d3f87adfc87d2c538430ea625b63b3af8c3f5578e72/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d44ff19eea13ae4acdaaab0179fa68c0c6f2f45d66a4d8ec1eda7d6cecbcc15f", size = 3446208 }, + { url = "https://files.pythonhosted.org/packages/28/3c/7de681727963043e093c72e6c3348411b0185eab3263100d4490234ba2f6/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d3d8da4a631471dfaf94c10c85f5277b1f8e42ac42bade1ac67da4b4a7359b73", size = 3509746 }, + { url = "https://files.pythonhosted.org/packages/41/67/936f9814bdd74b2dfd4822f1f7725ab5d8ff4103919a1664eb4874c58b2f/pillow-11.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:4637b88343166249fe8aa94e7c4a62a180c4b3898283bb5d3d2fd5fe10d8e4e0", size = 2626353 }, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 }, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, +] + +[[package]] +name = "prometheus-client" +version = "0.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/62/14/7d0f567991f3a9af8d1cd4f619040c93b68f09a02b6d0b6ab1b2d1ded5fe/prometheus_client-0.21.1.tar.gz", hash = "sha256:252505a722ac04b0456be05c05f75f45d760c2911ffc45f2a06bcaed9f3ae3fb", size = 78551 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/c2/ab7d37426c179ceb9aeb109a85cda8948bb269b7561a0be870cc656eefe4/prometheus_client-0.21.1-py3-none-any.whl", hash = "sha256:594b45c410d6f4f8888940fe80b5cc2521b305a1fafe1c58609ef715a001f301", size = 54682 }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.48" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2d/4f/feb5e137aff82f7c7f3248267b97451da3644f6cdc218edfe549fb354127/prompt_toolkit-3.0.48.tar.gz", hash = "sha256:d6623ab0477a80df74e646bdbc93621143f5caf104206aa29294d53de1a03d90", size = 424684 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/6a/fd08d94654f7e67c52ca30523a178b3f8ccc4237fce4be90d39c938a831a/prompt_toolkit-3.0.48-py3-none-any.whl", hash = "sha256:f49a827f90062e411f1ce1f854f2aedb3c23353244f8108b89283587397ac10e", size = 386595 }, +] + +[[package]] +name = "psutil" +version = "6.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/5a/07871137bb752428aa4b659f910b399ba6f291156bdea939be3e96cae7cb/psutil-6.1.1.tar.gz", hash = "sha256:cf8496728c18f2d0b45198f06895be52f36611711746b7f30c464b422b50e2f5", size = 508502 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/99/ca79d302be46f7bdd8321089762dd4476ee725fce16fc2b2e1dbba8cac17/psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:fc0ed7fe2231a444fc219b9c42d0376e0a9a1a72f16c5cfa0f68d19f1a0663e8", size = 247511 }, + { url = "https://files.pythonhosted.org/packages/0b/6b/73dbde0dd38f3782905d4587049b9be64d76671042fdcaf60e2430c6796d/psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0bdd4eab935276290ad3cb718e9809412895ca6b5b334f5a9111ee6d9aff9377", size = 248985 }, + { url = "https://files.pythonhosted.org/packages/17/38/c319d31a1d3f88c5b79c68b3116c129e5133f1822157dd6da34043e32ed6/psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b6e06c20c05fe95a3d7302d74e7097756d4ba1247975ad6905441ae1b5b66003", size = 284488 }, + { url = "https://files.pythonhosted.org/packages/9c/39/0f88a830a1c8a3aba27fededc642da37613c57cbff143412e3536f89784f/psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97f7cb9921fbec4904f522d972f0c0e1f4fabbdd4e0287813b21215074a0f160", size = 287477 }, + { url = "https://files.pythonhosted.org/packages/47/da/99f4345d4ddf2845cb5b5bd0d93d554e84542d116934fde07a0c50bd4e9f/psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33431e84fee02bc84ea36d9e2c4a6d395d479c9dd9bba2376c1f6ee8f3a4e0b3", size = 289017 }, + { url = "https://files.pythonhosted.org/packages/38/53/bd755c2896f4461fd4f36fa6a6dcb66a88a9e4b9fd4e5b66a77cf9d4a584/psutil-6.1.1-cp37-abi3-win32.whl", hash = "sha256:eaa912e0b11848c4d9279a93d7e2783df352b082f40111e078388701fd479e53", size = 250602 }, + { url = "https://files.pythonhosted.org/packages/7b/d7/7831438e6c3ebbfa6e01a927127a6cb42ad3ab844247f3c5b96bea25d73d/psutil-6.1.1-cp37-abi3-win_amd64.whl", hash = "sha256:f35cfccb065fff93529d2afb4a2e89e363fe63ca1e4a5da22b603a85833c2649", size = 254444 }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 }, +] + +[[package]] +name = "pycparser" +version = "2.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 }, +] + +[[package]] +name = "pygments" +version = "2.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 }, +] + +[[package]] +name = "pyparsing" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/1a/3544f4f299a47911c2ab3710f534e52fea62a633c96806995da5d25be4b2/pyparsing-3.2.1.tar.gz", hash = "sha256:61980854fd66de3a90028d679a954d5f2623e83144b5afe5ee86f43d762e5f0a", size = 1067694 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/a7/c8a2d361bf89c0d9577c934ebb7421b25dc84bf3a8e3ac0a40aed9acc547/pyparsing-3.2.1-py3-none-any.whl", hash = "sha256:506ff4f4386c4cec0590ec19e6302d3aedb992fdc02c761e90416f158dacf8e1", size = 107716 }, +] + +[[package]] +name = "pytest" +version = "8.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, +] + +[[package]] +name = "python-json-logger" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/c4/358cd13daa1d912ef795010897a483ab2f0b41c9ea1b35235a8b2f7d15a7/python_json_logger-3.2.1.tar.gz", hash = "sha256:8eb0554ea17cb75b05d2848bc14fb02fbdbd9d6972120781b974380bfa162008", size = 16287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/72/2f30cf26664fcfa0bd8ec5ee62ec90c03bd485e4a294d92aabc76c5203a5/python_json_logger-3.2.1-py3-none-any.whl", hash = "sha256:cdc17047eb5374bd311e748b42f99d71223f3b0e186f4206cc5d52aefe85b090", size = 14924 }, +] + +[[package]] +name = "pytz" +version = "2024.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 }, +] + +[[package]] +name = "pywin32" +version = "308" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/a6/3e9f2c474895c1bb61b11fa9640be00067b5c5b363c501ee9c3fa53aec01/pywin32-308-cp310-cp310-win32.whl", hash = "sha256:796ff4426437896550d2981b9c2ac0ffd75238ad9ea2d3bfa67a1abd546d262e", size = 5927028 }, + { url = "https://files.pythonhosted.org/packages/d9/b4/84e2463422f869b4b718f79eb7530a4c1693e96b8a4e5e968de38be4d2ba/pywin32-308-cp310-cp310-win_amd64.whl", hash = "sha256:4fc888c59b3c0bef905ce7eb7e2106a07712015ea1c8234b703a088d46110e8e", size = 6558484 }, + { url = "https://files.pythonhosted.org/packages/9f/8f/fb84ab789713f7c6feacaa08dad3ec8105b88ade8d1c4f0f0dfcaaa017d6/pywin32-308-cp310-cp310-win_arm64.whl", hash = "sha256:a5ab5381813b40f264fa3495b98af850098f814a25a63589a8e9eb12560f450c", size = 7971454 }, + { url = "https://files.pythonhosted.org/packages/eb/e2/02652007469263fe1466e98439831d65d4ca80ea1a2df29abecedf7e47b7/pywin32-308-cp311-cp311-win32.whl", hash = "sha256:5d8c8015b24a7d6855b1550d8e660d8daa09983c80e5daf89a273e5c6fb5095a", size = 5928156 }, + { url = "https://files.pythonhosted.org/packages/48/ef/f4fb45e2196bc7ffe09cad0542d9aff66b0e33f6c0954b43e49c33cad7bd/pywin32-308-cp311-cp311-win_amd64.whl", hash = "sha256:575621b90f0dc2695fec346b2d6302faebd4f0f45c05ea29404cefe35d89442b", size = 6559559 }, + { url = "https://files.pythonhosted.org/packages/79/ef/68bb6aa865c5c9b11a35771329e95917b5559845bd75b65549407f9fc6b4/pywin32-308-cp311-cp311-win_arm64.whl", hash = "sha256:100a5442b7332070983c4cd03f2e906a5648a5104b8a7f50175f7906efd16bb6", size = 7972495 }, + { url = "https://files.pythonhosted.org/packages/00/7c/d00d6bdd96de4344e06c4afbf218bc86b54436a94c01c71a8701f613aa56/pywin32-308-cp312-cp312-win32.whl", hash = "sha256:587f3e19696f4bf96fde9d8a57cec74a57021ad5f204c9e627e15c33ff568897", size = 5939729 }, + { url = "https://files.pythonhosted.org/packages/21/27/0c8811fbc3ca188f93b5354e7c286eb91f80a53afa4e11007ef661afa746/pywin32-308-cp312-cp312-win_amd64.whl", hash = "sha256:00b3e11ef09ede56c6a43c71f2d31857cf7c54b0ab6e78ac659497abd2834f47", size = 6543015 }, + { url = "https://files.pythonhosted.org/packages/9d/0f/d40f8373608caed2255781a3ad9a51d03a594a1248cd632d6a298daca693/pywin32-308-cp312-cp312-win_arm64.whl", hash = "sha256:9b4de86c8d909aed15b7011182c8cab38c8850de36e6afb1f0db22b8959e3091", size = 7976033 }, + { url = "https://files.pythonhosted.org/packages/a9/a4/aa562d8935e3df5e49c161b427a3a2efad2ed4e9cf81c3de636f1fdddfd0/pywin32-308-cp313-cp313-win32.whl", hash = "sha256:1c44539a37a5b7b21d02ab34e6a4d314e0788f1690d65b48e9b0b89f31abbbed", size = 5938579 }, + { url = "https://files.pythonhosted.org/packages/c7/50/b0efb8bb66210da67a53ab95fd7a98826a97ee21f1d22949863e6d588b22/pywin32-308-cp313-cp313-win_amd64.whl", hash = "sha256:fd380990e792eaf6827fcb7e187b2b4b1cede0585e3d0c9e84201ec27b9905e4", size = 6542056 }, + { url = "https://files.pythonhosted.org/packages/26/df/2b63e3e4f2df0224f8aaf6d131f54fe4e8c96400eb9df563e2aae2e1a1f9/pywin32-308-cp313-cp313-win_arm64.whl", hash = "sha256:ef313c46d4c18dfb82a2431e3051ac8f112ccee1a34f29c263c583c568db63cd", size = 7974986 }, +] + +[[package]] +name = "pywinpty" +version = "2.0.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/82/90f8750423cba4b9b6c842df227609fb60704482d7abf6dd47e2babc055a/pywinpty-2.0.14.tar.gz", hash = "sha256:18bd9529e4a5daf2d9719aa17788ba6013e594ae94c5a0c27e83df3278b0660e", size = 27769 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/09/56376af256eab8cc5f8982a3b138d387136eca27fa1a8a68660e8ed59e4b/pywinpty-2.0.14-cp310-none-win_amd64.whl", hash = "sha256:0b149c2918c7974f575ba79f5a4aad58bd859a52fa9eb1296cc22aa412aa411f", size = 1397115 }, + { url = "https://files.pythonhosted.org/packages/be/e2/af1a99c0432e4e58c9ac8e334ee191790ec9793d33559189b9d2069bdc1d/pywinpty-2.0.14-cp311-none-win_amd64.whl", hash = "sha256:cf2a43ac7065b3e0dc8510f8c1f13a75fb8fde805efa3b8cff7599a1ef497bc7", size = 1397223 }, + { url = "https://files.pythonhosted.org/packages/ad/79/759ae767a3b78d340446efd54dd1fe4f7dafa4fc7be96ed757e44bcdba54/pywinpty-2.0.14-cp312-none-win_amd64.whl", hash = "sha256:55dad362ef3e9408ade68fd173e4f9032b3ce08f68cfe7eacb2c263ea1179737", size = 1397207 }, + { url = "https://files.pythonhosted.org/packages/7d/34/b77b3c209bf2eaa6455390c8d5449241637f5957f41636a2204065d52bfa/pywinpty-2.0.14-cp313-none-win_amd64.whl", hash = "sha256:074fb988a56ec79ca90ed03a896d40707131897cefb8f76f926e3834227f2819", size = 1396698 }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 }, + { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 }, + { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 }, + { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 }, + { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 }, + { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 }, + { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 }, + { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 }, + { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 }, + { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 }, + { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 }, + { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 }, + { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 }, + { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 }, + { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 }, + { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 }, + { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 }, + { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 }, + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, +] + +[[package]] +name = "pyzmq" +version = "26.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fd/05/bed626b9f7bb2322cdbbf7b4bd8f54b1b617b0d2ab2d3547d6e39428a48e/pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f", size = 271975 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/a8/9837c39aba390eb7d01924ace49d761c8dbe7bc2d6082346d00c8332e431/pyzmq-26.2.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:ddf33d97d2f52d89f6e6e7ae66ee35a4d9ca6f36eda89c24591b0c40205a3629", size = 1340058 }, + { url = "https://files.pythonhosted.org/packages/a2/1f/a006f2e8e4f7d41d464272012695da17fb95f33b54342612a6890da96ff6/pyzmq-26.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dacd995031a01d16eec825bf30802fceb2c3791ef24bcce48fa98ce40918c27b", size = 1008818 }, + { url = "https://files.pythonhosted.org/packages/b6/09/b51b6683fde5ca04593a57bbe81788b6b43114d8f8ee4e80afc991e14760/pyzmq-26.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89289a5ee32ef6c439086184529ae060c741334b8970a6855ec0b6ad3ff28764", size = 673199 }, + { url = "https://files.pythonhosted.org/packages/c9/78/486f3e2e824f3a645238332bf5a4c4b4477c3063033a27c1e4052358dee2/pyzmq-26.2.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5506f06d7dc6ecf1efacb4a013b1f05071bb24b76350832c96449f4a2d95091c", size = 911762 }, + { url = "https://files.pythonhosted.org/packages/5e/3b/2eb1667c9b866f53e76ee8b0c301b0469745a23bd5a87b7ee3d5dd9eb6e5/pyzmq-26.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ea039387c10202ce304af74def5021e9adc6297067f3441d348d2b633e8166a", size = 868773 }, + { url = "https://files.pythonhosted.org/packages/16/29/ca99b4598a9dc7e468b5417eda91f372b595be1e3eec9b7cbe8e5d3584e8/pyzmq-26.2.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a2224fa4a4c2ee872886ed00a571f5e967c85e078e8e8c2530a2fb01b3309b88", size = 868834 }, + { url = "https://files.pythonhosted.org/packages/ad/e5/9efaeb1d2f4f8c50da04144f639b042bc52869d3a206d6bf672ab3522163/pyzmq-26.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:28ad5233e9c3b52d76196c696e362508959741e1a005fb8fa03b51aea156088f", size = 1202861 }, + { url = "https://files.pythonhosted.org/packages/c3/62/c721b5608a8ac0a69bb83cbb7d07a56f3ff00b3991a138e44198a16f94c7/pyzmq-26.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:1c17211bc037c7d88e85ed8b7d8f7e52db6dc8eca5590d162717c654550f7282", size = 1515304 }, + { url = "https://files.pythonhosted.org/packages/87/84/e8bd321aa99b72f48d4606fc5a0a920154125bd0a4608c67eab742dab087/pyzmq-26.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b8f86dd868d41bea9a5f873ee13bf5551c94cf6bc51baebc6f85075971fe6eea", size = 1414712 }, + { url = "https://files.pythonhosted.org/packages/cd/cd/420e3fd1ac6977b008b72e7ad2dae6350cc84d4c5027fc390b024e61738f/pyzmq-26.2.0-cp310-cp310-win32.whl", hash = "sha256:46a446c212e58456b23af260f3d9fb785054f3e3653dbf7279d8f2b5546b21c2", size = 578113 }, + { url = "https://files.pythonhosted.org/packages/5c/57/73930d56ed45ae0cb4946f383f985c855c9b3d4063f26416998f07523c0e/pyzmq-26.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:49d34ab71db5a9c292a7644ce74190b1dd5a3475612eefb1f8be1d6961441971", size = 641631 }, + { url = "https://files.pythonhosted.org/packages/61/d2/ae6ac5c397f1ccad59031c64beaafce7a0d6182e0452cc48f1c9c87d2dd0/pyzmq-26.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:bfa832bfa540e5b5c27dcf5de5d82ebc431b82c453a43d141afb1e5d2de025fa", size = 543528 }, + { url = "https://files.pythonhosted.org/packages/12/20/de7442172f77f7c96299a0ac70e7d4fb78cd51eca67aa2cf552b66c14196/pyzmq-26.2.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:8f7e66c7113c684c2b3f1c83cdd3376103ee0ce4c49ff80a648643e57fb22218", size = 1340639 }, + { url = "https://files.pythonhosted.org/packages/98/4d/5000468bd64c7910190ed0a6c76a1ca59a68189ec1f007c451dc181a22f4/pyzmq-26.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3a495b30fc91db2db25120df5847d9833af237546fd59170701acd816ccc01c4", size = 1008710 }, + { url = "https://files.pythonhosted.org/packages/e1/bf/c67fd638c2f9fbbab8090a3ee779370b97c82b84cc12d0c498b285d7b2c0/pyzmq-26.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77eb0968da535cba0470a5165468b2cac7772cfb569977cff92e240f57e31bef", size = 673129 }, + { url = "https://files.pythonhosted.org/packages/86/94/99085a3f492aa538161cbf27246e8886ff850e113e0c294a5b8245f13b52/pyzmq-26.2.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ace4f71f1900a548f48407fc9be59c6ba9d9aaf658c2eea6cf2779e72f9f317", size = 910107 }, + { url = "https://files.pythonhosted.org/packages/31/1d/346809e8a9b999646d03f21096428453465b1bca5cd5c64ecd048d9ecb01/pyzmq-26.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:92a78853d7280bffb93df0a4a6a2498cba10ee793cc8076ef797ef2f74d107cf", size = 867960 }, + { url = "https://files.pythonhosted.org/packages/ab/68/6fb6ae5551846ad5beca295b7bca32bf0a7ce19f135cb30e55fa2314e6b6/pyzmq-26.2.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:689c5d781014956a4a6de61d74ba97b23547e431e9e7d64f27d4922ba96e9d6e", size = 869204 }, + { url = "https://files.pythonhosted.org/packages/0f/f9/18417771dee223ccf0f48e29adf8b4e25ba6d0e8285e33bcbce078070bc3/pyzmq-26.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0aca98bc423eb7d153214b2df397c6421ba6373d3397b26c057af3c904452e37", size = 1203351 }, + { url = "https://files.pythonhosted.org/packages/e0/46/f13e67fe0d4f8a2315782cbad50493de6203ea0d744610faf4d5f5b16e90/pyzmq-26.2.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:1f3496d76b89d9429a656293744ceca4d2ac2a10ae59b84c1da9b5165f429ad3", size = 1514204 }, + { url = "https://files.pythonhosted.org/packages/50/11/ddcf7343b7b7a226e0fc7b68cbf5a5bb56291fac07f5c3023bb4c319ebb4/pyzmq-26.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5c2b3bfd4b9689919db068ac6c9911f3fcb231c39f7dd30e3138be94896d18e6", size = 1414339 }, + { url = "https://files.pythonhosted.org/packages/01/14/1c18d7d5b7be2708f513f37c61bfadfa62161c10624f8733f1c8451b3509/pyzmq-26.2.0-cp311-cp311-win32.whl", hash = "sha256:eac5174677da084abf378739dbf4ad245661635f1600edd1221f150b165343f4", size = 576928 }, + { url = "https://files.pythonhosted.org/packages/3b/1b/0a540edd75a41df14ec416a9a500b9fec66e554aac920d4c58fbd5756776/pyzmq-26.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:5a509df7d0a83a4b178d0f937ef14286659225ef4e8812e05580776c70e155d5", size = 642317 }, + { url = "https://files.pythonhosted.org/packages/98/77/1cbfec0358078a4c5add529d8a70892db1be900980cdb5dd0898b3d6ab9d/pyzmq-26.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:c0e6091b157d48cbe37bd67233318dbb53e1e6327d6fc3bb284afd585d141003", size = 543834 }, + { url = "https://files.pythonhosted.org/packages/28/2f/78a766c8913ad62b28581777ac4ede50c6d9f249d39c2963e279524a1bbe/pyzmq-26.2.0-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:ded0fc7d90fe93ae0b18059930086c51e640cdd3baebdc783a695c77f123dcd9", size = 1343105 }, + { url = "https://files.pythonhosted.org/packages/b7/9c/4b1e2d3d4065be715e007fe063ec7885978fad285f87eae1436e6c3201f4/pyzmq-26.2.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:17bf5a931c7f6618023cdacc7081f3f266aecb68ca692adac015c383a134ca52", size = 1008365 }, + { url = "https://files.pythonhosted.org/packages/4f/ef/5a23ec689ff36d7625b38d121ef15abfc3631a9aecb417baf7a4245e4124/pyzmq-26.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55cf66647e49d4621a7e20c8d13511ef1fe1efbbccf670811864452487007e08", size = 665923 }, + { url = "https://files.pythonhosted.org/packages/ae/61/d436461a47437d63c6302c90724cf0981883ec57ceb6073873f32172d676/pyzmq-26.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4661c88db4a9e0f958c8abc2b97472e23061f0bc737f6f6179d7a27024e1faa5", size = 903400 }, + { url = "https://files.pythonhosted.org/packages/47/42/fc6d35ecefe1739a819afaf6f8e686f7f02a4dd241c78972d316f403474c/pyzmq-26.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea7f69de383cb47522c9c208aec6dd17697db7875a4674c4af3f8cfdac0bdeae", size = 860034 }, + { url = "https://files.pythonhosted.org/packages/07/3b/44ea6266a6761e9eefaa37d98fabefa112328808ac41aa87b4bbb668af30/pyzmq-26.2.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:7f98f6dfa8b8ccaf39163ce872bddacca38f6a67289116c8937a02e30bbe9711", size = 860579 }, + { url = "https://files.pythonhosted.org/packages/38/6f/4df2014ab553a6052b0e551b37da55166991510f9e1002c89cab7ce3b3f2/pyzmq-26.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e3e0210287329272539eea617830a6a28161fbbd8a3271bf4150ae3e58c5d0e6", size = 1196246 }, + { url = "https://files.pythonhosted.org/packages/38/9d/ee240fc0c9fe9817f0c9127a43238a3e28048795483c403cc10720ddef22/pyzmq-26.2.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:6b274e0762c33c7471f1a7471d1a2085b1a35eba5cdc48d2ae319f28b6fc4de3", size = 1507441 }, + { url = "https://files.pythonhosted.org/packages/85/4f/01711edaa58d535eac4a26c294c617c9a01f09857c0ce191fd574d06f359/pyzmq-26.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:29c6a4635eef69d68a00321e12a7d2559fe2dfccfa8efae3ffb8e91cd0b36a8b", size = 1406498 }, + { url = "https://files.pythonhosted.org/packages/07/18/907134c85c7152f679ed744e73e645b365f3ad571f38bdb62e36f347699a/pyzmq-26.2.0-cp312-cp312-win32.whl", hash = "sha256:989d842dc06dc59feea09e58c74ca3e1678c812a4a8a2a419046d711031f69c7", size = 575533 }, + { url = "https://files.pythonhosted.org/packages/ce/2c/a6f4a20202a4d3c582ad93f95ee78d79bbdc26803495aec2912b17dbbb6c/pyzmq-26.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:2a50625acdc7801bc6f74698c5c583a491c61d73c6b7ea4dee3901bb99adb27a", size = 637768 }, + { url = "https://files.pythonhosted.org/packages/5f/0e/eb16ff731632d30554bf5af4dbba3ffcd04518219d82028aea4ae1b02ca5/pyzmq-26.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:4d29ab8592b6ad12ebbf92ac2ed2bedcfd1cec192d8e559e2e099f648570e19b", size = 540675 }, + { url = "https://files.pythonhosted.org/packages/04/a7/0f7e2f6c126fe6e62dbae0bc93b1bd3f1099cf7fea47a5468defebe3f39d/pyzmq-26.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9dd8cd1aeb00775f527ec60022004d030ddc51d783d056e3e23e74e623e33726", size = 1006564 }, + { url = "https://files.pythonhosted.org/packages/31/b6/a187165c852c5d49f826a690857684333a6a4a065af0a6015572d2284f6a/pyzmq-26.2.0-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:28c812d9757fe8acecc910c9ac9dafd2ce968c00f9e619db09e9f8f54c3a68a3", size = 1340447 }, + { url = "https://files.pythonhosted.org/packages/68/ba/f4280c58ff71f321602a6e24fd19879b7e79793fb8ab14027027c0fb58ef/pyzmq-26.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d80b1dd99c1942f74ed608ddb38b181b87476c6a966a88a950c7dee118fdf50", size = 665485 }, + { url = "https://files.pythonhosted.org/packages/77/b5/c987a5c53c7d8704216f29fc3d810b32f156bcea488a940e330e1bcbb88d/pyzmq-26.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8c997098cc65e3208eca09303630e84d42718620e83b733d0fd69543a9cab9cb", size = 903484 }, + { url = "https://files.pythonhosted.org/packages/29/c9/07da157d2db18c72a7eccef8e684cefc155b712a88e3d479d930aa9eceba/pyzmq-26.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ad1bc8d1b7a18497dda9600b12dc193c577beb391beae5cd2349184db40f187", size = 859981 }, + { url = "https://files.pythonhosted.org/packages/43/09/e12501bd0b8394b7d02c41efd35c537a1988da67fc9c745cae9c6c776d31/pyzmq-26.2.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:bea2acdd8ea4275e1278350ced63da0b166421928276c7c8e3f9729d7402a57b", size = 860334 }, + { url = "https://files.pythonhosted.org/packages/eb/ff/f5ec1d455f8f7385cc0a8b2acd8c807d7fade875c14c44b85c1bddabae21/pyzmq-26.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:23f4aad749d13698f3f7b64aad34f5fc02d6f20f05999eebc96b89b01262fb18", size = 1196179 }, + { url = "https://files.pythonhosted.org/packages/ec/8a/bb2ac43295b1950fe436a81fc5b298be0b96ac76fb029b514d3ed58f7b27/pyzmq-26.2.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:a4f96f0d88accc3dbe4a9025f785ba830f968e21e3e2c6321ccdfc9aef755115", size = 1507668 }, + { url = "https://files.pythonhosted.org/packages/a9/49/dbc284ebcfd2dca23f6349227ff1616a7ee2c4a35fe0a5d6c3deff2b4fed/pyzmq-26.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ced65e5a985398827cc9276b93ef6dfabe0273c23de8c7931339d7e141c2818e", size = 1406539 }, + { url = "https://files.pythonhosted.org/packages/00/68/093cdce3fe31e30a341d8e52a1ad86392e13c57970d722c1f62a1d1a54b6/pyzmq-26.2.0-cp313-cp313-win32.whl", hash = "sha256:31507f7b47cc1ead1f6e86927f8ebb196a0bab043f6345ce070f412a59bf87b5", size = 575567 }, + { url = "https://files.pythonhosted.org/packages/92/ae/6cc4657148143412b5819b05e362ae7dd09fb9fe76e2a539dcff3d0386bc/pyzmq-26.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:70fc7fcf0410d16ebdda9b26cbd8bf8d803d220a7f3522e060a69a9c87bf7bad", size = 637551 }, + { url = "https://files.pythonhosted.org/packages/6c/67/fbff102e201688f97c8092e4c3445d1c1068c2f27bbd45a578df97ed5f94/pyzmq-26.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:c3789bd5768ab5618ebf09cef6ec2b35fed88709b104351748a63045f0ff9797", size = 540378 }, + { url = "https://files.pythonhosted.org/packages/3f/fe/2d998380b6e0122c6c4bdf9b6caf490831e5f5e2d08a203b5adff060c226/pyzmq-26.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:034da5fc55d9f8da09015d368f519478a52675e558c989bfcb5cf6d4e16a7d2a", size = 1007378 }, + { url = "https://files.pythonhosted.org/packages/4a/f4/30d6e7157f12b3a0390bde94d6a8567cdb88846ed068a6e17238a4ccf600/pyzmq-26.2.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:c92d73464b886931308ccc45b2744e5968cbaade0b1d6aeb40d8ab537765f5bc", size = 1329532 }, + { url = "https://files.pythonhosted.org/packages/82/86/3fe917870e15ee1c3ad48229a2a64458e36036e64b4afa9659045d82bfa8/pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:794a4562dcb374f7dbbfb3f51d28fb40123b5a2abadee7b4091f93054909add5", size = 653242 }, + { url = "https://files.pythonhosted.org/packages/50/2d/242e7e6ef6c8c19e6cb52d095834508cd581ffb925699fd3c640cdc758f1/pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aee22939bb6075e7afededabad1a56a905da0b3c4e3e0c45e75810ebe3a52672", size = 888404 }, + { url = "https://files.pythonhosted.org/packages/ac/11/7270566e1f31e4ea73c81ec821a4b1688fd551009a3d2bab11ec66cb1e8f/pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ae90ff9dad33a1cfe947d2c40cb9cb5e600d759ac4f0fd22616ce6540f72797", size = 845858 }, + { url = "https://files.pythonhosted.org/packages/91/d5/72b38fbc69867795c8711bdd735312f9fef1e3d9204e2f63ab57085434b9/pyzmq-26.2.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:43a47408ac52647dfabbc66a25b05b6a61700b5165807e3fbd40063fcaf46386", size = 847375 }, + { url = "https://files.pythonhosted.org/packages/dd/9a/10ed3c7f72b4c24e719c59359fbadd1a27556a28b36cdf1cd9e4fb7845d5/pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:25bf2374a2a8433633c65ccb9553350d5e17e60c8eb4de4d92cc6bd60f01d306", size = 1183489 }, + { url = "https://files.pythonhosted.org/packages/72/2d/8660892543fabf1fe41861efa222455811adac9f3c0818d6c3170a1153e3/pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:007137c9ac9ad5ea21e6ad97d3489af654381324d5d3ba614c323f60dab8fae6", size = 1492932 }, + { url = "https://files.pythonhosted.org/packages/7b/d6/32fd69744afb53995619bc5effa2a405ae0d343cd3e747d0fbc43fe894ee/pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:470d4a4f6d48fb34e92d768b4e8a5cc3780db0d69107abf1cd7ff734b9766eb0", size = 1392485 }, + { url = "https://files.pythonhosted.org/packages/53/fb/36b2b2548286e9444e52fcd198760af99fd89102b5be50f0660fcfe902df/pyzmq-26.2.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:706e794564bec25819d21a41c31d4df2d48e1cc4b061e8d345d7fb4dd3e94072", size = 906955 }, + { url = "https://files.pythonhosted.org/packages/77/8f/6ce54f8979a01656e894946db6299e2273fcee21c8e5fa57c6295ef11f57/pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b435f2753621cd36e7c1762156815e21c985c72b19135dac43a7f4f31d28dd1", size = 565701 }, + { url = "https://files.pythonhosted.org/packages/ee/1c/bf8cd66730a866b16db8483286078892b7f6536f8c389fb46e4beba0a970/pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:160c7e0a5eb178011e72892f99f918c04a131f36056d10d9c1afb223fc952c2d", size = 794312 }, + { url = "https://files.pythonhosted.org/packages/71/43/91fa4ff25bbfdc914ab6bafa0f03241d69370ef31a761d16bb859f346582/pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c4a71d5d6e7b28a47a394c0471b7e77a0661e2d651e7ae91e0cab0a587859ca", size = 752775 }, + { url = "https://files.pythonhosted.org/packages/ec/d2/3b2ab40f455a256cb6672186bea95cd97b459ce4594050132d71e76f0d6f/pyzmq-26.2.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:90412f2db8c02a3864cbfc67db0e3dcdbda336acf1c469526d3e869394fe001c", size = 550762 }, +] + +[[package]] +name = "referencing" +version = "0.35.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/73ca1f8e72fff6fa52119dbd185f73a907b1989428917b24cff660129b6d/referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c", size = 62991 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/59/2056f61236782a2c86b33906c025d4f4a0b17be0161b63b70fd9e8775d36/referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de", size = 26684 }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490 }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242 }, +] + +[[package]] +name = "rpds-py" +version = "0.22.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/80/cce854d0921ff2f0a9fa831ba3ad3c65cee3a46711addf39a2af52df2cfd/rpds_py-0.22.3.tar.gz", hash = "sha256:e32fee8ab45d3c2db6da19a5323bc3362237c8b653c70194414b892fd06a080d", size = 26771 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/2a/ead1d09e57449b99dcc190d8d2323e3a167421d8f8fdf0f217c6f6befe47/rpds_py-0.22.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:6c7b99ca52c2c1752b544e310101b98a659b720b21db00e65edca34483259967", size = 359514 }, + { url = "https://files.pythonhosted.org/packages/8f/7e/1254f406b7793b586c68e217a6a24ec79040f85e030fff7e9049069284f4/rpds_py-0.22.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:be2eb3f2495ba669d2a985f9b426c1797b7d48d6963899276d22f23e33d47e37", size = 349031 }, + { url = "https://files.pythonhosted.org/packages/aa/da/17c6a2c73730d426df53675ff9cc6653ac7a60b6438d03c18e1c822a576a/rpds_py-0.22.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70eb60b3ae9245ddea20f8a4190bd79c705a22f8028aaf8bbdebe4716c3fab24", size = 381485 }, + { url = "https://files.pythonhosted.org/packages/aa/13/2dbacd820466aa2a3c4b747afb18d71209523d353cf865bf8f4796c969ea/rpds_py-0.22.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4041711832360a9b75cfb11b25a6a97c8fb49c07b8bd43d0d02b45d0b499a4ff", size = 386794 }, + { url = "https://files.pythonhosted.org/packages/6d/62/96905d0a35ad4e4bc3c098b2f34b2e7266e211d08635baa690643d2227be/rpds_py-0.22.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:64607d4cbf1b7e3c3c8a14948b99345eda0e161b852e122c6bb71aab6d1d798c", size = 423523 }, + { url = "https://files.pythonhosted.org/packages/eb/1b/d12770f2b6a9fc2c3ec0d810d7d440f6d465ccd8b7f16ae5385952c28b89/rpds_py-0.22.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e69b0a0e2537f26d73b4e43ad7bc8c8efb39621639b4434b76a3de50c6966e", size = 446695 }, + { url = "https://files.pythonhosted.org/packages/4d/cf/96f1fd75512a017f8e07408b6d5dbeb492d9ed46bfe0555544294f3681b3/rpds_py-0.22.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc27863442d388870c1809a87507727b799c8460573cfbb6dc0eeaef5a11b5ec", size = 381959 }, + { url = "https://files.pythonhosted.org/packages/ab/f0/d1c5b501c8aea85aeb938b555bfdf7612110a2f8cdc21ae0482c93dd0c24/rpds_py-0.22.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e79dd39f1e8c3504be0607e5fc6e86bb60fe3584bec8b782578c3b0fde8d932c", size = 410420 }, + { url = "https://files.pythonhosted.org/packages/33/3b/45b6c58fb6aad5a569ae40fb890fc494c6b02203505a5008ee6dc68e65f7/rpds_py-0.22.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e0fa2d4ec53dc51cf7d3bb22e0aa0143966119f42a0c3e4998293a3dd2856b09", size = 557620 }, + { url = "https://files.pythonhosted.org/packages/83/62/3fdd2d3d47bf0bb9b931c4c73036b4ab3ec77b25e016ae26fab0f02be2af/rpds_py-0.22.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fda7cb070f442bf80b642cd56483b5548e43d366fe3f39b98e67cce780cded00", size = 584202 }, + { url = "https://files.pythonhosted.org/packages/04/f2/5dced98b64874b84ca824292f9cee2e3f30f3bcf231d15a903126684f74d/rpds_py-0.22.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cff63a0272fcd259dcc3be1657b07c929c466b067ceb1c20060e8d10af56f5bf", size = 552787 }, + { url = "https://files.pythonhosted.org/packages/67/13/2273dea1204eda0aea0ef55145da96a9aa28b3f88bb5c70e994f69eda7c3/rpds_py-0.22.3-cp310-cp310-win32.whl", hash = "sha256:9bd7228827ec7bb817089e2eb301d907c0d9827a9e558f22f762bb690b131652", size = 220088 }, + { url = "https://files.pythonhosted.org/packages/4e/80/8c8176b67ad7f4a894967a7a4014ba039626d96f1d4874d53e409b58d69f/rpds_py-0.22.3-cp310-cp310-win_amd64.whl", hash = "sha256:9beeb01d8c190d7581a4d59522cd3d4b6887040dcfc744af99aa59fef3e041a8", size = 231737 }, + { url = "https://files.pythonhosted.org/packages/15/ad/8d1ddf78f2805a71253fcd388017e7b4a0615c22c762b6d35301fef20106/rpds_py-0.22.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d20cfb4e099748ea39e6f7b16c91ab057989712d31761d3300d43134e26e165f", size = 359773 }, + { url = "https://files.pythonhosted.org/packages/c8/75/68c15732293a8485d79fe4ebe9045525502a067865fa4278f178851b2d87/rpds_py-0.22.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:68049202f67380ff9aa52f12e92b1c30115f32e6895cd7198fa2a7961621fc5a", size = 349214 }, + { url = "https://files.pythonhosted.org/packages/3c/4c/7ce50f3070083c2e1b2bbd0fb7046f3da55f510d19e283222f8f33d7d5f4/rpds_py-0.22.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb4f868f712b2dd4bcc538b0a0c1f63a2b1d584c925e69a224d759e7070a12d5", size = 380477 }, + { url = "https://files.pythonhosted.org/packages/9a/e9/835196a69cb229d5c31c13b8ae603bd2da9a6695f35fe4270d398e1db44c/rpds_py-0.22.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bc51abd01f08117283c5ebf64844a35144a0843ff7b2983e0648e4d3d9f10dbb", size = 386171 }, + { url = "https://files.pythonhosted.org/packages/f9/8e/33fc4eba6683db71e91e6d594a2cf3a8fbceb5316629f0477f7ece5e3f75/rpds_py-0.22.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f3cec041684de9a4684b1572fe28c7267410e02450f4561700ca5a3bc6695a2", size = 422676 }, + { url = "https://files.pythonhosted.org/packages/37/47/2e82d58f8046a98bb9497a8319604c92b827b94d558df30877c4b3c6ccb3/rpds_py-0.22.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7ef9d9da710be50ff6809fed8f1963fecdfecc8b86656cadfca3bc24289414b0", size = 446152 }, + { url = "https://files.pythonhosted.org/packages/e1/78/79c128c3e71abbc8e9739ac27af11dc0f91840a86fce67ff83c65d1ba195/rpds_py-0.22.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59f4a79c19232a5774aee369a0c296712ad0e77f24e62cad53160312b1c1eaa1", size = 381300 }, + { url = "https://files.pythonhosted.org/packages/c9/5b/2e193be0e8b228c1207f31fa3ea79de64dadb4f6a4833111af8145a6bc33/rpds_py-0.22.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a60bce91f81ddaac922a40bbb571a12c1070cb20ebd6d49c48e0b101d87300d", size = 409636 }, + { url = "https://files.pythonhosted.org/packages/c2/3f/687c7100b762d62186a1c1100ffdf99825f6fa5ea94556844bbbd2d0f3a9/rpds_py-0.22.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e89391e6d60251560f0a8f4bd32137b077a80d9b7dbe6d5cab1cd80d2746f648", size = 556708 }, + { url = "https://files.pythonhosted.org/packages/8c/a2/c00cbc4b857e8b3d5e7f7fc4c81e23afd8c138b930f4f3ccf9a41a23e9e4/rpds_py-0.22.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e3fb866d9932a3d7d0c82da76d816996d1667c44891bd861a0f97ba27e84fc74", size = 583554 }, + { url = "https://files.pythonhosted.org/packages/d0/08/696c9872cf56effdad9ed617ac072f6774a898d46b8b8964eab39ec562d2/rpds_py-0.22.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1352ae4f7c717ae8cba93421a63373e582d19d55d2ee2cbb184344c82d2ae55a", size = 552105 }, + { url = "https://files.pythonhosted.org/packages/18/1f/4df560be1e994f5adf56cabd6c117e02de7c88ee238bb4ce03ed50da9d56/rpds_py-0.22.3-cp311-cp311-win32.whl", hash = "sha256:b0b4136a252cadfa1adb705bb81524eee47d9f6aab4f2ee4fa1e9d3cd4581f64", size = 220199 }, + { url = "https://files.pythonhosted.org/packages/b8/1b/c29b570bc5db8237553002788dc734d6bd71443a2ceac2a58202ec06ef12/rpds_py-0.22.3-cp311-cp311-win_amd64.whl", hash = "sha256:8bd7c8cfc0b8247c8799080fbff54e0b9619e17cdfeb0478ba7295d43f635d7c", size = 231775 }, + { url = "https://files.pythonhosted.org/packages/75/47/3383ee3bd787a2a5e65a9b9edc37ccf8505c0a00170e3a5e6ea5fbcd97f7/rpds_py-0.22.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:27e98004595899949bd7a7b34e91fa7c44d7a97c40fcaf1d874168bb652ec67e", size = 352334 }, + { url = "https://files.pythonhosted.org/packages/40/14/aa6400fa8158b90a5a250a77f2077c0d0cd8a76fce31d9f2b289f04c6dec/rpds_py-0.22.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1978d0021e943aae58b9b0b196fb4895a25cc53d3956b8e35e0b7682eefb6d56", size = 342111 }, + { url = "https://files.pythonhosted.org/packages/7d/06/395a13bfaa8a28b302fb433fb285a67ce0ea2004959a027aea8f9c52bad4/rpds_py-0.22.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:655ca44a831ecb238d124e0402d98f6212ac527a0ba6c55ca26f616604e60a45", size = 384286 }, + { url = "https://files.pythonhosted.org/packages/43/52/d8eeaffab047e6b7b7ef7f00d5ead074a07973968ffa2d5820fa131d7852/rpds_py-0.22.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:feea821ee2a9273771bae61194004ee2fc33f8ec7db08117ef9147d4bbcbca8e", size = 391739 }, + { url = "https://files.pythonhosted.org/packages/83/31/52dc4bde85c60b63719610ed6f6d61877effdb5113a72007679b786377b8/rpds_py-0.22.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:22bebe05a9ffc70ebfa127efbc429bc26ec9e9b4ee4d15a740033efda515cf3d", size = 427306 }, + { url = "https://files.pythonhosted.org/packages/70/d5/1bab8e389c2261dba1764e9e793ed6830a63f830fdbec581a242c7c46bda/rpds_py-0.22.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3af6e48651c4e0d2d166dc1b033b7042ea3f871504b6805ba5f4fe31581d8d38", size = 442717 }, + { url = "https://files.pythonhosted.org/packages/82/a1/a45f3e30835b553379b3a56ea6c4eb622cf11e72008229af840e4596a8ea/rpds_py-0.22.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e67ba3c290821343c192f7eae1d8fd5999ca2dc99994114643e2f2d3e6138b15", size = 385721 }, + { url = "https://files.pythonhosted.org/packages/a6/27/780c942de3120bdd4d0e69583f9c96e179dfff082f6ecbb46b8d6488841f/rpds_py-0.22.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:02fbb9c288ae08bcb34fb41d516d5eeb0455ac35b5512d03181d755d80810059", size = 415824 }, + { url = "https://files.pythonhosted.org/packages/94/0b/aa0542ca88ad20ea719b06520f925bae348ea5c1fdf201b7e7202d20871d/rpds_py-0.22.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f56a6b404f74ab372da986d240e2e002769a7d7102cc73eb238a4f72eec5284e", size = 561227 }, + { url = "https://files.pythonhosted.org/packages/0d/92/3ed77d215f82c8f844d7f98929d56cc321bb0bcfaf8f166559b8ec56e5f1/rpds_py-0.22.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0a0461200769ab3b9ab7e513f6013b7a97fdeee41c29b9db343f3c5a8e2b9e61", size = 587424 }, + { url = "https://files.pythonhosted.org/packages/09/42/cacaeb047a22cab6241f107644f230e2935d4efecf6488859a7dd82fc47d/rpds_py-0.22.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8633e471c6207a039eff6aa116e35f69f3156b3989ea3e2d755f7bc41754a4a7", size = 555953 }, + { url = "https://files.pythonhosted.org/packages/e6/52/c921dc6d5f5d45b212a456c1f5b17df1a471127e8037eb0972379e39dff4/rpds_py-0.22.3-cp312-cp312-win32.whl", hash = "sha256:593eba61ba0c3baae5bc9be2f5232430453fb4432048de28399ca7376de9c627", size = 221339 }, + { url = "https://files.pythonhosted.org/packages/f2/c7/f82b5be1e8456600395366f86104d1bd8d0faed3802ad511ef6d60c30d98/rpds_py-0.22.3-cp312-cp312-win_amd64.whl", hash = "sha256:d115bffdd417c6d806ea9069237a4ae02f513b778e3789a359bc5856e0404cc4", size = 235786 }, + { url = "https://files.pythonhosted.org/packages/d0/bf/36d5cc1f2c609ae6e8bf0fc35949355ca9d8790eceb66e6385680c951e60/rpds_py-0.22.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:ea7433ce7e4bfc3a85654aeb6747babe3f66eaf9a1d0c1e7a4435bbdf27fea84", size = 351657 }, + { url = "https://files.pythonhosted.org/packages/24/2a/f1e0fa124e300c26ea9382e59b2d582cba71cedd340f32d1447f4f29fa4e/rpds_py-0.22.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6dd9412824c4ce1aca56c47b0991e65bebb7ac3f4edccfd3f156150c96a7bf25", size = 341829 }, + { url = "https://files.pythonhosted.org/packages/cf/c2/0da1231dd16953845bed60d1a586fcd6b15ceaeb965f4d35cdc71f70f606/rpds_py-0.22.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20070c65396f7373f5df4005862fa162db5d25d56150bddd0b3e8214e8ef45b4", size = 384220 }, + { url = "https://files.pythonhosted.org/packages/c7/73/a4407f4e3a00a9d4b68c532bf2d873d6b562854a8eaff8faa6133b3588ec/rpds_py-0.22.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0b09865a9abc0ddff4e50b5ef65467cd94176bf1e0004184eb915cbc10fc05c5", size = 391009 }, + { url = "https://files.pythonhosted.org/packages/a9/c3/04b7353477ab360fe2563f5f0b176d2105982f97cd9ae80a9c5a18f1ae0f/rpds_py-0.22.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3453e8d41fe5f17d1f8e9c383a7473cd46a63661628ec58e07777c2fff7196dc", size = 426989 }, + { url = "https://files.pythonhosted.org/packages/8d/e6/e4b85b722bcf11398e17d59c0f6049d19cd606d35363221951e6d625fcb0/rpds_py-0.22.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f5d36399a1b96e1a5fdc91e0522544580dbebeb1f77f27b2b0ab25559e103b8b", size = 441544 }, + { url = "https://files.pythonhosted.org/packages/27/fc/403e65e56f65fff25f2973216974976d3f0a5c3f30e53758589b6dc9b79b/rpds_py-0.22.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:009de23c9c9ee54bf11303a966edf4d9087cd43a6003672e6aa7def643d06518", size = 385179 }, + { url = "https://files.pythonhosted.org/packages/57/9b/2be9ff9700d664d51fd96b33d6595791c496d2778cb0b2a634f048437a55/rpds_py-0.22.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1aef18820ef3e4587ebe8b3bc9ba6e55892a6d7b93bac6d29d9f631a3b4befbd", size = 415103 }, + { url = "https://files.pythonhosted.org/packages/bb/a5/03c2ad8ca10994fcf22dd2150dd1d653bc974fa82d9a590494c84c10c641/rpds_py-0.22.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f60bd8423be1d9d833f230fdbccf8f57af322d96bcad6599e5a771b151398eb2", size = 560916 }, + { url = "https://files.pythonhosted.org/packages/ba/2e/be4fdfc8b5b576e588782b56978c5b702c5a2307024120d8aeec1ab818f0/rpds_py-0.22.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:62d9cfcf4948683a18a9aff0ab7e1474d407b7bab2ca03116109f8464698ab16", size = 587062 }, + { url = "https://files.pythonhosted.org/packages/67/e0/2034c221937709bf9c542603d25ad43a68b4b0a9a0c0b06a742f2756eb66/rpds_py-0.22.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9253fc214112405f0afa7db88739294295f0e08466987f1d70e29930262b4c8f", size = 555734 }, + { url = "https://files.pythonhosted.org/packages/ea/ce/240bae07b5401a22482b58e18cfbabaa392409b2797da60223cca10d7367/rpds_py-0.22.3-cp313-cp313-win32.whl", hash = "sha256:fb0ba113b4983beac1a2eb16faffd76cb41e176bf58c4afe3e14b9c681f702de", size = 220663 }, + { url = "https://files.pythonhosted.org/packages/cb/f0/d330d08f51126330467edae2fa4efa5cec8923c87551a79299380fdea30d/rpds_py-0.22.3-cp313-cp313-win_amd64.whl", hash = "sha256:c58e2339def52ef6b71b8f36d13c3688ea23fa093353f3a4fee2556e62086ec9", size = 235503 }, + { url = "https://files.pythonhosted.org/packages/f7/c4/dbe1cc03df013bf2feb5ad00615038050e7859f381e96fb5b7b4572cd814/rpds_py-0.22.3-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:f82a116a1d03628a8ace4859556fb39fd1424c933341a08ea3ed6de1edb0283b", size = 347698 }, + { url = "https://files.pythonhosted.org/packages/a4/3a/684f66dd6b0f37499cad24cd1c0e523541fd768576fa5ce2d0a8799c3cba/rpds_py-0.22.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3dfcbc95bd7992b16f3f7ba05af8a64ca694331bd24f9157b49dadeeb287493b", size = 337330 }, + { url = "https://files.pythonhosted.org/packages/82/eb/e022c08c2ce2e8f7683baa313476492c0e2c1ca97227fe8a75d9f0181e95/rpds_py-0.22.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:59259dc58e57b10e7e18ce02c311804c10c5a793e6568f8af4dead03264584d1", size = 380022 }, + { url = "https://files.pythonhosted.org/packages/e4/21/5a80e653e4c86aeb28eb4fea4add1f72e1787a3299687a9187105c3ee966/rpds_py-0.22.3-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5725dd9cc02068996d4438d397e255dcb1df776b7ceea3b9cb972bdb11260a83", size = 390754 }, + { url = "https://files.pythonhosted.org/packages/37/a4/d320a04ae90f72d080b3d74597074e62be0a8ecad7d7321312dfe2dc5a6a/rpds_py-0.22.3-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:99b37292234e61325e7a5bb9689e55e48c3f5f603af88b1642666277a81f1fbd", size = 423840 }, + { url = "https://files.pythonhosted.org/packages/87/70/674dc47d93db30a6624279284e5631be4c3a12a0340e8e4f349153546728/rpds_py-0.22.3-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:27b1d3b3915a99208fee9ab092b8184c420f2905b7d7feb4aeb5e4a9c509b8a1", size = 438970 }, + { url = "https://files.pythonhosted.org/packages/3f/64/9500f4d66601d55cadd21e90784cfd5d5f4560e129d72e4339823129171c/rpds_py-0.22.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f612463ac081803f243ff13cccc648578e2279295048f2a8d5eb430af2bae6e3", size = 383146 }, + { url = "https://files.pythonhosted.org/packages/4d/45/630327addb1d17173adcf4af01336fd0ee030c04798027dfcb50106001e0/rpds_py-0.22.3-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f73d3fef726b3243a811121de45193c0ca75f6407fe66f3f4e183c983573e130", size = 408294 }, + { url = "https://files.pythonhosted.org/packages/5f/ef/8efb3373cee54ea9d9980b772e5690a0c9e9214045a4e7fa35046e399fee/rpds_py-0.22.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3f21f0495edea7fdbaaa87e633a8689cd285f8f4af5c869f27bc8074638ad69c", size = 556345 }, + { url = "https://files.pythonhosted.org/packages/54/01/151d3b9ef4925fc8f15bfb131086c12ec3c3d6dd4a4f7589c335bf8e85ba/rpds_py-0.22.3-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:1e9663daaf7a63ceccbbb8e3808fe90415b0757e2abddbfc2e06c857bf8c5e2b", size = 582292 }, + { url = "https://files.pythonhosted.org/packages/30/89/35fc7a6cdf3477d441c7aca5e9bbf5a14e0f25152aed7f63f4e0b141045d/rpds_py-0.22.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a76e42402542b1fae59798fab64432b2d015ab9d0c8c47ba7addddbaf7952333", size = 553855 }, + { url = "https://files.pythonhosted.org/packages/8f/e0/830c02b2457c4bd20a8c5bb394d31d81f57fbefce2dbdd2e31feff4f7003/rpds_py-0.22.3-cp313-cp313t-win32.whl", hash = "sha256:69803198097467ee7282750acb507fba35ca22cc3b85f16cf45fb01cb9097730", size = 219100 }, + { url = "https://files.pythonhosted.org/packages/f8/30/7ac943f69855c2db77407ae363484b915d861702dbba1aa82d68d57f42be/rpds_py-0.22.3-cp313-cp313t-win_amd64.whl", hash = "sha256:f5cf2a0c2bdadf3791b5c205d55a37a54025c6e18a71c71f82bb536cf9a454bf", size = 233794 }, + { url = "https://files.pythonhosted.org/packages/8b/63/e29f8ee14fcf383574f73b6bbdcbec0fbc2e5fc36b4de44d1ac389b1de62/rpds_py-0.22.3-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:d48424e39c2611ee1b84ad0f44fb3b2b53d473e65de061e3f460fc0be5f1939d", size = 360786 }, + { url = "https://files.pythonhosted.org/packages/d3/e0/771ee28b02a24e81c8c0e645796a371350a2bb6672753144f36ae2d2afc9/rpds_py-0.22.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:24e8abb5878e250f2eb0d7859a8e561846f98910326d06c0d51381fed59357bd", size = 350589 }, + { url = "https://files.pythonhosted.org/packages/cf/49/abad4c4a1e6f3adf04785a99c247bfabe55ed868133e2d1881200aa5d381/rpds_py-0.22.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4b232061ca880db21fa14defe219840ad9b74b6158adb52ddf0e87bead9e8493", size = 381848 }, + { url = "https://files.pythonhosted.org/packages/3a/7d/f4bc6d6fbe6af7a0d2b5f2ee77079efef7c8528712745659ec0026888998/rpds_py-0.22.3-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac0a03221cdb5058ce0167ecc92a8c89e8d0decdc9e99a2ec23380793c4dcb96", size = 387879 }, + { url = "https://files.pythonhosted.org/packages/13/b0/575c797377fdcd26cedbb00a3324232e4cb2c5d121f6e4b0dbf8468b12ef/rpds_py-0.22.3-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb0c341fa71df5a4595f9501df4ac5abfb5a09580081dffbd1ddd4654e6e9123", size = 423916 }, + { url = "https://files.pythonhosted.org/packages/54/78/87157fa39d58f32a68d3326f8a81ad8fb99f49fe2aa7ad9a1b7d544f9478/rpds_py-0.22.3-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bf9db5488121b596dbfc6718c76092fda77b703c1f7533a226a5a9f65248f8ad", size = 448410 }, + { url = "https://files.pythonhosted.org/packages/59/69/860f89996065a88be1b6ff2d60e96a02b920a262d8aadab99e7903986597/rpds_py-0.22.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b8db6b5b2d4491ad5b6bdc2bc7c017eec108acbf4e6785f42a9eb0ba234f4c9", size = 382841 }, + { url = "https://files.pythonhosted.org/packages/bd/d7/bc144e10d27e3cb350f98df2492a319edd3caaf52ddfe1293f37a9afbfd7/rpds_py-0.22.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b3d504047aba448d70cf6fa22e06cb09f7cbd761939fdd47604f5e007675c24e", size = 409662 }, + { url = "https://files.pythonhosted.org/packages/14/2a/6bed0b05233c291a94c7e89bc76ffa1c619d4e1979fbfe5d96024020c1fb/rpds_py-0.22.3-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:e61b02c3f7a1e0b75e20c3978f7135fd13cb6cf551bf4a6d29b999a88830a338", size = 558221 }, + { url = "https://files.pythonhosted.org/packages/11/23/cd8f566de444a137bc1ee5795e47069a947e60810ba4152886fe5308e1b7/rpds_py-0.22.3-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:e35ba67d65d49080e8e5a1dd40101fccdd9798adb9b050ff670b7d74fa41c566", size = 583780 }, + { url = "https://files.pythonhosted.org/packages/8d/63/79c3602afd14d501f751e615a74a59040328da5ef29ed5754ae80d236b84/rpds_py-0.22.3-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:26fd7cac7dd51011a245f29a2cc6489c4608b5a8ce8d75661bb4a1066c52dfbe", size = 553619 }, + { url = "https://files.pythonhosted.org/packages/9f/2e/c5c1689e80298d4e94c75b70faada4c25445739d91b94c211244a3ed7ed1/rpds_py-0.22.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:177c7c0fce2855833819c98e43c262007f42ce86651ffbb84f37883308cb0e7d", size = 233338 }, +] + +[[package]] +name = "scipy" +version = "1.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/c6/8eb0654ba0c7d0bb1bf67bf8fbace101a8e4f250f7722371105e8b6f68fc/scipy-1.15.1.tar.gz", hash = "sha256:033a75ddad1463970c96a88063a1df87ccfddd526437136b6ee81ff0312ebdf6", size = 59407493 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/53/b204ce5a4433f1864001b9d16f103b9c25f5002a602ae83585d0ea5f9c4a/scipy-1.15.1-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:c64ded12dcab08afff9e805a67ff4480f5e69993310e093434b10e85dc9d43e1", size = 41414518 }, + { url = "https://files.pythonhosted.org/packages/c7/fc/54ffa7a8847f7f303197a6ba65a66104724beba2e38f328135a78f0dc480/scipy-1.15.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:5b190b935e7db569960b48840e5bef71dc513314cc4e79a1b7d14664f57fd4ff", size = 32519265 }, + { url = "https://files.pythonhosted.org/packages/f1/77/a98b8ba03d6f371dc31a38719affd53426d4665729dcffbed4afe296784a/scipy-1.15.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:4b17d4220df99bacb63065c76b0d1126d82bbf00167d1730019d2a30d6ae01ea", size = 24792859 }, + { url = "https://files.pythonhosted.org/packages/a7/78/70bb9f0df7444b18b108580934bfef774822e28fd34a68e5c263c7d2828a/scipy-1.15.1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:63b9b6cd0333d0eb1a49de6f834e8aeaefe438df8f6372352084535ad095219e", size = 27886506 }, + { url = "https://files.pythonhosted.org/packages/14/a7/f40f6033e06de4176ddd6cc8c3ae9f10a226c3bca5d6b4ab883bc9914a14/scipy-1.15.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f151e9fb60fbf8e52426132f473221a49362091ce7a5e72f8aa41f8e0da4f25", size = 38375041 }, + { url = "https://files.pythonhosted.org/packages/17/03/390a1c5c61fd76b0fa4b3c5aa3bdd7e60f6c46f712924f1a9df5705ec046/scipy-1.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21e10b1dd56ce92fba3e786007322542361984f8463c6d37f6f25935a5a6ef52", size = 40597556 }, + { url = "https://files.pythonhosted.org/packages/4e/70/fa95b3ae026b97eeca58204a90868802e5155ac71b9d7bdee92b68115dd3/scipy-1.15.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5dff14e75cdbcf07cdaa1c7707db6017d130f0af9ac41f6ce443a93318d6c6e0", size = 42938505 }, + { url = "https://files.pythonhosted.org/packages/d6/07/427859116bdd71847c898180f01802691f203c3e2455a1eb496130ff07c5/scipy-1.15.1-cp310-cp310-win_amd64.whl", hash = "sha256:f82fcf4e5b377f819542fbc8541f7b5fbcf1c0017d0df0bc22c781bf60abc4d8", size = 43909663 }, + { url = "https://files.pythonhosted.org/packages/8e/2e/7b71312da9c2dabff53e7c9a9d08231bc34d9d8fdabe88a6f1155b44591c/scipy-1.15.1-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:5bd8d27d44e2c13d0c1124e6a556454f52cd3f704742985f6b09e75e163d20d2", size = 41424362 }, + { url = "https://files.pythonhosted.org/packages/81/8c/ab85f1aa1cc200c796532a385b6ebf6a81089747adc1da7482a062acc46c/scipy-1.15.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:be3deeb32844c27599347faa077b359584ba96664c5c79d71a354b80a0ad0ce0", size = 32535910 }, + { url = "https://files.pythonhosted.org/packages/3b/9c/6f4b787058daa8d8da21ddff881b4320e28de4704a65ec147adb50cb2230/scipy-1.15.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:5eb0ca35d4b08e95da99a9f9c400dc9f6c21c424298a0ba876fdc69c7afacedf", size = 24809398 }, + { url = "https://files.pythonhosted.org/packages/16/2b/949460a796df75fc7a1ee1becea202cf072edbe325ebe29f6d2029947aa7/scipy-1.15.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:74bb864ff7640dea310a1377d8567dc2cb7599c26a79ca852fc184cc851954ac", size = 27918045 }, + { url = "https://files.pythonhosted.org/packages/5f/36/67fe249dd7ccfcd2a38b25a640e3af7e59d9169c802478b6035ba91dfd6d/scipy-1.15.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:667f950bf8b7c3a23b4199db24cb9bf7512e27e86d0e3813f015b74ec2c6e3df", size = 38332074 }, + { url = "https://files.pythonhosted.org/packages/fc/da/452e1119e6f720df3feb588cce3c42c5e3d628d4bfd4aec097bd30b7de0c/scipy-1.15.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:395be70220d1189756068b3173853029a013d8c8dd5fd3d1361d505b2aa58fa7", size = 40588469 }, + { url = "https://files.pythonhosted.org/packages/7f/71/5f94aceeac99a4941478af94fe9f459c6752d497035b6b0761a700f5f9ff/scipy-1.15.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce3a000cd28b4430426db2ca44d96636f701ed12e2b3ca1f2b1dd7abdd84b39a", size = 42965214 }, + { url = "https://files.pythonhosted.org/packages/af/25/caa430865749d504271757cafd24066d596217e83326155993980bc22f97/scipy-1.15.1-cp311-cp311-win_amd64.whl", hash = "sha256:3fe1d95944f9cf6ba77aa28b82dd6bb2a5b52f2026beb39ecf05304b8392864b", size = 43896034 }, + { url = "https://files.pythonhosted.org/packages/d8/6e/a9c42d0d39e09ed7fd203d0ac17adfea759cba61ab457671fe66e523dbec/scipy-1.15.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c09aa9d90f3500ea4c9b393ee96f96b0ccb27f2f350d09a47f533293c78ea776", size = 41478318 }, + { url = "https://files.pythonhosted.org/packages/04/ee/e3e535c81828618878a7433992fecc92fa4df79393f31a8fea1d05615091/scipy-1.15.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:0ac102ce99934b162914b1e4a6b94ca7da0f4058b6d6fd65b0cef330c0f3346f", size = 32596696 }, + { url = "https://files.pythonhosted.org/packages/c4/5e/b1b0124be8e76f87115f16b8915003eec4b7060298117715baf13f51942c/scipy-1.15.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:09c52320c42d7f5c7748b69e9f0389266fd4f82cf34c38485c14ee976cb8cb04", size = 24870366 }, + { url = "https://files.pythonhosted.org/packages/14/36/c00cb73eefda85946172c27913ab995c6ad4eee00fa4f007572e8c50cd51/scipy-1.15.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:cdde8414154054763b42b74fe8ce89d7f3d17a7ac5dd77204f0e142cdc9239e9", size = 28007461 }, + { url = "https://files.pythonhosted.org/packages/68/94/aff5c51b3799349a9d1e67a056772a0f8a47db371e83b498d43467806557/scipy-1.15.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c9d8fc81d6a3b6844235e6fd175ee1d4c060163905a2becce8e74cb0d7554ce", size = 38068174 }, + { url = "https://files.pythonhosted.org/packages/b0/3c/0de11ca154e24a57b579fb648151d901326d3102115bc4f9a7a86526ce54/scipy-1.15.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fb57b30f0017d4afa5fe5f5b150b8f807618819287c21cbe51130de7ccdaed2", size = 40249869 }, + { url = "https://files.pythonhosted.org/packages/15/09/472e8d0a6b33199d1bb95e49bedcabc0976c3724edd9b0ef7602ccacf41e/scipy-1.15.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:491d57fe89927fa1aafbe260f4cfa5ffa20ab9f1435025045a5315006a91b8f5", size = 42629068 }, + { url = "https://files.pythonhosted.org/packages/ff/ba/31c7a8131152822b3a2cdeba76398ffb404d81d640de98287d236da90c49/scipy-1.15.1-cp312-cp312-win_amd64.whl", hash = "sha256:900f3fa3db87257510f011c292a5779eb627043dd89731b9c461cd16ef76ab3d", size = 43621992 }, + { url = "https://files.pythonhosted.org/packages/2b/bf/dd68965a4c5138a630eeed0baec9ae96e5d598887835bdde96cdd2fe4780/scipy-1.15.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:100193bb72fbff37dbd0bf14322314fc7cbe08b7ff3137f11a34d06dc0ee6b85", size = 41441136 }, + { url = "https://files.pythonhosted.org/packages/ef/5e/4928581312922d7e4d416d74c416a660addec4dd5ea185401df2269ba5a0/scipy-1.15.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:2114a08daec64980e4b4cbdf5bee90935af66d750146b1d2feb0d3ac30613692", size = 32533699 }, + { url = "https://files.pythonhosted.org/packages/32/90/03f99c43041852837686898c66767787cd41c5843d7a1509c39ffef683e9/scipy-1.15.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6b3e71893c6687fc5e29208d518900c24ea372a862854c9888368c0b267387ab", size = 24807289 }, + { url = "https://files.pythonhosted.org/packages/9d/52/bfe82b42ae112eaba1af2f3e556275b8727d55ac6e4932e7aef337a9d9d4/scipy-1.15.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:837299eec3d19b7e042923448d17d95a86e43941104d33f00da7e31a0f715d3c", size = 27929844 }, + { url = "https://files.pythonhosted.org/packages/f6/77/54ff610bad600462c313326acdb035783accc6a3d5f566d22757ad297564/scipy-1.15.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82add84e8a9fb12af5c2c1a3a3f1cb51849d27a580cb9e6bd66226195142be6e", size = 38031272 }, + { url = "https://files.pythonhosted.org/packages/f1/26/98585cbf04c7cf503d7eb0a1966df8a268154b5d923c5fe0c1ed13154c49/scipy-1.15.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:070d10654f0cb6abd295bc96c12656f948e623ec5f9a4eab0ddb1466c000716e", size = 40210217 }, + { url = "https://files.pythonhosted.org/packages/fd/3f/3d2285eb6fece8bc5dbb2f9f94d61157d61d155e854fd5fea825b8218f12/scipy-1.15.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:55cc79ce4085c702ac31e49b1e69b27ef41111f22beafb9b49fea67142b696c4", size = 42587785 }, + { url = "https://files.pythonhosted.org/packages/48/7d/5b5251984bf0160d6533695a74a5fddb1fa36edd6f26ffa8c871fbd4782a/scipy-1.15.1-cp313-cp313-win_amd64.whl", hash = "sha256:c352c1b6d7cac452534517e022f8f7b8d139cd9f27e6fbd9f3cbd0bfd39f5bef", size = 43640439 }, + { url = "https://files.pythonhosted.org/packages/e7/b8/0e092f592d280496de52e152582030f8a270b194f87f890e1a97c5599b81/scipy-1.15.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0458839c9f873062db69a03de9a9765ae2e694352c76a16be44f93ea45c28d2b", size = 41619862 }, + { url = "https://files.pythonhosted.org/packages/f6/19/0b6e1173aba4db9e0b7aa27fe45019857fb90d6904038b83927cbe0a6c1d/scipy-1.15.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:af0b61c1de46d0565b4b39c6417373304c1d4f5220004058bdad3061c9fa8a95", size = 32610387 }, + { url = "https://files.pythonhosted.org/packages/e7/02/754aae3bd1fa0f2479ade3cfdf1732ecd6b05853f63eee6066a32684563a/scipy-1.15.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:71ba9a76c2390eca6e359be81a3e879614af3a71dfdabb96d1d7ab33da6f2364", size = 24883814 }, + { url = "https://files.pythonhosted.org/packages/1f/ac/d7906201604a2ea3b143bb0de51b3966f66441ba50b7dc182c4505b3edf9/scipy-1.15.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:14eaa373c89eaf553be73c3affb11ec6c37493b7eaaf31cf9ac5dffae700c2e0", size = 27944865 }, + { url = "https://files.pythonhosted.org/packages/84/9d/8f539002b5e203723af6a6f513a45e0a7671e9dabeedb08f417ac17e4edc/scipy-1.15.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f735bc41bd1c792c96bc426dece66c8723283695f02df61dcc4d0a707a42fc54", size = 39883261 }, + { url = "https://files.pythonhosted.org/packages/97/c0/62fd3bab828bcccc9b864c5997645a3b86372a35941cdaf677565c25c98d/scipy-1.15.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2722a021a7929d21168830790202a75dbb20b468a8133c74a2c0230c72626b6c", size = 42093299 }, + { url = "https://files.pythonhosted.org/packages/e4/1f/5d46a8d94e9f6d2c913cbb109e57e7eed914de38ea99e2c4d69a9fc93140/scipy-1.15.1-cp313-cp313t-win_amd64.whl", hash = "sha256:bc7136626261ac1ed988dca56cfc4ab5180f75e0ee52e58f1e6aa74b5f3eacd5", size = 43181730 }, +] + +[[package]] +name = "seaborn" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pandas" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914 }, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/3a/aec9b02217bb79b87bbc1a21bc6abc51e3d5dcf65c30487ac96c0908c722/Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf", size = 17394 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072 }, +] + +[[package]] +name = "setuptools" +version = "75.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/ec/089608b791d210aec4e7f97488e67ab0d33add3efccb83a056cbafe3a2a6/setuptools-75.8.0.tar.gz", hash = "sha256:c5afc8f407c626b8313a86e10311dd3f661c6cd9c09d4bf8c15c0e11f9f2b0e6", size = 1343222 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/8a/b9dc7678803429e4a3bc9ba462fa3dd9066824d3c607490235c6a796be5a/setuptools-75.8.0-py3-none-any.whl", hash = "sha256:e3982f444617239225d675215d51f6ba05f845d4eec313da4418fdbb56fb27e3", size = 1228782 }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, +] + +[[package]] +name = "soupsieve" +version = "2.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/ce/fbaeed4f9fb8b2daa961f90591662df6a86c1abf25c548329a86920aedfb/soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb", size = 101569 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/c2/fe97d779f3ef3b15f05c94a2f1e3d21732574ed441687474db9d342a7315/soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9", size = 36186 }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, +] + +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154 }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610 }, +] + +[[package]] +name = "tomli" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, + { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, + { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, + { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, + { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, + { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, + { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, + { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, + { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 }, + { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 }, + { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, + { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, + { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, + { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, + { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, + { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, + { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, + { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, + { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 }, + { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 }, + { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, + { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, + { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, + { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, + { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, + { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, + { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, + { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, + { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 }, + { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, + { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, +] + +[[package]] +name = "tornado" +version = "6.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/45/a0daf161f7d6f36c3ea5fc0c2de619746cc3dd4c76402e9db545bd920f63/tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b", size = 501135 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/7e/71f604d8cea1b58f82ba3590290b66da1e72d840aeb37e0d5f7291bd30db/tornado-6.4.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e828cce1123e9e44ae2a50a9de3055497ab1d0aeb440c5ac23064d9e44880da1", size = 436299 }, + { url = "https://files.pythonhosted.org/packages/96/44/87543a3b99016d0bf54fdaab30d24bf0af2e848f1d13d34a3a5380aabe16/tornado-6.4.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:072ce12ada169c5b00b7d92a99ba089447ccc993ea2143c9ede887e0937aa803", size = 434253 }, + { url = "https://files.pythonhosted.org/packages/cb/fb/fdf679b4ce51bcb7210801ef4f11fdac96e9885daa402861751353beea6e/tornado-6.4.2-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a017d239bd1bb0919f72af256a970624241f070496635784d9bf0db640d3fec", size = 437602 }, + { url = "https://files.pythonhosted.org/packages/4f/3b/e31aeffffc22b475a64dbeb273026a21b5b566f74dee48742817626c47dc/tornado-6.4.2-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c36e62ce8f63409301537222faffcef7dfc5284f27eec227389f2ad11b09d946", size = 436972 }, + { url = "https://files.pythonhosted.org/packages/22/55/b78a464de78051a30599ceb6983b01d8f732e6f69bf37b4ed07f642ac0fc/tornado-6.4.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca9eb02196e789c9cb5c3c7c0f04fb447dc2adffd95265b2c7223a8a615ccbf", size = 437173 }, + { url = "https://files.pythonhosted.org/packages/79/5e/be4fb0d1684eb822c9a62fb18a3e44a06188f78aa466b2ad991d2ee31104/tornado-6.4.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:304463bd0772442ff4d0f5149c6f1c2135a1fae045adf070821c6cdc76980634", size = 437892 }, + { url = "https://files.pythonhosted.org/packages/f5/33/4f91fdd94ea36e1d796147003b490fe60a0215ac5737b6f9c65e160d4fe0/tornado-6.4.2-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:c82c46813ba483a385ab2a99caeaedf92585a1f90defb5693351fa7e4ea0bf73", size = 437334 }, + { url = "https://files.pythonhosted.org/packages/2b/ae/c1b22d4524b0e10da2f29a176fb2890386f7bd1f63aacf186444873a88a0/tornado-6.4.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:932d195ca9015956fa502c6b56af9eb06106140d844a335590c1ec7f5277d10c", size = 437261 }, + { url = "https://files.pythonhosted.org/packages/b5/25/36dbd49ab6d179bcfc4c6c093a51795a4f3bed380543a8242ac3517a1751/tornado-6.4.2-cp38-abi3-win32.whl", hash = "sha256:2876cef82e6c5978fde1e0d5b1f919d756968d5b4282418f3146b79b58556482", size = 438463 }, + { url = "https://files.pythonhosted.org/packages/61/cc/58b1adeb1bb46228442081e746fcdbc4540905c87e8add7c277540934edb/tornado-6.4.2-cp38-abi3-win_amd64.whl", hash = "sha256:908b71bf3ff37d81073356a5fadcc660eb10c1476ee6e2725588626ce7e5ca38", size = 438907 }, +] + +[[package]] +name = "tqdm" +version = "4.67.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540 }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20241206" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/60/47d92293d9bc521cd2301e423a358abfac0ad409b3a1606d8fbae1321961/types_python_dateutil-2.9.0.20241206.tar.gz", hash = "sha256:18f493414c26ffba692a72369fea7a154c502646301ebfe3d56a04b3767284cb", size = 13802 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/b3/ca41df24db5eb99b00d97f89d7674a90cb6b3134c52fb8121b6d8d30f15c/types_python_dateutil-2.9.0.20241206-py3-none-any.whl", hash = "sha256:e248a4bc70a486d3e3ec84d0dc30eec3a5f979d6e7ee4123ae043eedbb987f53", size = 14384 }, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, +] + +[[package]] +name = "tzdata" +version = "2024.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586 }, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140 }, +] + +[[package]] +name = "urllib3" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369 }, +] + +[[package]] +name = "watchdog" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/56/90994d789c61df619bfc5ce2ecdabd5eeff564e1eb47512bd01b5e019569/watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26", size = 96390 }, + { url = "https://files.pythonhosted.org/packages/55/46/9a67ee697342ddf3c6daa97e3a587a56d6c4052f881ed926a849fcf7371c/watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112", size = 88389 }, + { url = "https://files.pythonhosted.org/packages/44/65/91b0985747c52064d8701e1075eb96f8c40a79df889e59a399453adfb882/watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3", size = 89020 }, + { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393 }, + { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392 }, + { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019 }, + { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471 }, + { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449 }, + { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054 }, + { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480 }, + { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451 }, + { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057 }, + { url = "https://files.pythonhosted.org/packages/30/ad/d17b5d42e28a8b91f8ed01cb949da092827afb9995d4559fd448d0472763/watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881", size = 87902 }, + { url = "https://files.pythonhosted.org/packages/5c/ca/c3649991d140ff6ab67bfc85ab42b165ead119c9e12211e08089d763ece5/watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11", size = 88380 }, + { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079 }, + { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076 }, + { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065 }, + { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070 }, + { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067 }, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, +] + +[[package]] +name = "webcolors" +version = "24.11.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/29/061ec845fb58521848f3739e466efd8250b4b7b98c1b6c5bf4d40b419b7e/webcolors-24.11.1.tar.gz", hash = "sha256:ecb3d768f32202af770477b8b65f318fa4f566c22948673a977b00d589dd80f6", size = 45064 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/e8/c0e05e4684d13459f93d312077a9a2efbe04d59c393bc2b8802248c908d4/webcolors-24.11.1-py3-none-any.whl", hash = "sha256:515291393b4cdf0eb19c155749a096f779f7d909f7cceea072791cb9095b92e9", size = 14934 }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774 }, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826 }, +]