diff --git a/docs/example-warmstart.ipynb b/docs/example-warmstart.ipynb index abc9998f..c4eecf31 100644 --- a/docs/example-warmstart.ipynb +++ b/docs/example-warmstart.ipynb @@ -4,453 +4,508 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Tutorial: Warm and hot start for rapid iterations\n", + "# Tutorial: warm start from a similar fit\n", "\n", "In this tutorial you will learn:\n", "\n", " - How to play with model variations\n", - " - Warm start: How UltraNest can resume and reuse an existing run, even if you modify the data/likelihood\n", - " - Hot start: How you can make UltraNest skip ahead to the posterior peak\n", + " - Warm start feature: How UltraNest can resume and reuse an existing run, even if you modified the data/likelihood\n", "\n", - "As a simple example, lets say we want to estimate the mean and standard deviation of a sample of points. Over time, more and more points are added." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate some data" + "As a simple example, lets say we want to fit a black body." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from numpy import pi, log\n", - "\n", - "np.random.seed(1)\n", - "Ndata = 200\n", - "mean_true = 42.0\n", - "sigma_true = 0.1\n", - "y = np.random.normal(mean_true, sigma_true, size=Ndata)\n" + "import scipy.stats\n", + "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Visualise the data\n", - "\n", - "Lets plot the data first to see what is going on:\n", - "\n" + "## Black body model" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.figure(figsize=(10, 5))\n", - "plt.errorbar(x=np.arange(Ndata), y=y, yerr=sigma_true, marker='x', ls=' ');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will ingest the data in chunks, with more and more information becoming available to us. Here are the chunks. We will first analyse the orange ones:" + "parameters = ['Temperature', 'Amplitude']" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "plt.figure(figsize=(10, 5))\n", - "plt.errorbar(x=np.arange(Ndata), y=y, yerr=sigma_true, marker='x', ls=' ')\n", - "plt.errorbar(x=np.arange(Ndata)[:10], y=y[:10], yerr=sigma_true, marker='x', ls=' ')\n", - "ymin, ymax = plt.ylim()\n", - "plt.vlines(np.arange(10, Ndata, 20), ymin, ymax, linestyles='--', color='gray')\n", - "plt.ylim(ymin, ymax);" + "def black_body_model(wavelength, ampl, T):\n", + " with np.errstate(over='ignore'):\n", + " return ampl / wavelength**5 / (np.exp(1/(wavelength*T)) - 1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Model setup" + "## Generate some data" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "from ultranest import ReactiveNestedSampler\n", - "\n", - "parameters = ['mean', 'scatter']\n", - "\n", - "def prior_transform(x):\n", - " z = np.empty_like(x)\n", - " z[0] = x[0] * 2000 - 1000\n", - " z[1] = 10**(x[1] * 4 - 2)\n", - " return z\n", - "\n", - "import scipy.stats\n", - "def log_likelihood(params):\n", - " mean, sigma = params\n", - " return scipy.stats.norm(mean, sigma).logpdf(yseen).sum()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Adding one new chunk at a time, no warm start" + "Ndata = 10\n", + "wavelength = np.logspace(1, 2, Ndata)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "reference_results = []\n", - "\n", - "for i in range(10, Ndata, 20):\n", - " print()\n", - " print(\"Iteration with %d data points\" % i)\n", - " yseen = y[:i]\n", - " sampler_ref = ReactiveNestedSampler(parameters, log_likelihood, prior_transform)\n", - " res_ref = sampler_ref.run(min_num_live_points=400, max_num_improvement_loops=0, viz_callback=None, frac_remain=0.5)\n", - " reference_results.append(res_ref)\n" + "np.random.seed(1)\n", + "ampl_true = 42.0\n", + "T_true = 0.01 # in um^-1\n", + "background_true = 1e-9\n", + "y_true = black_body_model(wavelength, ampl_true, T_true)\n", + "sigma_true = y_true * 0.1\n", + "y_obs = np.random.normal(y_true + background_true, sigma_true, size=Ndata)\n", + "sigma = y_true * 0.1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Warm start" + "## Visualise the data\n", + "\n", + "Lets plot the data first to see what is going on:\n", + "\n" ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "## Adding one data point at a time, with warm start" + "plt.figure(figsize=(10, 5))\n", + "plt.errorbar(x=wavelength, y=y_obs, yerr=sigma, marker='x', ls=' ')\n", + "plt.plot(wavelength, y_true, ':', color='gray')\n", + "plt.ylabel('Spectral flux density [Jy]');\n", + "plt.xlabel('Wavelength [$\\mu$m]');\n" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "results = []\n", - "\n", - "yseen = y[:]\n", - "\n", - "# delete any existing content:\n", - "ReactiveNestedSampler(parameters, log_likelihood, prior_transform,\n", - " log_dir='warmstartdoc', resume='overwrite')\n", - "\n", - "for i in range(10, Ndata, 20):\n", - " print()\n", - " print(\"Iteration with %d data points\" % i)\n", - " \n", - " yseen = y[:i]\n", - " sampler = ReactiveNestedSampler(parameters, log_likelihood, prior_transform,\n", - " log_dir='warmstartdoc', resume='resume-similar',\n", - " warmstart_max_tau=0.5)\n", - " ncall_initial = int(sampler.ncall)\n", - " res = sampler.run(frac_remain=0.5, viz_callback=None)\n", - " results.append((i, res, ncall_initial))\n", - "\n" + "## Prior" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Likelihood evaluations saved by warm start" + "Here we intentionally set very wide priors:\n", + "\n", + "* a uniform prior on temperature, and \n", + "* a very wide log-uniform prior on the normalisation." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "ndim = len(parameters)\n", - "plt.figure(figsize=(10, 10))\n", - "for (i, res, ncall_initial), res_ref in zip(results, reference_results):\n", - " for j in range(ndim):\n", - " plt.subplot(ndim + 2, 1, 1+j)\n", - " plt.ylabel(parameters[j])\n", - " plt.errorbar(x=i, y=res['samples'][:,j].mean(), yerr=res['samples'][:,j].std(), marker='x', color='r')\n", - " plt.errorbar(x=i, y=res_ref['samples'][:,j].mean(), yerr=res_ref['samples'][:,j].std(), marker='x', color='gray')\n", - " \n", - " plt.subplot(ndim + 2, 1, 1+ndim)\n", - " plt.ylabel('$\\log(\\Delta Z)$')\n", - " plt.plot(i, res['logz'] - res_ref['logz'], 'x', color='r')\n", - " plt.subplot(ndim + 2, 1, 1+ndim+1)\n", - " plt.ylabel('Likelihood call fraction')\n", - " plt.plot(i, ((res['ncall'] - ncall_initial) / res_ref['ncall']), 'x', color='r')\n", - " plt.ylim(0, 1)\n", - "\n", - "plt.subplot(ndim + 2, 1, 1)\n", - "plt.hlines(mean_true, 0, i+1, color='k', linestyles=':')\n", - "plt.subplot(ndim + 2, 1, 2)\n", - "plt.hlines(sigma_true, 0, i+1, color='k', linestyles=':')\n" + "def prior_transform(x):\n", + " z = x.copy()\n", + " z[0] = x[0]\n", + " z[1] = 10**(x[1] * 20 - 10)\n", + " return z\n" ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "## Take-aways:\n", + "plt.figure(figsize=(10, 5))\n", + "plt.title(\"Prior predictive checks\")\n", + "plt.errorbar(x=wavelength, y=y_obs, yerr=sigma, marker='x', ls=' ')\n", + "plt.ylim(0, y_obs.max() * 10)\n", "\n", - "Notice the time saving in the bottom panel by more than half. This benefit is *independent of problem dimension*. The cost savings are higher, the more similar the modified problem is." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Hot start" + "for i in range(20):\n", + " T, ampl = prior_transform(np.random.uniform(size=len(parameters)))\n", + " y_predicted = black_body_model(wavelength, ampl, T)\n", + " plt.plot(wavelength, y_predicted, '-', color='gray')\n", + "plt.ylabel('Spectral flux density [Jy]');\n", + "plt.xlabel('Wavelength [$\\mu$m]');\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We may already know roughly what the posterior looks like. If it is roughly gaussian, we can take advantage of this by running UltraNest on an auxiliary distribution.\n", - "\n", - "The speed-up depends on how the auxiliary distribution is defined. Therefore, this is left to the user, and not automatically derived. The following illustrates how to create a auxiliary distribution and work with it." + "# First simple model" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [], "source": [ - "## Guess a useful covariance" + "def log_likelihood(params):\n", + " T, ampl = params\n", + " y_predicted = black_body_model(wavelength, ampl, T)\n", + " return scipy.stats.norm(y_predicted, sigma).logpdf(y_obs).sum()\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ultranest] Sampling 400 live points from prior ...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "75f027c7ce0f42beb5047c4919e1ab8e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value=''), GridspecLayout(children=(HTML(value=\"
&nb…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ultranest] Explored until L=2e+02 7 [173.9132..173.9155]*| it/evals=5960/17596 eff=34.6592% N=400 400 \n", + "[ultranest] Likelihood function evaluations: 17598\n", + "[ultranest] Writing samples and results to disk ...\n", + "[ultranest] Writing samples and results to disk ... done\n", + "[ultranest] logZ = 160 +- 0.1753\n", + "[ultranest] Effective samples strategy satisfied (ESS = 983.4, need >400)\n", + "[ultranest] Posterior uncertainty strategy is satisfied (KL: 0.46+-0.07 nat, need <0.50 nat)\n", + "[ultranest] Evidency uncertainty strategy wants 398 minimum live points (dlogz from 0.14 to 0.51, need <0.5)\n", + "[ultranest] logZ error budget: single: 0.18 bs:0.18 tail:0.41 total:0.44 required:<0.50\n", + "[ultranest] done iterating.\n", + "\n", + "logZ = 160.064 +- 0.655\n", + " single instance: logZ = 160.064 +- 0.184\n", + " bootstrapped : logZ = 160.026 +- 0.514\n", + " tail : logZ = +- 0.405\n", + "insert order U test : converged: True correlation: inf iterations\n", + "\n", + " Temperature : 0.00940│ ▁▁▁▁▁▁▁▁▁▁▂▂▃▃▅▅▅▅▆▇▇▅▅▄▃▃▂▂▁▁▁▁▁▁▁▁▁ │0.01033 0.00988 +- 0.00011\n", + " Amplitude : 37.8 │ ▁▁▁▁▁▁▁▁▂▂▄▃▄▅▆▆▇▇▇▅▅▄▃▃▂▂▁▁▁▁▁▁▁▁ ▁▁ │58.5 47.4 +- 2.7\n", + "\n" + ] + } + ], "source": [ - "# take result from the second-to-last run\n", - "ref_result = reference_results[-2];" + "from ultranest import ReactiveNestedSampler\n", + "\n", + "reference_run_folder = 'blackbody-alldata'\n", + "sampler_ref = ReactiveNestedSampler(parameters, log_likelihood, prior_transform, log_dir=reference_run_folder, resume='overwrite')\n", + "results_ref = sampler_ref.run(frac_remain=0.5)\n", + "sampler_ref.print_results()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Luckily, the posterior here is already very gaussian-like:" + "## Plot the fit" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "import corner\n", - "corner.corner(ref_result['samples'], show_titles=True);" + "plt.figure(figsize=(10, 5))\n", + "plt.errorbar(x=wavelength, y=y_obs, yerr=sigma, marker='x', ls=' ')\n", + "from ultranest.plot import PredictionBand\n", + "band = PredictionBand(wavelength)\n", + "for T, ampl in results_ref['samples']:\n", + " band.add(black_body_model(wavelength, ampl, T))\n", + "band.line(color='k')\n", + "band.shade(color='k', alpha=0.5)\n", + "plt.ylabel('Spectral flux density [Jy]');\n", + "plt.xlabel('Wavelength [$\\mu$m]');\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**Step 1**: Identify the center and covariance (in u-space, i.e., before the prior transformation).\n", - "\n", - "You can also do this \n", + "# Warm Start with Model modification\n", "\n", - "* by looking at the data\n", - "* from posterior samples of a previous nested sampling or MCMC run\n", - "* with a minimizer such as [snowline](https://johannesbuchner.github.io/snowline/).\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We demonstrate the second method here:" + "Lets say we alter our model slightly. We include a small constant background:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ - "indices = np.random.choice(len(ref_result['weighted_samples']['weights']), p=ref_result['weighted_samples']['weights'], size=10000)\n", - "u_posterior = ref_result['weighted_samples']['upoints'][indices,:]\n", - "ctr = u_posterior.mean(axis=0)\n", - "cov = np.cov(u_posterior, rowvar=False)\n", - "\n", - "print(\"center in unit cube coordinates:\", ctr)\n", - "print(\"center in physical coordinates:\", prior_transform(ctr))\n", - "print(\"covariance:\", cov)\n", - "\n", - "invcov = np.linalg.inv(cov)\n", - "print(\"precision matrix:\", invcov)" + "def log_likelihood_with_background(params):\n", + " T, ampl = params\n", + " y_predicted = black_body_model(wavelength, ampl, T) + 1e-9\n", + " return scipy.stats.norm(y_predicted, sigma).logpdf(y_obs).sum()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let us intentionally show the case where a poor distribution is chosen:" + "We have the same parameters, and expect results to only be slightly different. So lets use **warm start**." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**Step 2**: Define the auxiliary distribution\n", - "\n", - "This is always the same, once you have chosen a center and covariance.\n", - "Here we use a multivariate Student-t distribution with one degree of freedom.\n", - "\n", - "This allows heavier-tailed posterior distributions than a Gaussian,\n", - "and is more forgiving if we mis-estimated the center or the covariance." + "Using the previous reference run output file ..." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ - "from ultranest.hotstart import get_extended_auxiliary_problem\n", - "\n", - "aux_log_likelihood, aux_transform = get_extended_auxiliary_problem(\n", - " log_likelihood, prior_transform, ctr, invcov, \n", - " enlargement_factor=len(parameters)**0.5, df=2)\n" + "posterior_upoints_file = reference_run_folder + '/chains/weighted_post_untransformed.txt'" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "#aux_parameters = ['aux_%d' % (i + 1) for i, p in enumerate(parameters)]\n", - "aux_sampler = ReactiveNestedSampler(\n", - " parameters, aux_log_likelihood, transform=aux_transform,\n", - " derived_param_names=['aux_logweight'],\n", - ")\n", - "aux_results = aux_sampler.run(frac_remain=0.5, viz_callback=None)" + "We define our accelerated likelihood and prior transform:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ - "from getdist import MCSamples, plots\n", - "\n", - "aux_dist_samples_full = np.array([aux_transform(np.random.uniform(size=len(parameters))) for i in range(10000)])\n", - "aux_dist_samples = aux_dist_samples_full[aux_dist_samples_full[:,-1] > -1e100,:-1]\n", - "\n", - "samples_o = MCSamples(samples=ref_result['samples'],\n", - " names=ref_result['paramnames'],\n", - " label='Cold start',\n", - " settings=dict(smooth_scale_2D=3), sampler='nested')\n", - "samples_a = MCSamples(samples=aux_dist_samples,\n", - " names=ref_result['paramnames'],\n", - " label='Auxiliary distribution',\n", - " settings=dict(smooth_scale_2D=1), sampler='nested')\n", - "samples_g = MCSamples(samples=aux_results['samples'][:,:-1],\n", - " names=aux_results['paramnames'][:-1],\n", - " label='Hot start',\n", - " settings=dict(smooth_scale_2D=3), sampler='nested')\n", + "from ultranest.integrator import warmstart_from_similar_file\n", "\n", - "mcsamples = [samples_o, samples_a, samples_g]\n", - "\n", - "g = plots.get_subplot_plotter(width_inch=8)\n", - "g.settings.num_plot_contours = 3\n", - "g.triangle_plot(mcsamples, filled=False, contour_colors=plt.cm.Set1.colors,\n", - " param_limits=dict(zip(parameters, [(41.9, 42.1), (0, 0.2)])))\n", - "\n" + "aux_paramnames, aux_log_likelihood, aux_prior_transform, vectorized = warmstart_from_similar_file(\n", + " posterior_upoints_file, parameters, log_likelihood_with_background, prior_transform)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In a good run, most auxiliary weights should be small (<1). If they are not, you may need to increase the enlargement_factor." + "Make accelerated run:" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.hist(aux_results['samples'][:,-1], bins=40)\n", - "plt.xlabel(\"ln(weights)\");" + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ultranest] Sampling 400 live points from prior ...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cd5bbe64da7e46a294ae91464f7034bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value=''), GridspecLayout(children=(HTML(value=\"
&nb…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ultranest] Explored until L=2e+02 8 [169.3705..169.3741]*| it/evals=1560/4757 eff=35.8045% N=400 \n", + "[ultranest] Likelihood function evaluations: 4808\n", + "[ultranest] logZ = 166.7 +- 0.04882\n", + "[ultranest] Effective samples strategy satisfied (ESS = 867.2, need >400)\n", + "[ultranest] Posterior uncertainty strategy is satisfied (KL: 0.46+-0.07 nat, need <0.50 nat)\n", + "[ultranest] Evidency uncertainty strategy is satisfied (dlogz=0.41, need <0.5)\n", + "[ultranest] logZ error budget: single: 0.07 bs:0.05 tail:0.41 total:0.41 required:<0.50\n", + "[ultranest] done iterating.\n" + ] + } + ], + "source": [ + "sampler = ReactiveNestedSampler(aux_paramnames, aux_log_likelihood, aux_prior_transform, vectorized=vectorized)\n", + "res = sampler.run(frac_remain=0.5)" ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl4AAAFHCAYAAABwEEJIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB+BElEQVR4nOzdd3zUVb7/8deZmUwyyaT3Xggl9BI60rGggg1sK2Bj1e177/Z777r7u3d3ddddd13LIq51LWBDBAEXkN5C7xBCeu9lJpl2fn9MjKKCUUkmgc/z8fg+SOY7M9/PmeEhb88533OU1hohhBBCCNH1DL4uQAghhBDiciHBSwghhBCim0jwEkIIIYToJhK8hBBCCCG6iQQvIYQQQohuIsFLCCGEEKKb9IrgpZRKUkrtV0r9+mu89qdKqePtxwmllEcpNbEr6hRCCCGEuJAeH7yUUg8B+4FBX+f1WutHtdZZWuss4L+AXcCOi1iiEEIIIUSn9PjgpbV+SmsdDWz7+DGl1CilVI5SqkAp9YZSKvTL3kcpFQ48BtyntfZ0YclCCCGEEF+oxwev83gT+D2QAbQAv1FKGZVS/p85/D71mkeA17TWR31RsBBCCCFErwteSqloIA34HXAEmAr0BxYBrZ85/tn+mjDgro9/F0IIIYTwBZOvC/gaqoFy4Mda61VKqbmAW2v9PvDceV5zDVCutT7VXUUKIYQQQnxWr+vx0t5dvW8Ffq+UOgncj3fC/IUMAU50dW1CCCGEEBeivDlGCCGEEEJ0tV7X4yW+OqXUYl/XIL4Z+Q57P/kOezf5/nq/nvIdSvC6PPSIv2ziG5HvsPeT77B3k++v9+sR32GPnlwfFRWl09LSfF1GrxcYGEh2draMKfdi8h32fvId9m7y/fV+3fEd7t27t7p97dHz6rLgpZRKAlYC72qtf/OZcxOAJ4Ag4HWt9cNf9B5paWnk5OR0VYmXjezsbPkcezn5Dns/+Q57N/n+er/u+A6VUgVf9pwuGWq80DY/SikFvIZ3+56RwCKl1PSuqEN4LV7cI3pXxTcg32HvJ99h7ybfX+/XU77DLr2rUSm1Efjo0z1eSqkBwDEgSGttV0q9AeRprX/x2ddnZ2dr+T8MIYQQQvQGSqm9WuvsCz3HF5PrI4BarbW9/fdiIPLTT1BKLVZK5Rw/fpzs7GyWLFnS7UUKIYQQQnTGkiVLyM7OBshq30v6vN1rvujxygKOcm6P11mt9c8/+3rp8RJCCCFEb9FTe7xOAEXAVKWUBRgLfOiDOoQQQgghulW3LSehlHoRKNFa/1IpdTvwd7x3Nb6otV7fXXUIIYQQQvhKlwYvrfW0T/288FM/b8d7R6MQQgghxGVDVq4XQgghhOgmEryEEEIIIbqJBC8hhBBCiG4iwesyp7Vm+/btPPvss7jdbl+XI4QQQlzSevQm2aJrOZ1Oli9fzgcffABATEwMc+fO9XFVQgghxKVLgtdlqqGhgWeeeYZjx46RlpaG1pq33nqLPn36MHjwYF+XJ4QQQlySZKjxMlRQUMBvfvMbcnNzSUtLw2g0YjKZiI6O5qmnnqKmpsbXJQohhBCXJAlelxGtNbt27eK3v/0tLpeLxMRElFId54ODg3G73Tz99NM4nU4fViqEEEJcmiR4XSZcLhfLly/nySefJCoqioiIiC98XlxcHKdPn+btt9/u5gqFEEKIS58Er8tAU1MTjz/+OO+//z4pKSlYLJaOc1prDh06RH19PQBKKVJSUli1ahX79u3zUcVCCCHEpUmC1yWuqKiI3/zmN5w4cYL09HRMpk/up3A4HCxfvpx33nmHV155hdbWVgCMRiOxsbH84x//oKKiwlelCyGEEJccCV6XsJycHH7zm9/Q1tZGUlLSOfO56uvr+ec//8mJEycYPXo0tbW1vPvuu2itAQgKCsJgMPDkk0/S1tbmqyYIIYQQlxQJXpcgt9vN22+/zV//+lciIiKIjIw853xBQQHPPvssDQ0N3HnnncyePZsrr7ySkydPsnXr1o7nxcbGUlhYyOuvv94RyIQQQgjx9ck6XpeY5uZmnn32Wfbv309qauo5Q4sAe/fuZfXq1YSHh3P77bd3hLKxY8dSUlLChg0bSEhIoE+fPgCkpKSwfv16+vbty4QJE7q9PUIIIcSlRHq8LiElJSX89re/5ciRI5+bz+V2u1m9ejXvv/8+GRkZ3Hfffef0hCmluP7664mJieGtt96irq4OAIPBQHx8PP/85z8pLi7u9jYJIYQQlxIJXpeI/fv38/DDD2Oz2UhOTj5nPpfNZuOVV15hz549TJgwgdtvv52AgIDPvYfZbObWW2/F4/GwbNmyjrW8LBYL/v7+PPnkk9hstm5rkxBCCHGpkeDVy7ndbt59913+/Oc/ExYWRlRU1DnnKysrefbZZykqKuKGG25g1qxZGAzn/9ojIiK46aabKC8vZ9WqVR1zu6Kjo6moqODll1+W+V5CCCHE1yTBqxdraWnhySef5O233yY1NZWgoKBzzp88eZLnnnsOl8vFokWLGDZs2Be+j9Yaj8fT8Xu/fv2YMmUKBw8eJCcnp+PxpKQktm7dyqZNm7qmQUIIIcQlTibX91JlZWX87W9/o7KykvT09HOGFrXWbN26tWOi/K233kpISMgXvo/2uDHU7yXU1EiF/yT8/b1DkFOmTKG0tJQ1a9YQFxdHcnIyBoOBpKQkXnrpJdLS0khLS+uOpgohhBCXDOnx6oUOHjzIr3/9axobGz83n8vpdPL222+zYcMGhgwZwqJFi84buqxUMsTwHndk1zN/gj/Btn0dPV9KKW688UZCQ0NZtmwZzc3NAPj7+2O1WnniiSc6HhNCCCFE50jw6kU8Hg/vv/8+jz32GCEhIURHR59zvrGxkeeff54jR44wY8YMbrzxRvz8/D73PgEGO4MCdjEmcA2jBiWSOXQm8X1GMy/bTnPF0Y45XBaLhVtvvZW2tjaWL1+O2+0GvPPAPl6A9dNDlEIIIYS4MAlevYTNZuPpp59m2bJlJCcnY7VazzlfVFTEkiVLqKmp4fbbb2fSpEnn9IQBGHHTx5LL5JDVxBjPkDF4Kun9x6AMBpQxgIx+Q5k/vJLq8oKO18TGxnL99ddTWFjIunXrOh5PSkpiz5495zwmhBBCiAuTOV69QHl5OU888QRlZWWfm88FcODAAd5//31CQkJYuHDh53rCQBNrrmRoyEEMzloa2wIZPXYaERER5zzLaIlm5KA0iuuL2FwWTESEd52vIUOGUFJSwq5du0hMTGTo0KEopUhOTub111+nT58+9O3btys/AiGEEOKSID1ePdyRI0d4+OGHqaurIyUl5ZzQ5fF4WLt2LStWrCAlJYX777//c6Er2NjE+LAdjA/fhq25kRaimDh5+udC18fMoRlcnR1Ksjn3nDW7Zs2aRWpqKitXrqS8vNz7XLOZ8PBwnnjiCRoaGrqg9UIIIcSlRYJXD+XxeFi9ejWPPvooQUFBxMTEnHO+tbWVV199lZ07dzJmzBjuvPNOLBZLx3k/5WCg9SjTo9YT7lfN2SqwhMZxxRVXYA361DBlWzUULofGE97flcIa1Z9FU0y46k/jcrkAMBqN3HLLLVgsFpYtW4bdbgcgNDQUu93Os88+2zEHTAghhBBfTIJXD/Xee+/x2muvkZSURHBw8DnnqqurWbp0KWfPnuW6667jmmuuwWg0AqDwkBxQyKyoD8kMPE19WxDF1S7S0tIZP248/mZ/75toN1RuoejwezxzeDJ7j5xm8KYRPJw3CIz+RMel8+AMNxUlZzom21utVubNm0dDQwNvv/12x+MJCQkcOnSI999/v/s+ICGEEKIXkuDVQ23dupX4+HjMZvM5j+fm5rJ06VLsdjsLFixg1KhRHeci/GqYErGJUaF7cWozNa1B1DU0MXjQYIYPH94RzrCXwplnoXIDoWExFHsSSQwq5kj8PTycutf7HP8I+qREced4J8VFhR3XSE5O5uqrryY3N5ePPvoIoGO+11tvvcWRI0e69HMRQgghejMJXj1QfX091dXV5wwdaq3ZsWMHr776KmFhYdx///2kpqYCYDHYGBmSw+SILViMdupd4TTZ3dhsNsaOGUu/fv1QKPA4oXwdpw99xJriMZByKyGZ17E1YSL/5/kVrtZGGvPWQntPliEwmUkDzEzo00ZFRUVHLdnZ2QwfPpzNmzdz8uRJAPz8/IiOjuapp56ipqamGz8tIYQQoveQ4NUDFRQUoJTqmEjvcrlYsWIF69atY8CAAdxzzz2EhYVhVC4yg04xM+rfJASUUu8Kxe4JpLm5GbfbzRWTriAxMdH7ps1nIfdpqN5BmRpJnmsErZYB3nNKcVgP5fXa7/LqqXF4qrZ2PG4KTuWOCR6iAhppbGxsf1gxe/Zs4uPjeeeddzqCVnBwMG63m6effrpjg20hhBBCfEKCVw904sSJjmHBpqYmXnzxRQ4ePMiUKVOYN28eZrMfcf6lzIhczyDrMWzuIJrdIWgNDQ0NBAQEMHXKVO+di247lLzHscN7KLbFQ9pCJmYPYPE0RcBn1lYdnxXC1OQzGCo3QvMZ74NGfyzBsfxwth8t9eW0tbUB3h6u+fPnYzAYWLZsGQ6HA4C4uDhOnz7N22+/3W2flxBCCNFbSPDqgQ4ePEhYWBilpaU8++yzVFRUMG/ePKZOnUqoXxMTw7cxPnwXKGhwheHGiNaa+vp6oqKimHzFZO+G2Q3H4fRTOGuOsK52DjsdN4M1DaMBTMbPX7dPrGLAoGzwj8Kevwoc7UtEmMOJDDby4xvDKSku6litPiwsjJtvvpmqqipWrlyJ1hqlFCkpKbz//vvs37+/Gz81IYQQoueT4NXD/HJTMb+P+RaPVcbx7Asv4TD6c8899zB8UB8GWw8xPXIDoaZ66pxhODzeOxTdbjf19fWkp6czbtw4zKoNXbCMUyf24zEG49f3bhZMCeDG7E583UYzhdY7efzMA5w5tg083uUksCTRL7KRb82MpbCwsOOOxj59+jB9+nSOHDnCzp07vW9hNBIXF8czzzxzztwwIYQQ4nInwauHuTOqgbC9b8LLPyElPpbv37eAcemtzIr+kIygszS4QrB5rIB3/pfT6aShoYFBgwYxbOhQjPUH4fRT5FU4ea30To763weWeCKsYOzktx0XHcqgOBuxHIeyD7wPKoWyJDMjs4qxAyMpLS3teP7EiRMZMGAAH374Ifn5+QAEBQVhMBh46qmnOoYnhRBCiMudBK8e5tSpU7Qd347BEsyP7pnNdSm7GR6ynzaPP42uUPSnvrLW1lbvnYtjx9IvJQrOvkx9wRYIiCVj6NXMG6MZlPwlX7HHCe5W71wwj3dCvNkEc8aGYY0bhq7dh7u6fcjQaMboH8Hdk2xEBJuora0FvJPtb7jhBiIiInjzzTc7JuHHxsZSUFDA66+/3tFDdiEP76hEPX6s43h4R+XX+ASFEEKInkuCVw9z8OBBnPlHCMwYxNSY7ZgNDupd4bj0uTPhm5ub8Xg8TJ40iURzAeQ+zdrCgTxb8h3siQtRAZEMTASDOs+FwLtqvb0E/KMhIAZshaA9Had1zHRW1NzFO/v90bb2Hi5zGAEGJz+7JRpbS3PHtkL+/v7ceuutOJ1Oli1b1rHifUpKCv/+97/ZtWvXl7b94fExTEkMZEpiIPqHA3l4fMyXvkYIIYToTSR49SB2u50TJ07gqikhpE9/mt1WWj2Wc56jte64c3Ha2CzCat7CXbYBrH0YMSSLqQNNBJgvlLbw9my1nAW/UBj6G/CPBHMkxEwBW1HHOl7KYCAmPokYSx0ULgNX+96NlkQiyOcn3xpKWVlZR8iKjo5m7ty5lJSUsGbNGgAMBgMJCQksXbqUkpKSi/uBCSGEEL2MBK8epLCwsGMD6pDMLFzadM75j+9cjImOYFqWB3PJv3jxzDWsdzwAKbcSG2lldAaoC/Zy1Xh7uZJugCG/hqDUT86l3wXWDGgt73hoQn8zk0emodzN6KK3vT1iSkFgEv0D9vOtuWPPmWw/cOBAJk6cyN69ezvuarRYLPj7+/P3v/+9Y49HIYQQ4nIkwasHyc3Npby8HIN/IIGJaXw8gR68dy7W1dUxOD2EcZEHMNbuwBg+hMSEOGKior4kbeG9O7ElH/ys3sCVfCMYz92OCKM/9P8umCzgqPvk8cBEKoJv4tnjM6gtbB8yNJjBL4JZqaeYMHoQxcXFHU+fPn06GRkZrFq1qmMSfnR0NBUVFbz88sudmu8lhBBCXIokePUgBw4coKqqisD0AWD8pLfL6XRia6pjen87ke6jvHT2Rmqi74akucwa6sfw1Au8KUBbLdiLIPE6GPIwWNPP/1xzOPT/IbiaPxlaBMwRWXgMQbRVHYLGk+0PhmLw2Ll7iof4uBgqK72T4Q0GAzfffDNWq5Vly5Z1zANLSkpi69atbNq06Wt8OkIIIUTvJ8Grh2hra+Po0aPU1tYSkpmFR3u/mtbWVoIpY3ZmPmGeXPwih9KoEmlQKV/+ph4XtBR4e7AG/w+k3OLt1foy1jTI/Da0lnWs4xVuVXx7loX4MAXF73jDHEBAAv7Nx/mPOwbh8XhoamoCIDAwkPnz59Pc3Mybb76Jx+PpmO/10ksvdSw7IYQQQlxOJHj1EMXFxR3zu4L7ZKFROGx1DA0/TVq4nU110yDjXoJTp/KdWYqML7vhz1HnvUsx/irvBPrgPl+toKgxkHxT+52O7ZPtjX7o5PlsrR3P9n0nweNon++VTHjDh/zk23Oorq7u2D4oISGBa6+9lrNnz7JhwwYAAgICsFqtPPHEEzQ3N3+1moQQQoheToJXD5GXl0d5eTlmPyOByenMNq9nWuIx4gPrOc2V7G8cRbMhCfiSJSI8brAVgMEPBv83pN0GxoCvV1TSXIgc6x2m/Jg5jHLDKMpbrOji972hzOAH5gj6uD7g7jtvpLi4uGNboREjRjBq1Ci2bdvGsWPHAIiIiKChoYHnn3++43lCCCHE5UCCVw/x8fyugWmhXBO0m4cC3qFUD0RlPsCEEek8NBOsX5afHPVgL4C4WTD0/0FI329WlDJAn3vAkthxp6NScMNYKzcOqUM1HobaPd7nmkPB3cqUpNPMmD71nDsdr776ahITE1mxYgVVVVUAJCYmsmfPHtatW/fNahRCCCF6EQlePYDT6eTw4cNUV1cztp+ZMeoIr5fexqamGyAgGqMBLOYLvIF2Q0shGAww8JeQdod3XtfFYLJA/++DMnZsmm0ygoq5gpaAIaw8YMLR2H5HoyUBVX+YO6aG0bdvX8rKyrzPN5mYP38+fn5+vPHGG7S1taGUIikpiddff53Tp09fnFqFEEKIHq7LgpdS6mGl1Aml1F6l1ITPnPu+UqpYKVWilPp9V9XQW5SUlHQsu5DdN4gpQbvIjD/IrWO/ZIkI8IahlgKImwZD/xdCB1z8AgOi2+90rPduLwSgFBXW6zjcPISy3G3gbO6Y7+VXtoLvLZxFYGBgx7ZCISEh3HLLLdTW1vLuu++itcZsNhMeHs7f//53GhoaLn7dQgghRA/TJcFLKTUDWASMBP4HeE0p70JTSikr8BfgJmAM8J9KqayuqKO3OHv2LOXl5ZiMBsZkKsIMzexnJP5+F3iR9ngnvisNg37uXfzUFPiVrvtoTjUbi1rOeWxjUQuP5lR//skhfSHjHu/iqx43ABlxZn44tZZU/1woetPb82bwA3MkIWUv8ePv3k1LS0vHchJpaWnMmjWLEydOsG3bNgBCQ0Ox2Ww8++yzuN3ur1S/EEII0dt0VY/XLGCH1toGbASSgX7t59qAeiAICATcQN0XvMdl4+DBg1RVVZGVFgyGAP5R+G1OtQ08/wucjd7FUKMnw7D/g9ALPPcCRsdamL+6mLo2b+DZWNTC/NXFjI49zzBl9CRImA32T+50DAyNhcTrOV3lx5kT7Ztp+4WAx0GKYw3fXnzvOdsKjRs3jkGDBrFhwwbOnDkDeO9+PHToEO+///7XaocQQgjRW3RV8IoASgDaw1cdENn+uxP4E/Bv4AjwAlDx6RcrpRYrpXKOHz9OdnY2S5Ys6aIyfc/tdncEr7H9AvAztOFRUOf3BetFaE/7XoouyPoJZCwEU9DXvva05CCWzU7ieG0bZxsdzF9dzLLZSUxLPs97KgUp8yBsGLR+su+iJ3QoG+qvZ1tBJLr+qPfBgHioP8aYhEpuuOGGjsn2SinmzJlDdHQ0b731FvX19SilSE5O5u2336bF1vLF1xZCCCF6qCVLlpCdnQ2QpZTKUUotPt9zuyp41QGJAEqpQCAcqG3/PRv4OZABxAPTgVs+/WKt9RKtdXZWVhY5OTksXnze+nu9srIySkpK0Fozum8g/ay5BEeV0+r3mV4nZ1N7L9d4GPY7CB/y5dsEdcK05CDig0wUNrl4cGj4+UPXxwwmyFzs3VS7zXuHokHB7ZOCuL3PJlTpCmit7JjvRdHb3DCtH9nZ2R3bCpnNZubPn4/H42HZsmU4nU52WwdjSxxCaUkpTpcTuMCwpxBCCNGDLF68mJycHIDjWutsrfV5e4y6KnitA8YppSzAVKAIaN9nhhDAAzQDNsAFhHVRHT1efn4+5eXlGA2K431uZqNjDPv0qI7zG2ujeDQ3zrtY6YD/gIx7vfstXiQbi1ooa3GREmzi6UN1n5vz9YX8rDDgh96eN6d3pfqQICN+aTfhJoB9B4+gXW3ekOYfjfHMM9x7143ExHyyrVBkZCQ33XQTZWVlrFq1inhXLaujptOqzJSWlvLh2YYLD3sKIYQQvVCXBC+t9XrgJeAA8L/A7cALSqnfaa03AE8CB4FcYCfwYlfU0RscOnSIqqoqBqRYGWAoYW7dU+S0DgNgY7WV+UfGMTo+DIb/DiKGXZRero99PKcrK8Kf9BAzy2YnMX91cefClyUe+n0f2qrB7V2pHr8QjvgtYGXpDApObvPOA/MLBo+ToNJX+MH3vnPOtkL9+vVj8uTJHDx4kJqdq7nFtoP6gEiqXGZueb/wwsOeQgghRC/UZctJaK1/rbXur7UeqbXerrVeqLX+Zfu5/9JaJ7Uf92itHV1VR0/m8Xi8C6dWVpLdN4Ar/bfyE/0KO93pnLUFMP/YNJZNMzFt3K3eAHOR7amws2x2EuH+RuCTOV97Kuyde4OwQd67Ke3F3vlnwNDMKO4eepg0vQWqt3ufFxAPjSeIc+3m+9///jnbCk2dOpW+ffuyZs0aTGf3EazttPiHklG6mwGmxoveZiGEEMKXZAFVH6qsrKSwsBC3x8PELAtpgUXcF/U+8eZWCh0hPDgklGmDhl/UXq5P+2l21Od6lKYlB/HT7KjOv0ncDIid3rGno1KQkjEIQgZSXXSAusoib/2WZCh+l4Hxbu666y6KiorweDwopbjxxhsJDQ3ltZwzNOFPqKeFE5HD+e+X3pcthYQQQlxSJHj5UEFBAeXl5RgUjO1rotEVwi7zNZQ5LKSYm3j6hLtzw36+pJR3pfzgftBa1vGYO34Or5QuYOV+j3eR1/b5Xpx+ihmThjN9+vSOOx0tFgsTF/0Y+7z/xfju7wl1NjDPvpNXDCP42we7fNs+IYQQ4iKS4OVDhw8fpqqqir5JgbSqCH5Q9Hvur1pAlqWG9GD91eZc+ZLRDP2+451031bjfcjPnxtHeZgbtxKKloPH5R0u1R5U7hLuvH3+OdsKtUb3YdKZd3BueZ26Vf8gw13FDY1beG3r4Y7V74UQQojeToKXj2it2b9/P5WVFWT3DSQtMB+TtY7XB+0k3NgKJutXn3PlS+ZQ6P8j8LSCyxsUU+NDCU2bgbaVUH7m4/lecdB4EnPlBzz00EMEBgZSV1fHxLaTzEgNJnjijTRteZOzZ88ywNjA0Oo9/Otf/+rYcFsIIYTozSR4+UhNTQ35+fm4XG6mDfYnxr+a/wp7lSujKgENxgDga8y58qWgZOj7ELRWgMe7FhehWezzzGPJkSsoKTj1yfpexe8RThE//OEPaW5uxm73hsuw2YsxRSXy3nvv4XA4SEhIYM+ePezbt8+HDRNCCCEuDglePlJQUNAxzDYq0588WwYqdAC4msHoD8rk4wq/pogRkDq/fYV978T4IQMHcGXiHuKb3gR7Wft8rxg4/TRpcVYWL15MaWkpLpcLgzmAyHk/pb6+nvXr16OUIiYmhueff75jGQohhBCit5Lg5SPHjh2jqrKSzAQLNhXDyyULaDOng7MeTBd/6YhulTAboieCvQgAs5+BcSMHYTBZaD27AkervX0RWA2nn2bs6JEd2wqhISBjKGPGjGH37t0UFBRgtVqx2+28+eabvm2XEEII8Q1J8PIBrTV79+6lsrKCUf0CGRZykFnh75GRGAhoMAX6usRvRhm8+0gGpXl7uABMQbgS57E0bx6rdpZ7F1f1j4XmM95thW64gVGjRtHW1gbAjBkzCAsL47333sPpdJKYmMhHH33E8ePHfdcuIYQQ4huS4OUDDQ0N5Obm4nC6uGa4mSCTnZhgFya0N7S0z+/q1YwB0O97YDCDox4AU3ASY9OaGRW0ESo3fbK+V8n7GBsOc9999+Fn9sPpcGI2m5kzZw61tbVs3LgRg8FAeHg4S5cupbW11bdtE0IIIb4mCV4+8PH6XQBD0oPYXT8aHTrYO8wYksUl87X4R0DWj8DVCG7v5PnRg1JIiY+Aqk201Z0GgxECYiH3GYKMNpISk9Ba09LSQnp6OqNGjWLnzp0UFxcTFhZGbW0tK1eu9HHDhBBCiK/nEvkXvnc5ceIEVZUVpMb602qI5oOqazFb470T6yOyfV3exWXNgD73e4ccPS5vL1fCtRxuncQTWxKpq6sHU/um36efwmw2ER8fT0VFBR6Ph1mzZhEcHMyKFStwuVwkJiayatUq8vPzfdkqIYQQ4muR4OUD+/bto6KygvEDghgbvpMbol4mKSYQUBCc6evyLr6ocZA0t2NbIQx+JPbJpk/QWQIr3/IuPeEfC8150FpNcHAw48ePp7S0FH9/f66//nqqq6vZtGkTJpMJq9XK0qVLcTqdvm6ZEEII8ZVI8OpmTU1NHD9+nLY2J9eNNGJUGn9LGEbt9E6qt8T7usSLTylIugEis70bagMR4aHcOMaMv7MYT8n7aA1YUsBRA64m7rzzTgICAmhqaiIzM5Phw4ezbds2SktLiYqKoqioiHXr1vm0WUIIIcRXJcGrmxUUFFBRUQFAZloUqytn4wkZBI46iBjlnVx/KTIYoc993pXrW73tJ7gvjshp/OvYMLYfKvY+x2AGexkh5jbuu+8+qqqq8Hg8XHnllQQFBbFixQrcbjeJiYm8/fbbHWuhCSGEEL3BJfqvfM916tQpKivKSIw0YzAFsb9xOOERkeBxQPgwX5fXtUyBMOAH3p+djQD4xV6B1d9AoO2Ad9FVZfSez/snw4YMZvLkyRQXF2OxWLjuuuuorKxky5YtmM1m/Pz8eOGFF/B4PL5pjxBCCPEVSfDqZt79GSuZMiSQ7NAcbox8kdiIIEB7J6Jf6gJiYMAPwVEL7jaUQXHjpFhGROZB4XLCdY2316v+GKpqE7fddhvBwcE0NjbSv39/hgwZwpYtW6ioqCA2NpYTJ06wefNmX7dKCCGE6BQJXt3IZrNx+PBhbPY2bhhtRCnwBCRhcNvAkgDmMF+X2D1C+kPGIu98L+0GkwVSbuVsUywzqzbi53F4P4/8V7Eam1i8eDHV1dW43W6uvvpqLBYLK1aswOPxEBcXx2uvvUZNTY2vWyWEEEJ8KQle3aiwsJCKCu/6XQkJibxUfBeEDARng3fi+eUkZgrEXw0t7Xc6WuJwR4zH6HazQL3k3a/SYIbcZxmU1Z+ZM2dSXFxMYGAgs2fPpqysjO3bt2OxWPB4PLzyyitorX3dKiGEEOKCJHh1o9zcXKory4gNMxEc4KbRGUxsdCjggdCBvi6veynl3Uw7bDDYSwB4RV2PJ6qOu/z/xawtSTxcOg2azkDZWm655RbCw8Opr69n4MCBDBw4kE2bNlFVVUVCQgJ79+5l7969Pm6UEEIIcWHnDV5KqWlfdnRnoZeC/fv3U1FRyexsC0NDjjIlZCWRYe3rdwWl+aSmh3dUsqnExqYSG+rxYzy8o7L7Lm7wg74PgDkc2qp5OOMoD43ug8svhp/rt/hB1D4ITITCNwnUNXz729+mtrYWt9vN7NmzMZvNrFixAq01MTExvPDCCzQ1NXVf/UIIIcRXdKEerzXAUuC58xwfdHl1l5C2tjYOHjxIU0sr148yoTW4LakYnE0QMsA7tOYDD4+PQf9wYMfx8PiY7i3ALxgG/Mi7iKqrGQx+tETfxJ664Zw8dRKUH5iCIPcf9M9M55prrqG4uJigoCCuueYaSkpK2LlzJ1arFbvdzvLly7u3fiGEEOIruFDwOqO17qO1zviiA8jrriIvBUVFRR1rToXHZfL42R9hDOkHribv+l2Xs8AE6PcdaK0Ej4PQiFi+M2o/4wLehYYj4B8FtmIoXcWNN95ITEwMtbW1DB48mP79+7Nx40ZqampITEzko48+4tixY75ukRBCCPGFLhS8hgEopd5XSt2klPL7ovOic/Ly8qipLCY6xEhSUA2RfuUkxYZ45zqF9Ot4nk+H/nwpfCik3ekNWNpDcOIYsCRRm7+NypomsCRB8QoCXKUsXryYhoYG3G431157LSaTiffeew+lFJGRkTz33HPY7XZft0gIIYT4nPMGL631xxvhbQJ+BZQqpR5XSg39zHnRCd75XVXMmxhAZlAegwN2EBpsBmOgd+mEdj4f+vOl+Cshdop3T0cUOvFGXi2Zx8qcVjRGMIXA6X/QJy2ROXPmUFxcTHBwMFdddRWFhYXs3r2b0NBQamtrWblypa9bI4QQQnzOl97VqLX+o9Z6FDAFyAb2K6W2KaXGdnl1lwin08m+ffuob7Jz9UgLbR4zOjANg7MBwodfutsEfVVKQdpdYO0DbeWogAhuGFTFLTH/QtXuBP8I73Bk0Ttcf/31JCYmUl1dzbBhw8jMzGT9+vXU1dWRmJjI6tWrOXv2rK9bJIQQQpzjS//FV0qNVEr9Gfg3EIO39+td4K2uLe3SUVJSQnmZd8mEwKh+PHrmZ/iHZ4CnDSJG+Li6HsZohr7f9q7t5bKRlNqf0IhYqFhPS0OVd8ix9APMrWe5//77aW5uxuVycd1116GU4r333sNoNBIcHMzSpUtxOqVjVgghRM/Rma6WLUAUcJvWup/W+g9a6z8Csk9LJ308vysu3MDAkDMMDtxDUnSw9+TlsE3QVxUQA33uhdZyQEPi9Wysmc4zm4OwOzSYI+D0P0hLiuGmm26iuLiY0NBQrrzySvLz89m7dy+RkZEUFxezbt06X7dGCCGE6NCZ4JWgtV6gtT4naGmt7+iimi45hw4doqKiijuuCCA+oIJ402lCggxgifOuYSU+L3IMxEz2bitkspLVJ4FRIXsw127ybq3krIeCZVxz9dWkpqZSWVnJyJEjSU9P58MPP6ShoYHExETeeustSktLfd0aIYQQArjwAqoepZQbqFVKuZVSLqVUnlJqdjfW1+u53W52795Ndb2NmcNDKG2Ng8BUDK4GiBjt6/J6LqUg7Q4wR4KjjrjENKZmNmCs3YpuLvAOOVasx6/lBIsXL6a1tRWn08mcOXPQWrNy5Ur8/Pzw9/fnhRdewO12+7pFQgghxAV7vKYC0z51zAJeAv7S9WVdOsrKyigvKwLAGNafZ4seIDgqFdCX3zZBX5UpEPo96N3L0uOAuKuocGeydEsA9c0u8I+B3GdJig1l3rx5lJSUEBoaysyZMzlz5gwHDhwgJiaGEydOsGXLFl+3RgghhLjgchKbP3NsBP4OxHdfeb1ffn4+dZXFpEQpxkfuZYJ1LYnRVkCBNc3X5fV81gxImedd38tgxj9pGk6PgeaSnd5V7902yP8Xs2bOJDMzk8rKSkaPHk1qaipr166lqamJhIQEXn31VWpqanzdGiGEEJe5Tq9joJR6ADgErO+6ci49Bw8epLyiioVTAwg2NROgawkJ0BDcD4wBvi6vd4i/GsIGQWs5YZEJPDjqMEmujdBwHCyJULUdU+MB7rvvPhwOBw6Hgzlz5uB2u1m1ahX+/t7tmF5++WW01j5ujBBCiMvZheZ43f6Zh3LxLiVx+3nOi8/weDzs2bOH8poWJg6N5mDjEFRwKgZPC0Rk+7q83sNghD73eed9uVpQMVPQ/vHsOlJKWU0rBMTCmX8SHxnA7bffTklJCeHh4UyfPp1Tp05x+PBh4uPj2bdvHzk5Ob5ujRBCiMvYhXq8fq+UmqqUmqaUmga4gXxgfPvvv++OAnuziooKSou8W1p6rP1YUXEDMdHxoDlnmyDRCf6R0GcxtFaAgra4m9hWM4YDJ4q8q/97XJD3EtOmTiUrK4uKigrGjh1LUlISa9asoaWlhdjYWF544QUaGxt93RohhBCXqQsFLw38E3juPIeny6vr5QoKCqirKiYrUXFVzAamhbxDTGQgmAIgMNHX5fU+ESMgbgbYSwgIjuLeUblcHfo61O31brtUuxdj7S7uvfde3G43DoeDuXPn4nA4WL16NYGBgbS2trJs2TIZchRCCOETF5pcn661zrjQ0Z2F9kaHDx+mrKKKBVPMGJQHp9NDiL8bwobLNkFfh1KQMt+7wGpbDaEJw1HWDGzFWyitbISAeDj7IjEhBu68805KS0uJjIxk6tSpHD9+nGPHjpGYmMjmzZs5fvy4r1sjhBDiMiT/+ncRrTV79uympLKZkYNSWV81Db+QZAzaIdsEfRMmC/R9CFzN3iUmkubyZtlNLN9jxK38AQV5/2TyFZMYOnQoZWVlTJgwgYSEBFavXo3dbicyMpKlS5dit9t93RohhBCXGQleXaS6uprSgpMYFJis8exqGEd8bDQovJtAi68vKAXS7gR7CZiCuWqwk1vj/4WxZgsExEH9EQxVm7n77rtRStHa2sqcOXNobW1lzZo1hIaGUldXx4oVK3zdEiGEEJeZzmySfYtSyq87irmUFBQUUFtVwthMmB61ienWZUSHWbyLfso2Qd9c3HQIHwb2UmITM4mLiYbKTdgby7zzvfJfJTLQyYIFCygvLycmJobJkydz5MgRTpw4QWJiIh988AF5eXm+bokQQojLSGd6vB4GypRSf1VKDe/aci4dR48epay8kjsmmQGob7NgDXBB5GjvXCXxzSiDdyNtoz84myBhNvubx/G3jyKptxvA4Ae5S5kwbgzZ2dmUlJQwadIkYmNjWbVqFU6nk5CQEJ577jmcTqevWyOEEOIy8aXBS2s9GO+WQS3AW0qp/Uqp+5RSxi6vrpfSWpOzZzeF5c307TeQN0rnERiWhBFkm6CLyRwGmd+GtipQfqT3yWJI8EEC6zZ4exabTqHK/81dd92Fn58fra2tzJ07l5aWFtauXUtkZCQlJSWsXbvW1y0RQghxmejsHC8FmAB/IAD4HvBBVxXV29XX11OUdwh/PwgJNlPRFkNiXKS3pyso3dflXVrCh0DCNWAvIiw6mdlZdZgbdkFzLgQmQeFyws3N3HPPPVRUVBAbG8ukSZM4ePAgp0+fJiEhgbfffpvS0lJft0QIIcRloDNzvI4A24BI4FatdRYwAhjetaX1XgUFBdRXlTJlAIwP383ogA+IDvWD4L7eu/LExZV8EwQmQ2sVxM6g0ZDGS9v9Kav1gNECuUvIHjGU8ePHU1payuTJk4mOjmblypV4PB78/f355z//idvt9nVLhBBCXOI60+P1NyBBa32v1nqbUipda+0BhnRxbb3WiRMnKC2vZN4EPzxaUdtmJShAyzZBXcXoD30fAE8raBemxKtpcgXSWJoD/lFgK0KVfcCdd95JQEBAx5Bjc3MzH374ITExMZw6dYotW7b4uiVCCCEucRfaqzFUKZUO/ASIVEqlK6UGAFsAtNYVF3pjpdTDSqkTSqm9SqkJnznXRyn1kVLqpFLqeaVU0EVoS4+xd89O8kqbiU0fwz8Kvk1IRDxGg0G2CepKgYmQfhfYSwkMieHB0Sfpb1gP9Ye8G2kXv0uIoZr77ruPyspK4uPjGT9+PPv27ePs2bMkJCTw6quvUl1d7euWCCGEuIRdqMfrB8AZoA+Q1/7zEWDfl72pUmoGsAgYCfwP8JpS59zKtxz4f0AW3q2HrvgatfdIjY2NFJzeS3gQpIQ0YlENJMWGg8HfGwBE14mZ7L1r1F6CIXo8BKZw/NQZ8srbwBQCp//BsMH9mTx5MiUlJUydOpXIyEjee+89Pv7r+corr8h2QkIIIbrMhbYM+q3W2gCs11ob2g+T1npOJ953FrBDa20DNgLJQD8ApVQG3mHKO4CTgAPY8A3b0WMUFhZSX1XCzEEwJOQw6aYcIkKM3jWnDHIjaJdSBshYCKZAcDXjTriRjdWT2XW8znsHZGslqngFt912G1arFbvdzpw5c2hoaGD9+vXEx8ezb98+9uzZ4+uWCCGEuERdaKjxpvYfX1NK3f3poxPvGwGUALSHrzq8k/MB4vDeIbkPmAxMBc55T6XUYqVUzvHjx8nOzmbJkiVfpU0+derUKUrKqrhhrIU2t4kGRxDWACOEj/R1aZcHvxDo+yC0VWM0W7lzZAXzY16A6h3eHsfS1Vg9JSxevJjq6moSExMZO3Yse/bsoaCggNjYWF588UUaGxt93RIhhBC9xJIlS8jOzgbIUkrlKKUWn++5Fxpq/Lhn61vAXZ86vtWJGuqARAClVCAQDtS2n2to//NVrXUZ3t6uoZ9+sdZ6idY6Oysri5ycHBYvPm/9Pc7+vTvILWkmMGkij+f/mPCIKO/8rmDZJqjbhGZB0lywFxMaNxBjaH+c5ZsprmgAcwTk/oNB/dOZMWMGJSUlTJ8+nfDwcN577z3MZjOtra288cYbMuQohBCiUxYvXkxOTg7Aca11ttb6vD1GFxpqXNT+53RgLt4g9hhwXSdqWAeMU0pZ8PZoFeEdVgQ4AVQA1yqlTMBE4GAn3rPHs9lsnD2+k+RIGBSWR7r5KMlx4d4768wRvi7v8pI0B6xp0FYJCdexuuo6XtkdTKu2Qls9FC5n3rx5hIWFYbPZmDNnDnV1dWzYsIHExES2bNnCsWPHfN0KIYQQl5jOrOP1B+CHwF+A54Cnv+w1Wuv1wEvAAeB/gduBF5RSv9Nau/HO7/o5cBrvkOPzX6/8nqWwsJC6qhJmDYaMwDwidB4RVgWR2bJNUHcz+EHmA+BxgVJMGWxlXtwbBNRu8C6sWr6ewLYzfPvb36a2tpbk5GSys7PZuXMnJSUlREZGsnTpUmw2m69bIoQQ4hLSmXW8rgX+AcwE0oBhnXljrfWvtdb9tdYjtdbbtdYLtda/bD+3QWs9WGudrrW+R2t9SWyWl5ubS0lpFdeMDqeqLRKb2x9rkAVCB/u6tMuTJQ4yFoG9jLDoVPokR0DNDtoaCr29kLlL6J+RwNVXX01xcTEzZ84kNDSUFStWEBgYSENDAytWrPB1K4QQQlxCOhO8XHhXqj8OBHZtOb3bob1bOVXcjCdqAkuKvk14RBQGgwGssk2Qz0RPgOjxYC+BuFnkOobzl03xlDX6g9sG+a9x0403Eh0djc1m4/rrr6empoZNmzaRkJDAmjVrOHPmjK9bIYQQ4hLRmeC1DVgNvAAsaf9ZfEZbWxu5R7YxKAkmRuxmSMAWUmKtYO3jXd5A+IZSkHYX+IWCy0ZixmgGBJ3AWr/Be5dj1VYCbMdYvHgx9fX1pKamMmLECLZv305FRQUhISE899xzOBwOX7dECCHEJeBLg5fW+rtAuNZ6GfBdrfWvur6s3qewsJD66mJmDYZo/yr8XLWEW40QMdrXpQk/K/R7CJx1WEKiuWFIHcH23dB4HAJiIe85MlOimDNnDsXFxVx55ZVYrVZWrFhBaGgopaWlrF271tetEEIIcQnozOT6G4ANSqkCYFf7n+IzzuTmUlxazeSRiRxtHIDDYybIapVtgnqK4ExIvhnsxRA9iVZzGm/uMZJbocDjhLMvcd2115KQkEBLSwvXXXcdVVVVbNmyhcTERN555x1KSkp83QohhBC9XGeGGh/Feyfjp9fyEp9x/MAW8spaaAoax/tVc4iODMNoCoDAZF+XJj6WMBuC+4OjGmPSddQ4wqkrPQL+8VCTg3/TPhYvXkxTUxPp6ekMHTqUrVu3UlNTg7+/P88//zxut9vXrRBCCNGLdSZ41QEva603f3x0dVG9jdPp5PSRrYxK08yJfZ9h/htIig2CsKGyTVBPYjBB5v2Axs9s4f4xhYy2fAB1ORAQD2dfJC3Oyk033URJSQlXX301FouFFStWEBkZyalTp9i8Wf76CyGE+Po6E7zOAP9WSv1WKfUbpdRvurqo3qa4uJj6ykJmDgaTwYHL6SDM6i/bBPVEAdGQcS+0lmOIGAnWTIrOHuN4iRO0hrwXuObqq0hJSaG5uZlrr72W8vJytm/fTkJCAq+++irV1dW+boUQQoheqjPBqxXIBZLwbnYtY2efkXcml4LSGoYP6ce22km4tYGgoCDZJqinihwNsVOgtQSdMIcNNdPZdMyJNsdA/SH8andw//33Y7fb6dOnD4MGDWLTpk00NjailOKll16S7YSEEEJ8LZ25q/Ee4K/ARuDn7b+LTzl9aBNl1S00+w8ip2EUsVEhGC3R3kU6Rc+jFKTeDuZIlHZy04g27k54FlW9GSwJkP8KyVF+3HLLLR1DjgEBAaxYsYLY2FgOHDjA7t27fd0KIYQQvVBn7mp8APgQ+D2wWCkly0l8itaaM0e2MiZDc0PsOww1f0hSdCBEyDZBPZop0LvEhKuR4KhU/CMH4Knc5t1I22CCM0u5cuYMMjMzaWlp4ZprrqG0tJSdO3cSGxvLiy++SGNjo69bIYQQopfpzFDjj4CBQCPwB+CWLq2ol6mrq6O67CwzB4PTY6TFYSIkOAjCZJugHs+aDim3epeYiLuaLQ0zeX53NLVtEdB4ClP1Ru69914cDgeZmZkMGDCAjRs3YrfbcTgcvP766zLkKIQQ4ivpTPAyAQ5AAxYgvEsr6mUqyss4W1JDav9sVlddCyjv/C5rhq9LE50Rf6V3L01nHWMGJzE3ZgXhTWvBkgQFy0gI83D77bdTWlrK7Nmz8fPzY8WKFcTFxbF161aOHj3q6xYIIYToRToTvP4BHMY7uX4v8FKXVtSLPLyjkoFroaTFD7dfJCda+5IQFYgxJFO2CeotDEbocx8oAxZrOEMzrKj6fTga88FogdwlTJsyiaysLJqbmzs21M7JySEqKoqlS5dis9l83QohhBC9RGcm1z8KLAD+H/B9rfX/dHlVvcTD42PoU72Xmen1XB29llFqNfFRVu9dc6L38I+AzMXQWgnRkynXA/nrliRya4OhpQBj+VruvfdePB4P/fr1o2/fvqxfvx6Xy0VDQwPvvvuur1sghBCilzhv8FJK/ffHBzAZ7zDj6PbfRbumE7uZORiaHWZsbjMhISEQ0t/XZYmvKnw4xM+EtnIiM6aQEXiW0MYNEJAIxe8QE9jCnXfeSVlZGddeey1Go5H33nuPxMRE1q5dS25urq9bIIQQohe4UI9X3/bjKuAhYCjwADClG+rqFVpbW3EUHMI/eSZvV96K0QBBwWGyTVBvpBSkzIeAOPxMBm4e3ki0aw80HAFTMOQuYfLEsQwdOpSWlhauvPJKCgoK2L9/P6GhoTz33HM4HA5ft0IIIUQPd97gpbVeoLVeALiAYVrreXjvbgzqruJ6usqKCgYZThLm34rH4yI+IgBj5HDvcgSi9zEGQN8HwWWDsBG4LRmsPeTiYLE/2MsxlK5k0aJFKKUYMGAAGRkZfPjhhxgMBsrKylizZo2vWyCEEKKH68zk+gy8+zUC+AEpXVdO71J49hiTE6qYFLGVGPchYqNCIHyEr8sS30RQCqTdAa2lqMTrKWuNo6osz7uXY8n7RJlrWbBgAeXl5Vx33XUopVi5ciUJCQksX76c7du3+7oFQggherDOBK/twH6l1N/xrl6/tmtL6j1ytn/IhH5GTjRF4dQmgkOCITjT12WJbypuOoSPwKBt3DWmgZlh70DNLjBHQO4/mDBmOKNGjcJmszFz5kzy8vI4cuQIiYmJPPPMM+zYscPXLRBCCNFDdSZ4LcC7pATAU3jneQng0P6dNEVex3vV38LP4MYangz+0b4uS3xTygB97gaDGaM1FUIGUVN8iENFQFstqvgtFixYgMlkIisri7S0NNatW4fD4SA+Pp6nn35athQSQgjxhTqznIRDa/2E1vq7WuuntdYygxjweDy0VJ1hYGgeDn9NfGQAxugxsk3QpcIcBn0fAEcNxF/N5vpprDtmxmGKhbJ/E65Kufvuu6msrOS6667D4/GwbNkylFLEx8fz5JNPkpOT4+tWCCGE6GE60+MlvkBdXR0R/vUMCznECXM00ZHh3hXQxaUjbDAkXAOOaq4eYWFx8jOYaz/ybn6e+w9GD89i3Lhx2O12brrpJsrKynj55ZdRShEbG8sTTzzB3r17fd0KIYQQPchXDl5KKb+uKKS3+d9tRbSmZNPm9uOkK5WQkBA21ifwaE61r0sTF1PyTRCYjCXQSkhMFtTsorSqEVwtqILXuPOOOwgICCApKYn58+dTUVHBSy+9dE74OnDggK9bIYQQoof40uCllHpaKWVu/zkT72T7y56ldC9vZv2ZBwr+Am4ju0xTmb+uhtGxFl+XJi4mo9m7xIS7DaIncdA2kWd3JVPYFAVVWwl153HvvfdSWVlJ3759ufXWW6msrOSll7w7a0VHR/P4449z6NAhHzdECCFET9CZHq9EYLtS6jvALuCDri2pd7DnvMOfDQ/zZtAYik3x3HFyCstmJzEtWZY5u+QEJkD6XdBWxcCsLK6JXk1S2wcQEAN5Sxk+MI3JkydTUlJC3759ue2226iqquro+YqOjuYvf/kLhw8f9nVLhBBC+FhngtdNgAf4G/B32avRq7roMPfHrGGM8QDlKoYHB5oldF3KYiZD5Gj8jJox/YIwNB7G2ZCPdjtR+a9w2623Eh0dTWlpKZmZmdx+++3U1NTw4osvAhAZGclf/vIXjh496uOGCCGE8KXOBK+tgBO4DbhbKfVk15bU89ntdkKMtbzVciXbPNkkGmt5+jhsLGrxdWmiqygFGQvBFAShQ2g09uOZHYkcLA+Hmt1Y247y85//nOjoaEpKSujTpw+33347tbW1HeErIiKCxx57jGPHjvm4MUIIIXylM8FrCzBFa70cGImsXE95WQm29CksaPoDoxzHSbO0suzaJOavLpbwdSnzC/HO93LWYU2bSWJACeEtW8A/DvKeJ8zi5mc/+xmJiYkUFRWRnp7OHXfcQX19fUf4Cg8P57HHHuPkyZM+bowQQghf6EzwWg1coZSaBgwB/ty1JfV8Jw9txxGVxO8Mf8JpAIPZyrTkIJbNTmJPhd3X5YmuFDoAkm7A4GnhppFtpKqd0HAYtIYzSwkJ8ucnP/kJGRkZFBUVkZaWxh133EFDQwMvvPACAGFhYfzxj3/k1KlTvm2LEEKIbteZ4PVc+/E88CHwYpdW1Avs3r6e/4v4B1epVbhNfhj8vHO7piUH8dPsKB9XJ7pc0vVgTQdLItran+3Hm9lxNhgajsPJxwnyV/z4xz+mf//+FBYWkpqayp133klTUxMvvPACWmtCQkJ49NFHyc3N9XVrhBBCdKPOrFyf0X6kAf2By34vlPyTe/AEZdDgjsJoMoHB7OuSRHcy+EHmA4AbYmdS0pZMcXkl2j8RGk/B8T9hMTn5wQ9+wJAhQygoKCAlJYVvfetbNDc3dww7BgcH88gjj3DmzBnftkcIIUS3+aoLqFYD47uikN7C4/Fg9ZTyr5I7OdE6DJNRgtdlyRILGXej3I3cOFJzS/QrqIo16IAksBXB0UcIMNj57ne/y6hRo8jPzycxMZG77rqLlpaWjmFHq9XKI488Ql5enm/bI4QQolt0ZgHVQqVUgVKqACgH1nd9WT1XTXU1sUHN3JP8T6JUAcovEJD9GS9LUeMheiKmgCBU9ERaq4/y4voazjbGQ1s1HPk/zJ56HnjgASZMmEB+fj4JCQncdddd2Gy2jmHHwMBAHnnkEfLz833dIiGEEF2sMz1e3wLuaj/6a60XdG1JPdvZk/vpG+PGz1mB1diA0Rzs65KErygF6d8CcyiEj8IZOZ02pwt3xUdgjgS3DY78H37OSu69916mTZtGfn4+cXFxLFiwgNbW1o7wZbFYeOSRRygoKPB1q4QQQnSh8wYvpdRvlFK/AWZ86ri3/bHL1u7tHxKXlMmJpkwsFn8MfoG+Lkn4kikI+j4ErgaCE0Zw/7gyMg1bIf8l6tuCQbvhyP9hai1iwYIFXHnlleTn5xMbG8uCBQtoa2vjhRdewOPxYDabeeSRRygsLPR1q4QQQnSRC/V4JV/guGydPLSN454ZHGmdSEhwqMzvEhCcCck3g60IQ/gwSLmVsnrF3zeYOVAc5P07cvR3GFtyueOOO7juuusoKCggOjqahQsX4nQ6O8KXyWTikUceoaioyNetEkII0QUuFLzcWut7gCKt9T2fPrqruJ7I1HKSBYkv0c+8i+CwCO8dbkIkXAMxV0BLPlgziek3k/Hhu+hnfx48DjAFw7FHMNQfZv78+dx4440UFBQQGRnJwoULcbvdvPjii3g8HgwGA3/4wx8oKSnxdauEEEJcZBcKXtOUUsuA7yulXvz00V3F9TQ2m40YSyMWox0TbZgjspCJ9QIAgwn63AtJc8CWjzEwnhlj+xBosqPznmfPGTduUySc/AuqZjc33HADt956K4WFhYSHh58TvrTWGAwGfv/731NaWurrlgkhhLiILhS8bgUO4N2n8cxnjstScf4pYuKS2FgxBrTm8aZr2VRiY1OJDfX4MR7eUenrEoUvKYN3yDFjEdiLvb1cGfeQ19qf1ccjOF7QCAGxcOpJVMUmrr32WhYsWEBRURGhoaEsWrQIrXXHsCPA73//e8rKynzbLiGEEBeN0lpf+AlKXaO1/qCb6jlHdna2zsnJ8cWlv9CrSx9FVWzkrGs408NWMm7haxA2xNdliZ6oZi+cfhJMoWAwUXJsHQnqMCppLoQMAHsJpN4GCdfw0aZN/POf/yQhIaFjgVWPx8PChQsxGAwYjUZ+8YtfEBcX5+tWCSGEuACl1F6tdfaFntOZlet9Erp6oiN7N3Jb2homW14jNDQELAm+Lkn0VJGjYOAvwGMHt53EQbNR1jTq8z/ipc2tNKhkKHgNit5m6pTJPPDAA5SVlREYGMiiRYswGo28+OKLuN1uXC4Xf/jDH6ioqPB1q4QQQnxDX3Xl+suaq+YASoHRoLGGxoA5wtcliZ4spC8M/h8wmsFRC6l30Og/hLpmTVtFDlhSoPhdyP8XE8aN5Xvf+x6VlZUEBASwcOHCc8KXw+HgkUceoaqqytetEkII8Q1caB2v9PMd3VlgT+F2uwkLhDVVV9PkisA/aqB3AU0hLiQwAQb/t3eLodYyUgZM4bsjthNjWwdlq2k2pEDZh3DmObJHDuNHP/oR1dXV+Pv7s2jRIvz8/DrCl91u5w9/+APV1dW+bpUQQoiv6UI9XmeAXD4/sT63G+rqcaoqSomKCGNv/Sg8CqwJo31dkugtzOEw8GcQmgX2QowJV0H0FI4Uufjbh4qytiSo3gannmLY4AH853/+J3V1dZhMJhYtWoS/vz8vvfQSbreblpYWfv/730v4EkKIXuq8wUtrbdBaG9v/7DiAid1YX49xcM8GJsadYI71cULNDgKjBvi6JNGbmIKg/w8g+gqwFUD0JNLS+jAiZC8xda+BfyzUHYCTjzOofzo/+9nPaGpqQinFokWLCAgI6AhfNpuNRx55hNraWl+3SgghxFfUmU2yZyul1iil1iulNgGdmmyvlHpYKXVCKbVXKTXhPM95Vym15SvW7BMHdn7IgARocQUQFiYT68UnHt5RiXr8WMdx3mVFDH7Q5x5Imgu2AqwxWVwz0oqxrRDHmX9xpCoGGk/B8T/SLz2OX/ziF9jtdrTWLFq0iMDAQF5++WUcDgdNTU088sgj1NXVdW9jhRBCfCOdmVz/MLAPcAP7geVf9gKl1AxgETAS+B/gNaXOnRCllJoLTPtq5fpOU/EulpffRpXuS1BYHPiF+Lok0UM8PD6GKYmBTEkMRP9wIA+Pjzn/k5UBkm+CjHu8S0oEpUPqneyq7Mvb+wOosgeDrRiOPkJGYhi//OUvcblcuFwuFi5cSFBQEK+88gpOp5P6+noeffRR6uvru62tQgghvpnOBK9ArfUvgXKt9Q+BzkxumgXs0FrbgI1493fs9/FJpZQV+D3w6Feu2EeCjY3UOiNwEIg5arBMrBdfn1IQNw0G/AgcNWCOZOLIfixIeYPoymcBBW3VcPR3pMZa+OUvfwmAw+Fg4cKFBAcHd4Sv2tpaHnnkEQlfQgjRS3QmeFUopRYAAUqpBwFrJ14TAZQAtIevOiDyU+d/CzwHFH/Ri5VSi5VSOcePHyc7O5slS5Z04pJdp7mpkWRrFbdHPU2MsQBrwhif1iMuEREjYNAvwdOGwWQmbfAsMPhRfOxD3jkYjMthgyP/S2K45le/+hV+fn7Y7fZzwldbWxs1NTX88Y9/pKGhwdctEkKIy9KSJUvIzs4GyFJK5SilFp/vuZ0JXt/Du23QP4D7gT934jV1QCKAUioQCAdq238fCswA/nq+F2utl2its7OyssjJyWHx4vPW3y2OHdzGoERNaWMAJj8zQVH9vvxFQnRGcB8Y8t9g9Pdupp1xL2XOdIqrHbS11ILWcOR3xFnt/OpXv8JqtdLS0sKiRYsIDQ3l1Vdfpa2tjaqqKv70pz/R2Njo6xYJIcRlZ/HixbTvtHNca52ttT5vj1FngtezWuvXtNbrtdYjtdZPd+I164BxSikLMBUoAk62nxuIN4gdxjvcOEopdd4Q1hPs376OU343s88+mdCQYFRgoq9LEpcSSzwM/i8IjAdnHaOzs3lgwPsEVbyBbsqj1e0PR39HtLmGX/ziF4SHh9PY2MiiRYsICwvj1VdfpbW1lfLych577DGampp83SIhhBDn0ZngdVgp9X2lVJhq92Uv0FqvB17Cu8n2/wK3Ay8opX6ntX5da52itc4CfgHs1Vr/4Bu0octVn/kIo0GjlBFLWDL4dWa0VYivwBwOWT+F0MHQVolf+q0Q3I+NR+08u9mM3R0Cxx4lgiJ+9rOfERsbS319PQsXLiQiIoLXXnuN1tZWSktLeeyxx2hubvZ1i4QQQnyBzgSvbwGPAzV472x0deaNtda/1lr3b+8l2661Xtg+Sf/Tz3lRa33FVy26uwW05XFT3Ntk+J/AP3qor8sRlypTIPT/HsRc4b3jMelm+sbCAMt+Aho2e8PZyT8T5jzBT37yE5KSkqirq2PBggVERkby2muvYbfbKS4u5rHHHqOlpcXXLRJCCPEZnQleA4E0IP1Tf1423C4XCcHNNNgVbq0IlhXrRVcy+EHG3ZB0A9iLSM4cw6wBLai6HJoKPqKoORZOP0WIbS//+R//QXp6OjU1Ndx1111ER0fz+uuvY7PZKCoq4i9/+Qs2m83XLRJCCPEpFwxe7cOKa7TWhXjnaVUCm7qjsJ6i4MwRXNEzeaV0EUaTH9YYmVgvPvFoTjUbi87tWdpY1MKjOd9gSx9lgOQboc+90FoKURMg7ko+yMvkjd0GHIYoyPsnQQ2b+PGPfsSAAQOorq7mrrvuIiYmhjfeeIPm5mbOnj0r4UsIIXqYC22S/T94hxb7K6U+HmJsAeq7p7SeYc/W1fSLqMGia2Rivfic0bEW5q8upq7NDXhD1/zVxYyOtXyzN1YKYqfCgP8ARy2EZHHtMDe3xr2KufR1MEdCwetYqlfz/e99l6FDh1JZWcldd91FXFwcy5cvp7m5mTNnzvD4449jt9u/eWOFEEJ8Yxfq8Xoc77BiXvuf6UCq1npEN9TVY5QeXcvYiL1kmHYTEJ4OxgBflyR6kGnJQSybncTx2jbONjqYv7qYZbOTmJYcdHEuEDEMBv8KtJOgsFiSB1wBbVUcObiT7YVxULyCgPI3+c5DD5CdnU1ZWRl33nknCQkJvPnmmzQ3N5Obm8vf/vY3WltbL05NQgghvrYLbZLdqLUuAIYB/dqHG1O6rbIeQjWdQGuFv9lfJtaLLzQtOYj4IBOFTS4eHBp+8ULXx6wZMPi/wRjo3Ww7fQGnG5M5WViHWwVC2b8xF77Et++/h4kTJ1JeXs4dd9xBYmIib775Jk1NTZw4cYInnnhCwpcQQvhYZybX/w2Y3/7z00qp/9eF9fQoWmssoYn84czPaHKHEpKQ7euSRA+0saiFshYXKcEmnj5U97k5XxeFJc7b8xWYCGjmjo/izpR3MBa8iMtjwFO5Hb+zz3Lf3Xcxbdo0SktLue2220hOTuatt96isbGRY8eO8fe//522traLX58QQohO6UzwGqe1/njp+LHA3C6sp0epqy4jLaSKJOMRgvycBMf293VJoof5eE5XVoQ/6SFmls1OYv7q4q4JX+aw9rW+hmDw2DD3+RbaaOXtXa0sOxCNrj2AMfcJFt45j6uuuoqysjJuu+02UlJSeOedd2hoaODIkSM8+eSTEr6EEMJHOhO8ApRSye0/RwD+XVhPj5KzdRVTUopJ8WwhJMSKsiT4uiTRw+ypsLNsdhLh/kbgkzlfeyq6aDK7yeJd6yt2GjhrUekLSA+pIY1tKEctNJ7CcPIx7ph3Hddffz2lpaXMnz+f1NRU3n33XRoaGjh06BBPP/00Doeja2oUQghxXp0JXo/gXb1+P3CGC+yxeKk5e+B9XIYgXPjjH94HjGZflyR6mJ9mR31uTte05CB+mh3VdRc1mCBjAaTcAo4qRo8cyrjkKih9j4rKappqSjAcf4R5c2Zw0003UVZWxrx580hLS+Pdd9+lrq6OAwcO8Mwzz+B0OruuTiGEEJ/zpcFLa/0sMAb4PyBba/1Ul1fVQ7TV5fHY2Z/QYBpIQPQwX5cjxCeUARLnQOb94KiGxDl4QobwxpE03tpngbZa1LHfccNV47ntttsoLy/n5ptvJiMjg/fee4/a2lr27t3LkiVLJHwJIUQ3+tLgpZSKx9vr9WtghFIqs8ur6iEiDCVMC1uD1VBLSNIoX5cjxLmUgpjJ3rW+nI0YYqdxS7/jXBfxKtTsBFcz6uj/MXvqUBYsWEB5eTk33ngjmZmZrFy5kpqaGvbs2cPSpUtxuTq1E5gQQohvqDNDjf/Eu9m1P1AAPN2VBfUUzrZWMiPqiHDsJcivjdDYLF+XJMQXCx/qveMRNwkpfYhKGgL1h9h2sJyzVQp19HfMHJfBfffdR2VlJXPnzqVv376sWrWKqqoqduzY0enw9fCOStTjxzqOh3dUdn37hBDiEtKZ4JWltf4N4NRab+Ey2avx4O5/ExcTS3lLMNbgEJQlztclCXF+1nTvWl8mKwRn4oy9noPVSRw+UwVaw9HfM2V4LA8++CBVVVVcd9119OvXj9WrV3eEr+eff/5Lw9fD42OYkhjIlMRA9A8H8vD4mG5qoBBCXBo6E7zylFI/BPyVUg8CFV1bUs9wctdbvFZ1D7lMxRzezzuhWYiezBILg/8LApPxC4zknrG1XBv5FhS/jcut4NijjO9v4Xvf+x61tbVce+219O/fnzVr1lBeXs6WLVt44YUXcLvdvm6JEEJcsjoTvO7Du3ZXHLAAWHzhp18a7GU7uDn2LVID8rDEXla7JInezBwKWf8JESMICDBjTLsNR5ud57cY2XY2BE7+hexUJz/+8Y+pr6/n6quvJisri3Xr1lFeXs7mzZt58cUXJXwJIUQX6cxdjXnADcBU4Fqt9dEurqlHCNZFJJtPYTU2EZow3NflCNF5Jgv0fQjipgNgTLuVGP8qou3rvcOOp59maEw1//HjH9PU1MSsWbMYOHAgH374IaWlpXz00Ue8/PLLeDyec9720Zzqzy0Mu7GohUdzqrutaUII0dt15q7GeUApsBEoUUot7PKqfEx7PISGhrO/Ih5lMBEaP9DXJYke7OEdlWwqsbGpxNZzJpwbTJC+AFLmYaSNueMj6RdSAoWvU1JnwJ37PIPC8/n5z36G3W5nxowZDBo0iPXr11NcXMyGDRt45ZVXzglfo2MtzF9dTF2btzfs41X7R8dafNVKIYTodZTW+sJPUOoE8B2t9Xql1CTgFa11WncUl52drXNycrrjUufIP7mP9W8/QUObmWnxBxixeId33SQheqPKrXDmWTAE0pj/IU+cvI3RibVcmdUEiXPIc43g0T/+CZPJxObNmzl8+DBTp04lKSmJq666ijvuuAODwfv3f2NRC1e9U0B8kAmbS7NsdtLF3xRcCCF6KaXUXq31BTd27kyaMOLt7QLYCdi+aWE93eEt/+LG+PdIcm/CHNFfQpfo3WImQdZPABchaTOZm7KNSeYXwV4JJSvJUNv45S9+htaaSZMmMXToUD766CMKCwtZu3Ytr7/+ekfP17TkIOKDTBQ2uXhwaLiELiGE+Io6kyi2A08ppa4HngH2KKWmKaWmdW1pvtOQv5EIcy0xliYssbJwqrgEhA2GQb8Cgx+Ds/oSGJ6CLv+QDccMNJz9iBTHOn75859gNBqZMGECw4cPZ/PmzeTn57N69WqWL1+O1pqNRS2UtbhICTbx9KG6rtkMXAghLmGdWSPhivY/r/zMYxroc9Er6gkcDRyoH4gyOQlNGOrraoS4OKxpMOS/4fhjEDWBWkc0u/PiCTKeZqxlK4nhNn718//gkT/9lbFjx6KUYuvWrWitWblyJcecVp5qySQrwp9wfyO/HhfN/NXFMtwohBBfwZcGL611BoBSKgBwaK09X/KSXs8VlMnKqjFMDVpOeOIgX5cjxMUTEONd5f7k34iMd/OQXw7Bjf+GmgF4PBDnaeOXP/sBjz72JNnZ2Sil2LZtG1prjh44y3dHGNho9u7iMC05iGWzk9hTYZfgJYQQnXTeoUal1Ail1DGlVLhS6hagGqhRSk3truJ8obGmlOvi1zPc/QKB1jAMAdG+LkmIi8svpH2tr1GERMaj4q+iobaMp7dGcSYvj+iqF/jFT75DZGQkI0eOJDs7m+3bt+O/9RVy17xKdfUny0dMSw7ip9lRPmyMEEL0Lhea4/VX4D2gBXgC+DPwEPCnbqjLZ/ZvfJEoqxvtbMYvIsu7EbEQlxpjAPR9EOJnQUAMxviZBBnqCWrcBo25RJT+g5//6H7i4uIYOnQoo0ePZteuXZw6dYrKqkqqq6txOp2+boUQQvQ6FwpeKVrrnwMDgSjgT1rr19p/vmSVntjAltorICASS5ysWC8uYQYTpH0LUm/FarWwcJyNOONpKF1NeXkZocVP8rMfLCIlJYXBgwczduxYdu/ejX3dUqqqq/jJT37Ctm3bJIAJIcRXcKHg5VRKRQPzgH1a60alVDydm5Dfa7XZ69lQMwOjfwRhicN8XY4QXUspSLwW+j6I8rNA0i3kNcXyj13pHM1rwHr2cX7yndvJzMxkwIABJE66luZt71C5/M/81X86D713VAKYEEJ8BeddQFUp9TPgYcAMPAAcBF4Dlrf3hHU5Xyyguv23JoIsZhpJZsJ3t2O0RHbr9YXwmfqjcPKveBw2dh0tYXTIbkyJV4IljtaM7/HE86s4evQohYWFbN26FafTSVZWFqNGjcJgMBAeHs68efMYM2YMfn5+vm6NEEJ0u84soHrBlevbV6pv01rvUUoNB8YD/+iuOxu7O3i52mzUvxDE/qIAQhOGMebBHTLHS1xeWgrg2J/AWQ9la3G2NrLNsYBJAzSezO/y5CsbOHDgADExMezatYvdu3fT1tZG3759yc7Oxs/PTwKYEOKy9Y2Dl691d/A6sH4pJYffpaY8nyEjxjHi1qXddm0heozWKjjxZ7AVc+LUWZYVzOBbg4+SkRCMM+Mhlry5m507d5KUlITWmt27vb/b7XYyMjLIzs4mICBAApgQ4rIjwesrevfPN5JryyTCkcPEmfPoP/mhbru2ED2KswlOPgENx6kpOUqkaz9ETUIHpePOuJ81extYtWoVdrudmJgYTCYTOTk5bN++nZaWFlJSUhg9ejSBgYFERERIABNCXBYkeH1FK/8nmaszi9la0oeB8/5JbObkbru2ED2Ouw1yl0L1Dqg/RElFDe/X3MqtI+oJG3Q7tuCx7Nydw7vvvktDQwORkZFYLBb27dvHtm3baGpqIjExkdGjRxMSEiI9YEKIS54Er69o+2/9iQhyUq37MO47uzFZwrvt2kL0SB43FLwOpR9QVFrNB2dSub1/DsGxAyEgGhLn4ggZwd4DR3nnnXeoqKggLCwMq9XKoUOH2Lp1K/X19cTGxjJmzBjCw8MlgAkhLlkSvL4C7Xax4s/XUt9oo1+cmwnf2d4t1xWix9MaSj+AgtfQLUWoqk1ocwzvVd/CiBQnKVFGSJiNO3ICh08W8c4775Cfn4/VaiU8PJyjR4+yZcsWampqiIqKYvTo0URFRckQpBDiktOZ4HVJr8n1VRQf/5BWFUGTxx+/iFhflyNEz6EUJM4Gczgqdwn4hVBfdpQz1QFkGHeDnwV3WwOeghUMT5jCsJ99m5OFjaxYsYJjx44RExPDAw88wIkTJ9iyZQsffPAB4eHhjB49mmeeeYbly5dLABNCXDYu6x6vh3dU8ptd3n3nrit/gpVDn+HNg1EMmv2/ZE35dpddV4heq+E4nPgLKDNuRwOqZheGltPsa8xmfc0sFo8+S2iwP0SMQsdfTUGNiVWrV7Nnzx78/PyIjY0lNzeXzZs3U1ZWRmhoKNnZ2cTHxxMZGSkBTAjRq8lQYydMXZ4PwM9PXcmVqadZn5/GkNteIS5zYpdeV4heq6UITv4N2qrAZAWPh5LCkxwu9eeqqA9QwX045RhLaLCF2IQUSJpLmT2Stev+zebNm1FKERsbS0FBAZs3b6a4uBir1Up2djYJCQlER0dLABNC9EoSvC7g0ZxqRsda+M3OKgC+fXwRe/3G02J287fv/Bd+ASFdcl0hLgkeNzQchdLV0HgClJ83hNUfRNfs5okz9xLp38SdwwrAEg+WOEi6gRqVwYaPtrFu3TpcLhcxMTGUl5ezefNm8vPzCQwMZOTIkSQnJxMTEyMBTAjRq8gcrwsYHWth/upiEoJMhPsbKQpK4xl1E78zPS2hS4gvYzBC+FDvYSuG8g1QuRmCUlFhw7g/shB71WGoPI2dCF4pXcis/s+RFmth3oTruHrGw2zavp9Vq1ZhMBi45ZZbqKmpYcuWLWzdupWAgABGjBhBRUUFsbGxEsCEEJeMy7bHC2BjUQtXvVNAml8TdQ4nD5b9kmuGZjH+jn902TWFuGQ5m6B6J5SuAkc9GK3gbKSy5ATv5o1gbtxKYqOjaDH3Q/tHYE2Zij10AjsPnO1YCywiIoLm5mY2b97MyZMnMZvNDB8+nLS0NOLj47nlllsYM2YMZrPZ160VQojPkaHGTkh97hSFTS7+O/Bpsk68yrC5jzBwyn1dek0hLmkel3cYsmQVNJ0Cgx9am1D1OVB3gDWVM9jfmM2Px+7FPzgWIsfgjJnJ3uM1vPPuu5SXlxMaGorD4WDr1q0cPXoUk8nEsGHDyMjIICEhQQKYEKJHkuD1JT7u8bqiZQO7AsbzH81/5Nu3fZ+EvhO67JpCXDa09g5DVmyAyi2AG4xWairOUlRaw3DrTjBHsrXpGhIiA8jISMcdP5sjRZp3V7xHXl4eQUFBKKXYtm0bhw4dwmAwMHjwYDIzM0lKSpIAJoToUSR4XcDGopaOOV4/z7uZ/X5XsSTgBpZdn8mVmdFdck0hLlvOxk8NQzaAMRDs5biq9vD3k7cwMOQkV/atgqA03IF9MCRfz6maEFauWsuRI0fw9/fHbDazfft2Dhw4AMDAgQPp27cvKSkpEsCEED2CBK8L+PRdjS9VZnK8GI7FLsQ56RF+mh3VJdcU4rLncUHDkfZhyNOgTLidDlw1+/G3HaGsLYFXShdw2+B8khMi0QnXUtSWyqq1m9i1axcmk4nAwEB27drFvn37cLvdDBgwgH79+pGWliYBTAjhUxK8OuH6f23nHT2ZN3b7kTpmEZO+9XSXXk8IQfswZBFUrIfKraA9oExUlJ5l89koro95l4DgWMrVcAyBCcT0m0qFGsTaj/bx0UcfAWC1WsnJySEnJwen00m/fv3o378/GRkZEsCEED7h0+CllHoYuA1oAb6ntd7+qXOTgL8BwcAO4H6tddtn36M7Vq7fs+7vjAOOtTQSNuIanr79qi67nhDiCzgaoHqHdz9IZwMof2jJg9rdvJp/HRWOeH4wajuG4AyIuYL6wHGs33GatevW4XQ6CQ4O5sCBA+zevZu2tjYyMjIYMGAAffv2lQAmhOhWPgteSqkZwHPAQGAa8BSQptsvppQqAB4A1gE5wF+11i989n26o8dr/ROzQGtKyyuZtmgJSf3Gden1hBDn4XFC/RHvPLCmXFBGbM0N1JTnkWzYjzYEsLzyLoYmuRjQvz8t4dPZfKCSle+vwmazERwczJEjR9i1axd2u53U1FSysrLo37+/BDAhRLfw5QKqs4AdWmubUmojkAz0A04qpYKB7cBWrbVbKdXYhXV8qeC2Y0SbSjGE9iE6eYivyhBCGPwgYgSEDwdbIZSvJ5CtBGYMBc9AWqqOUmcz0Fq5H0xbCbBu5YqIIUz/1W3sPOXgnRXvk5qaysCBAzl16hQ7duxgzZo1HDlyhGPHjpGVldWxEKsEMCGEr3RVj9cSoFFr/Z/tv9cA139muNEI/D/gbmCQ1rr2U+cWA4sDAwNHZWVlsXjxYhYvXnzR6wQ4+UQE+aX1GGKuYNaPNnXJNYQQX5OjAaq2e7cmcjWhPRrddBJD/X4O1mexsnIOi4fvJSY+HVfctRwoCeStFWsoLS0lMDCQs2fPsn37dpqamoiPj2fgwIEMGjRIApgQ4qJasmQJS5YsYe/evTbgOLBEa73ki57bVcHrESBFa327UioQaAYGaq1PtJ8PA97HO8frBq312S96n64eavS4Xfzvwz/HZD/DhKEJTF3wZJddSwjxDXicUHcISt+HZu9/LmprajlU4GBK2FqUOZRjzimYgxPIGDKdE3VxvLlyI2fOnCEgIICSkhK2bdtGfX090dHRDBo0iKFDh0oAE0JcVL4calwHLFVKWYCpQBFw8lPnVwAlwF1aa0cX1fDllIHM9GQcp9YTnny9z8oQQnwJgx9EjoKIkdBSAOXriVDbmBrhBudcqNvH9jMxmI2tZBp+y8DQLP7r9lnkt03hnbU5tLa2cvPNN1NVVcXWrVv56KOPOHz4MPv372f48OHMnz9fApgQolt05V2Nv+GTuxq/C3wbb9h6GigEzgIf38n4d63157qbumNyfd6B1RSt/S4ZN75Bcr/RXXotIcRF5KiHqm3euyFdzbgddlpq8ghp3Uub28w/ir/DrMwKsgYNp9QwkpWbTrFz5y6UUtTV1bFt2zaqqqoICwtj4MCBjBw5kltvvVUCmBDia5N1vDoh78Bqzq77ORO/t4MAS1CXXksI0QXcDqg/BCXvQ0s+eJzU15TywalEpkRsICFM0xwwBJt1NMa4yXywq5SNH21Fa01DQwPbt2+nvLyckJAQsrKyyM7O5rbbbpMAJoT4ynw51NirOC1pErqE6K2MZojMhohR3uBV/m/CDDu4PcoJ9oFQu48duZqddUZ+PPK3fKv/UOaOm8OGQzZWr/uIq666iubmZnbt2sWuXbs4evQou3fvZvTo0dx2222MHTtWApgQ4qK57Hu8KsoKyTuxn/HT5nbpdYQQ3chR1z4MuQacjdhamsgvqWGgeQsYzGxsnENkRAR9h01l22kT76z6iObmZmw2Gzk5OeTn52OxWMjKymLs2LHcfvvtEsCEEF9KhhqFEJc3twPqDnrvhmwpAGcjnsbTPHdkPMmWIq5OOw6hg2gMv55jtdEsW7mN2tpabDYb+/bt67grcsCAAYwdO5Y777xTApgQ4rwkeAkhBHj3hmw5C2XroHoX2mXD3VyMqXEfFbYQlhYtZv6Ao2QMHMvRhj68vmovJSWl2O12Dh06xMmTJzGbzfTv359x48Zx1113SQATQnyOBC8hhPistlqo2to+DNlAfV0N2/KCmB7+ARZ/A6VqDC3BYyFiBMvWHefU6TxsNhvHjh3j2LFjmEwm+vfvz/jx41mwYIEEMCFEBwleQghxPu42qDvQfjdkIbRWQNMJ3j4zijxbBj8cuhpj9FhK/Gfy9qYi9h44hs1m4+TJkxw5cgSDwUDfvn0ZP348d999twQwIYQELyGE+FJaQ/MZ7zBkbQ4uWy01NdXEunagPR5erbiXAfEeUgZMYNWeZjbtOEhzczO5ubkcOnQIgD59+jBhwgTuvfdeCWBCXMZkOQkhhPgySkFwpvdoq8FUuYVY6zpoS8DRUIIqc6DqjxB95j3uSh3M5AHXs7/In9UbQujbty9nzpzh4MGD5ObmsnXrViZMmMD9998vAUwI8YWkx0sIIT7L3Qa1+zsWZdXNhaimYxyuieft8lu4J2sLkX0msa0gljfX7qe+voG8vDwOHjyI0+kkLS2NCRMm8MADD0gAE+IyIkONQgjxTWgNTblQ/iFU78bWVMnhIhhjWYMyGDnsmEabdTBtAZm8/sERqqpryc/PZ//+/TgcDpKTk5kwYQIPPfQQgwcPJjw8HKWUr1slhOgiEryEEOJiaa2Gqi3euWD2Umg6w+snhmJ3B3B3vw9xR4zlgH0Kr394muLSKvLz8zlw4ACtra3ExMQQExNDYmIiY8aMYdKkSaSmppKQkEBwcLCvWyaEuEgkeAkhxMXmboXafVDyPropl9b6Iiy2QzicLp4o+AFTUosJSxzJQzuiOd1oIP/ofjiwFspOQfpISBmM/7Z/ERkZSWRkJKmpqYwbN45JkyaRlJREQkICFovF160UQnwNEryEEKKraA1Np6FsLVTvpqW+mI1nohhu3UFSUC3v61u5q/J7BDptuO3NDC3dyqb0uQzZ+zyeUzspKyujsrISj8cDgL+/f0cY69OnD5MmTWLChAkkJiYSHx+Pn5+fjxsshPgyEryEEKI7tFZB5RZvCGvOg+ZcNhWm8HzDfN4OHkOGXw0FrjgeNO1G5x+nvKoepRROp5OWlhaampqorq6mvLz8c2EsKiqKyMhIBgwYwOTJkxk7diyJiYnExMRgNBp93HAhxKdJ8BJCiO7kboXavVC8Elf9CQrL6lnaPJzf2xZzi+cjJrXm8oPB7+EOSORgw2AadDx1NiNHzlSTX1ILeMNYU1MTTU1N1NTUdISxj/9b/XEYi46OZvDgwUyZMoXs7GySkpKIjIyUyftC+JAELyGE8AXtgabTbDyym6v3DGO8+SiHnX141PJP7g39F7iaebbwfgIMrdyV+iaYw/mgYjrWwACS4sI4WR3G4TP1nCqowe0Bp9NJQ0MDTU1N1NbWUlFRcU4YCwgIIDIykri4OIYOHcq0adMYOXIkSUlJhISESBgTopvIAqpCCOELysDGhiTmH4YB4RoMfXkzZS/zD91HRmgs06ynWRBVjL21FQwZ4KimtgmMbYWkm5aSjoHjxh8xf1QTV6RVUacy2FM+jPzyVk7m12J3aFwuF7W1tTQ3N3eEsX379rF3716ef/55LBYLkZGRJCQkMGLECKZPn87w4cNJSkoiMDDQ15+QEJct6fESQogu8GhONaNjLfxmZxUAH81LY2NhE3tK6/hpVgu0lkPTGe+cMHu5t5fM2QDOWjyOZjYVppLgl0d/y0EcHjO/P/MLpkZtZXL8cVpNcawrHUeo1UxelYGjZxuobXLhdnuoqamhqamJuro6Kisrqaqq6ugZ+ziMpaSkMGrUqI4wFh8fj7+/vy8/LiEuCTLUKIQQPvTwjkp+s6u64/dfj43i4fExn3+ix+mdoN9WCS3F3r0jW86CowE8bbjttRTXKkKM1YSrImqaPDxTsJi5sSsYHHyMGlJ5o2gOU1IKMAeEcKA0hINnHZTWtOJ0eaitraWhoYH6+noqKyuprq7+XBjLyMhg9OjRTJ8+nWHDhhEbG4vJJIMiQnwVEryEEKI3c9mgtQJaK6El39tDZisElx2PsxHdWovR3UhVk+bD4qHMiFhHrH8FuS2Z/Kv0WyzMWEFMiCLf3oeDlbGcLW/lbHkbrU5NTU3N58LYxwIDA4mKiiIzM5Nx48YxdepUhg0bRlRUFAaDwXefhxA9nAQvIYS41GgNznqwV3wyXNly1ruavrsVHLXUN9o5UR3G8OB9BLjL2F03ig+qZvPj9D9jtRg52jKcw439SQmu52CRH4cL3TS3KWpqaqmrq6OhoYHKykpqamo6LhsYGEh0dDT9+/dn/PjxTJ06laFDh8o2SEJ8igQvIYS4XHhc0Fbl7R2zlUBzLjTnQ1sNbkcTtQ12ooylKFcDe8qT2Fk7ku+m/h2lNP+uuYojTYNZ2P8jylpj2VMcwZFiAxX1Lqpr6jqGKisrK6mtre24ZGBgILGxsWRlZTFhwgSmTZvGkCFDZBskcdmS4CWEEJc7l/2T4UpbQXsPWYG318xRD23VnKgKoaQxkBkRq0F7WF42j7K2eL6T+TJtxmi2VY2gvCmA/NJGzlT7U1nT0DFUWVlZSV1dXcflgoKCiIuLY/DgwUycOJGpU6cyZMgQAgICfPYRCNFdJHgJIYT4PK29d1C2VniHLJvzvIetCJz1VNe30tzSRpolF9pqeKngFgzKw7cSX0EbAlhWNh+LyU2UXxn7C80crgiloLSemppa6uvrqaqqor6+vuNyQUFBJCUlMXjwYCZNmsS0adMYOHCgbIMkLjkSvIQQQnSexwVtNe2BrOST+WO2Upytjfi5qsBRx/v5wwgzVDApYisAf8r7T/pazzIl/hBFzRFsK0nnTJmDo/ktVFXXdISxhoaGjktZrVaSk5MZNmwYkyZNYurUqQwYMEC2QRK9mgQvIYQQ35zL7l3qorUSWgq988ea8qC1Au2o52CplXBDOanmY7Q5PPwh7xdMj/w3EyNzaCaKN4uuIUiXcrq4hd1njJRVNVBbW0t1dTWNjY0dl7FaraSlpTFixIiOnrHMzEyZvC96DQleQgghuobW4Gxsnz/2yXClbsylqbkJo7OOIE8Z9S1O/pV/PdMiNzAw+DhVjmiWFt7PjJgtuBzN7CsK4kBpGIdOV1BVVdWxAOzHQkJCSE9PZ9SoUUycOJEZM2aQkpLylcLYx4vZTksO6nhsY1ELeyrs/DQ76qJ+LOLyJsFLCCFE9/K4wdE+XGkrg+bTn6zQ76ynrtHOztJkRofsIMpUyqnmfrxWdgcLk18m3N/GkdpU9lelknu2iB0n7VRU1lJTU0Nzc3PHJUJDQ+nTpw/Z2dlMnDiRmTNnkpCQcN6SNha1MH91MctmJzEtOehzvwtxsUjwEkII0TO4W71DlR3DlWeg4Tj2xgoKaw2k+5/E7K5if3UG71Vez3+k/4kgk529jWPYUzeCRNdW9ufDzjwTJ/LrqKqqoqWlpePtw8LC6Nu3L6NHj2bSpEnMmDGDmJhPdglYuKaYl058Mqy5YEAIL16d1J2fgLgMSPASQgjRc2kNrqb2xWArvBP5m07jqDmG2V0FbTUcqQhlf01fvpXwEkppPqyexe76MdyX8hy5VQHsKk3gWJmZ9TtOUVldj81m63j7iIgI+vfv3xHGflydRXGbgf8eG8Vvv2jrJiG+IQleQggheh+PGxy17XdXlkFTLjQcg6ZTFNVAeQOMDtmJdjWzrHQeVY5ovpP2FM3uYNaWTqS0wcTpE4f56IiNM8WN2O12yBwDCx+D3e+gxt5M7NpHiG8uIiIigsjISKKiooiJiSEmJob4+Hji4+OJi4sjKiqKwMBAmeAvOkWClxBCiEuHu619df4KaCmCppO0VR6iqbGWKEMBtFXzTuFk3B7FLfFvAvBc0b2cUVE8YbqBsaWvEFZfxWlPDEf73kH427/Ek3eQ5uYWHA7HeS9rNBoJCgoiODiYsLAwIiIiiIiIICoqiujoaGJiYoiLizsnrIWHh8vSGJchCV5CCCEubVqDq/mT1fmb86D+MNQfgdYKthTG8aZrDHODVjHdvJs/5f0n/YNOYA2vZI9zMJRHkWU9zpTw9TQ7jLxdeQfR6hRhzqPUNisK1ThaagupLCukosGNx5JMYUklBSW11Dc7UcqAx+P5wtIsFgvBwcGEhoYSHh7eEdY+7l2LjY3tCGvR0dFERkZisVi6+QMUF1Nngpepu4oRQgghLjqlwC/YewRnQvQE7+PaA221XNFawRX2MmiMgvoh3BN6GhNOQoyKaZ4ccoxJRJlrCAkMJdjdRnRzE/2tzQwLrsPt8fDHMwOZmVrL5Bk1OD1+/O7Mzfwk8kMmRWzD7vbn0bxfcEXov8nw20+VPZDtLXMIb9uPs/EslU1+NAYMpaokl5Kyw9ScgcrCSM4WV1PX2PqFzfHz88NqtRISEtIR1j49FPpxWIuNjSUqKorIyEjCwsIwGAzd+KGLb0J6vIQQQlw+tAc8DnDbvXdadhztv7ts3vXJXI3gaABHLdpejXLV4WlroLTeQLCxkVBTPQ6nix0VfegTVEBiQDHNDj/eLL6O8eHb6R90nBpHFE8WfJebYt9iSMhhKttieLrwIW6JW84A6zEKWuJ5o3wBEwLfI8hVQElLBLmeKzDUbqe+ppKa1kCcARkU5J2kpLKBxjYzDoKoqmnE7XZ3NEkp1TEUGh4eTnh4eEdYi46OJjY2lri4uHPCWmRkpOyf2QWkx0sIIYT4NGUAY4D36OxL2v80AEkeV0dIM7tbmfKp0BbsaeVuRyO4ZoCjnihHDb8aWI1yDAdXCqGtdm4PyCHeEoTR2JcIPz+GO06TFdZGlJ+BWJuJ4vJw5vZxkhRg43RLIq+Wzua/ryolydLAyeZ0Xi+7nbsTlxBqqORYQ1+2NV3JUJbjsNVRbLdQY8ykqXAL1XXNNNaHUF8Qwwe5uVQ3Omls9cPhVh3z2cxmc8e8tU8PhX563tpnw1poaGiv6l3riYvnSvASQgghOstgAkP70GYnfPofWX/toZ+7DTzeXrYwdyvXfKrnLdll4zvORnCOhNYqMuxV/CizmEA9EjyZxFk1cwP2Eh0cQYDyI9HPTDoVjItxYzVojjZaWVPVn18N30iwycnu+gw+qLqWlxb8kSCTk511I1lbfQ2L4/+Io83Bwaah5DpGkNL0L+qaiqhwp2IzuSne+xpnWjRthkgcWDl1poC6FnC4vYErKCiIsLCwjhsNIiMjO8Lax71rnw5rkZGRmM3mLvgyvtzoWMt5F8/1FRlqFEIIIXoDj/OLh0fdrd4w52gEZ4P3RoO2alqbq6mvbyTGvxKDx05Zoz95DWGMjTiIwdPKkfpUDtYN4I7EN1A42VwziW11k/hln/9DKVhbdSV7G7L5ZebvAFhVcTVHm4dwc8hfqG+BI/ax1Lrj8S9/h+omN42mftg9VgpO76OuBZzGCBrtivySGpQxgNDQ0I7etU/PW4uLiyMmJuZzYS0kJOSiLOPxcdh6cGg4Tx+q69IdC2SoUQghhLhUGPy8Ryd72wKAuI9/0R7i3W3Eez4JbUPdrQx1t4J7MbhamOqoZ0prOartv8FeztiIegbYjkHQeLTbTh93G8GW46RGRZLqcdJcFYDZbubWwd5h2OVlw6hsi+HJufsAeKN0FrXOCB5MfZo2ZyvLy66nxRXAcP0qtc2a057J2Frzadi2ifwWcAQOoLHFSf7ZM9S1gNsURqvbjNEv8Jyh0I971r4orEVGRuLn53fO57CpuIVqu5v/t6u643dfbhUlwUsIIYS41CkDmCzAhZer+HT/Ulj7gdYo7WKAu5UBn+ppm9LR87YYHPXcbCvD2VwOrsXQWsGkwFZaHYW4g4ZhdNrIbGvA6W5gZEQoSjuwl0YCmpvGea+3pHAyVmMzdySeAeCZgtsI86tnbtTrNNgLeLf6LszuSqKa3qC2CMoqZ1DcXEVt8SHqWkAH9+P/t3f3QVbVdRzH3x+EVXa3FE2jEYQmARdNFNeHwAR5qMZpekDLLFMmGHO0J/9oplFH0aZRnKlxJienNU3NkXQsdTItFgTDUBMfQHAXTbCFzcdQFJeHhf32x/mt3rZdl6d79p7l85rZufec3zm/87v73Xv58vv97vm98eZG3tiwkR37fZT9a4cyuPZAXv74eKg/F6oGg8TajT3fsy0PTrzMzMysZxKo9962AcD+JduHdz6JDtixlVM6tsD2ze/PcZvRmcRtnQ1bX+Hc0evoaHsV+AqxbROTaGW/aGNg9SgOrt3KiO3vcODALZw4phY62rm55UhGVg/iC1NXADD3pa/y6Y+s4IzDHgK2cM1Ls4iad/j5gLO4advFtPx7LKf/4Aa+/uB6Fq3ru14vJ15mZmZWPqW9bVVDejysuvQUoA6yG+TGdujyRQR2bOHCHZuhfRO0nQ1tLcwa+hr7tdewXVPoaN/EaZ94nvt3jOfOmmuZVLWet4/5FEOH13D3GcN48rXNTrzMzMzM/sdO9rYBdL05xERgYupto2PL+/PdTh9e4zleZmZmZnvdTs5ty1PZ7oImaY6kZklPSZrQpWxC2t8saU652mBmZmZWScrS4yVpKjATGAucDsyTNDIiQtlNOeYBFwKPAM9L+ltEPFyOtpiZmZlVinL1eE0HHouINmARMBwYncrGpO3FqfyJdLyZmZlZv1auxOtgoBUgJVdvAYeUlG2IiM1pe31JGQCSLpC0rKmpifr6ehoaGsrUTDMzM7M909DQQH19PUCdpGWSLujp2LIsGSRpLnBERJwjqRrYBIyNiGZJdcAqoCYiNku6C1gbET/pWo+XDDIzM7Oi2Jklg8rV4zUfOEXSYGAysA5Yncqa0/bkVH4y0FimdpiZmZlVjLJMro+IhZJuB54F3gPOAW6V1BoRl0o6B7gBqAFui4iF5WiHmZmZWSUpy1Dj3uKhRjMzMyuKvhxqtAriLycUn2NYfI5hsTl+xVcpMXTitQ+olD82232OYfE5hsXm+BVfpcSwoocaJb0B/Kuv29EP1AFNfd0I2yOOYfE5hsXm+BVfHjEcERGHftgBFZ142d4haVlvY85W2RzD4nMMi83xK75KiaGHGvcNldG/anvCMSw+x7DYHL/iq4gYusfLzMzMLCfu8TIzMzPLiROvfkjSTyU1S3pB0rckjZK0NG3fKMlxLwBJwyS9K2mWY1gsKWbPSHpW0mzHr1gk1Up6QFJr+iyd5BgWQ/rcfEbSlWm727hJmpNi+5SkCXm20X84/YykKcD5wDiyFQMagDuB3wFHAccDM/uqfbZLfgl0pOe34BgWgqRxwI+BCcA30s/tOH5Fch4wHBhB9t67Dr8HK56ki4BngKNLdv9f3CRNJYvfeOAKYJ4k5dVOJ179TzVwQ0RsBTak7ROAhyOiA3gEmN6H7bOdIOlLQABPAwcAE3EMi+JM4E1gAXAP8FuyNWkdv+J4DRhE9t6rIVv6zu/BChcRv0q3cvg7gKRquo/bdOCxiGgDFpEl2aPzaqcTr34mIh6IiOskHQHcDdwECGhNh6wHDumr9lnvJNUCc4EfpV0H4RgWyVBgFPBt4DLgDhy/oplPlmy9DlwKXIVjWEQH0X3cDu7cl5Kvt8gxnk68+iFJ04DlwFLgErKek8NT8TCynjCrXFeSLR7fkrbfxjEsko3A4xGxJiLuJ4sdOH5Fcg2whuwf6BnAfWm/Y1gsb9P9Z+dbnftSr9gQcoynE69+RtJY4F5gVkT8MCLeI+t2nZImFU4CGvuyjdarUcB3JDUBJwGX4xgWyWKgXtJhkuqBzcBKHL8i+ShZ3LaSJdI1wDIcw0JJvVndfXbOB06RNBiYDKwDVufVLt/Hq5+RdDnZ8MbLJbu/SzZ09TFgIXBRGu+2CidpEdlQ1RLgNhzDipcm6V4LfA3YTvZ+XI7jVxiShpHNzTuKLPm6nGy+pWNYAOlzc3FEXCVpNN3ETdJVZF98eQ/4XkQsza19TrzMzMzM8uGhRjMzM7OcOPEyMzMzy4kTLzMzM7OcOPEyMzMzy4kTLzMzM7OcOPEyMzMzy4kTLzMzM7OcOPEys7KR9LSkS9LzIZJ2pJv8Iqla0jZJE/bwGudLWrI32ltS55Wpvb3WLWmSpHZJTWn5kd25XlU6f5ukqbvXajMrAideZlZOjcBp6fkUsmVYpqXtz5DdNfqJPmhXb+aQrdO3s16NiLqIaJO0WNIYAEmHSFrZ28kRsS0i6vhgMV8z66eceJlZOTUCn03L6EwDrgdOSj1Dneum1UiaJ2mVpOckXSbpL5KuAJB0mqRWSQPSzy8krZXULGlG6cW6K0+9Vo9J+rOklyVdnY6tknRLOnaJpJWSZklakKqbD4wEDpXUWHpuL44EXkzPjwWeS234h6SHJL0uaa6kP0h6UdI9kgbtyS/ZzIpjYF83wMz6tUfJFhgeC0wHZqTHU8kWp70VGA2sAb4JfA74E3AecAVwNXAWcEdaX20mMBE4GhgOPAl8v+R65/VQfgzZ4uO1QJOk68nWaasHxgCfBFYARMQ0SZHacipweGrr++dGxIbuXqykEUBryRp+x3bWC9QBI4BxwMNkPX4ryBZhPhZ4qtffppkVnhMvMyubiNgi6VFgJlni8hywAPgicBJZslUFDAN+T7Yg8SDgPuBGSeOAM4HPpypPJOtR6kxS2rpcsqfy5RHxKoCkgcAQsmRsSURsA1ZLWt3Dy+ju3G4TL+A4Pki0AE4A7iJboHd5RGyQ1JJ+N4+nOv8DHNBDfWbWz3io0czKbQFwMdAYEZG2ZwMvRMR6sh6p6og4G7g3ndNOlrBcD7wSEZ3zpFYCq4DxwMnATV2u1VN5dNOuVcCpachxGHBUSVkHsP+HnNuTcaQkStIo4MtkyeaH1bMr9ZtZwTnxMrNyawQGp0eApenxr+nxj8BoSU1kw4otwCVkw5CTgdtL6voN0AQ0A4uAdV2u1Vt5qVvIkq9m4NfpvM4k6EGyBHHkzrzAEscBAyQtJxsqbQLO38U6zKwfU/YfUDOzfYuk48iGPH9Glhi2AGdGxCO7WM8ksjlowyX9Ezg+It7dzTatBWZHxMLdOd/MKp/neJnZvmoN2aT/J8jmYN28q0lXiaEpaWrfnaRLUhWwnGwiv5n1Y+7xMjMzM8uJ53iZmZmZ5cSJl5mZmVlOnHiZmZmZ5cSJl5mZmVlOnHiZmZmZ5cSJl5mZmVlOnHiZmZmZ5cSJl5mZmVlO/gvnc78TDAEjHAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "## Speed-up by hot start" + "plt.figure(figsize=(10, 5))\n", + "plt.errorbar(x=wavelength, y=y_obs, yerr=sigma, marker='x', ls=' ')\n", + "from ultranest.plot import PredictionBand\n", + "band = PredictionBand(wavelength)\n", + "for T, ampl in results_ref['samples']:\n", + " band.add(black_body_model(wavelength, ampl, T))\n", + "band.line(color='k')\n", + "band.shade(color='k', alpha=0.5)\n", + "\n", + "band = PredictionBand(wavelength)\n", + "for T, ampl, _ in res['samples']:\n", + " band.add(black_body_model(wavelength, ampl, T))\n", + "band.line(color='orange')\n", + "band.shade(color='orange', alpha=0.5)\n", + "plt.plot(wavelength, y_true, ':', color='gray')\n", + "plt.ylabel('Spectral flux density [Jy]');\n", + "plt.xlabel('Wavelength [$\\mu$m]');\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Assuming we already obtained the covariance and mean for free, what is the additional cost of the hot start?" + "## Speed-up" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Speed-up of warm-start: 266%\n" + ] + } + ], "source": [ - "print(\"auxiliary sampler used %(ncall)d likelihood calls\" % aux_results)" + "print(\"Speed-up of warm-start: %d%%\" % ((results_ref['ncall'] / res['ncall'] - 1)*100))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Compare this to the full run with the same number of data points." + "The cost savings are higher, the more similar the posterior of the modified run is to the original run. This speed-up increases drastically if you have highly informative posteriors.\n", + "This benefit is *independent of problem dimension*." ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "print(\"Speedup factor of hot start: %.1f\" % (reference_results[-1]['ncall'] / aux_results['ncall']))" + "# Starting from existing posterior samples" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "This speed-up increases drastically if you have highly informative posteriors." + "The hot-starting works by deforming the parameter space. The prior transform function is adjusted, and the adjustment is removed by reweighting the likelihood function, to produce the same posterior.\n", + "To make this work, posterior samples from the unit cube space are required. The deformation uses a factorized auxiliary distribution, based on marginal posterior quantiles.\n", + "\n", + "If you already have posterior samples (or can generate samples from posterior means and standard deviations), and you can untransform to unit cube samples, then you can create an appropriate weighted_post_untransformed.txt file.\n", + "\n", + "The weighted_post_untransformed.txt file from a hot-started run cannot be used. This is because it has a deformation already applied." ] }, { @@ -459,15 +514,12 @@ "source": [ "## Conclusion\n", "\n", - "* Warm start allows accelerated computation based on a different but similar UltraNest run. \n", - "* Hot start allows accelerated computation based on already approximately knowing the posterior peak.\n", - "\n", - "These feature allows you to:\n", + "Hot start allows accelerated computation based on already knowing the posterior peak approximately. This allows you to:\n", "\n", "* vary the data (change the analysis pipeline)\n", "* vary model assumptions \n", "\n", - "**without needing to start the computation from scratch** (potentially costly).\n", + "without needing to start the computation from scratch (potentially costly).\n", "\n", "These features are experimental and feedback is appreciated. It is recommended to do a full, clean run to obtain final, reliable results before publication.\n" ] @@ -475,7 +527,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -489,7 +541,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/docs/index.rst b/docs/index.rst index 10c6d6dd..8145cca4 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -27,6 +27,7 @@ Welcome to UltraNest's documentation! example-line.ipynb example-outliers.ipynb example-sine-bayesian-workflow.ipynb + example-warmstart.ipynb .. include:: ../README.rst diff --git a/tests/test_hotstart.py b/tests/test_hotstart.py index d6ca9b27..6d00f05b 100644 --- a/tests/test_hotstart.py +++ b/tests/test_hotstart.py @@ -4,7 +4,7 @@ from numpy import log10 from ultranest import ReactiveNestedSampler from ultranest.utils import vectorize -from ultranest.integrator import resume_from_hot_file +from ultranest.integrator import warmstart_from_similar_file from ultranest.hotstart import reuse_samples, get_extended_auxiliary_problem from ultranest.hotstart import compute_quantile_intervals, get_auxiliary_contbox_parameterization, compute_quantile_intervals_refined import os @@ -110,7 +110,7 @@ def test_contbox_hotstart(): header='weight logl mean scatter', fmt='%f' ) - aux_param_names, aux_loglike, aux_transform, vectorized = resume_from_hot_file( + aux_param_names, aux_loglike, aux_transform, vectorized = warmstart_from_similar_file( tmpfilename, parameters, extended_log_likelihood, @@ -122,7 +122,7 @@ def test_contbox_hotstart(): assert p.shape == (len(aux_param_names)+1,) L = float(aux_loglike(p)) print(L) - aux_param_names, aux_vloglike, aux_vtransform, vectorized = resume_from_hot_file( + aux_param_names, aux_vloglike, aux_vtransform, vectorized = warmstart_from_similar_file( tmpfilename, parameters, vectorize(extended_log_likelihood), diff --git a/tests/test_run.py b/tests/test_run.py index f684a076..c6c4f1c4 100644 --- a/tests/test_run.py +++ b/tests/test_run.py @@ -6,7 +6,7 @@ import json import pandas from ultranest import NestedSampler, ReactiveNestedSampler, read_file -from ultranest.integrator import resume_from_hot_file +from ultranest.integrator import warmstart_from_similar_file import ultranest.mlfriends from numpy.testing import assert_allclose @@ -493,7 +493,7 @@ def transform(x): print('%15s : %.3f +- %.3f' % (name, col.mean(), col.std())) -def test_run_hotstart_gauss_SLOW(): +def test_run_warmstart_gauss_SLOW(): center = None stdev = 0.001 @@ -523,7 +523,7 @@ def transform(x): loglike, transform=transform, log_dir=folder, resume=resume, vectorized=True) else: - aux_param_names, aux_loglike, aux_transform, vectorized = resume_from_hot_file( + aux_param_names, aux_loglike, aux_transform, vectorized = warmstart_from_similar_file( os.path.join(folder, 'chains', 'weighted_post_untransformed.txt'), paramnames, loglike=loglike, transform=transform, vectorized=True, ) diff --git a/ultranest/hotstart.py b/ultranest/hotstart.py index 2f13cc35..2a9e5d7b 100644 --- a/ultranest/hotstart.py +++ b/ultranest/hotstart.py @@ -338,14 +338,6 @@ def get_auxiliary_contbox_parameterization( likelihood and prior transform that is identical but requires fewer nested sampling iterations. - This is achieved by deforming the prior space, and undoing that - transformation by correction weights in the likelihood. - - The auxiliary distribution used for transformation/weighting is - factorized. Each axis considers the ECDF of the auxiliary samples, - and segments it into five quantile segments. Within each segment, - the parameter edges in u-space are linearly interpolated. - Usage:: aux_loglikelihood, aux_transform = get_auxiliary_contbox_parameterization( @@ -354,6 +346,20 @@ def get_auxiliary_contbox_parameterization( aux_results = aux_sampler.run() posterior_samples = aux_results['samples'][:,-1] + This is achieved by deforming the prior space, and undoing that + transformation by correction weights in the likelihood. + A additional parameter, "aux_logweight", is added at the end, + which contains the correction weight. You can ignore it. + + The auxiliary distribution used for transformation/weighting is + factorized. Each axis considers the ECDF of the auxiliary samples, + and segments it into quantile segments. Within each segment, + the parameter edges in u-space are linearly interpolated. + To see the interpolation quantiles for each axis, use:: + + steps = 10**-(1.0 * np.arange(1, 8, 2)) + ulos, uhis, uinterpspace = compute_quantile_intervals_refined(steps, upoints, uweights) + Parameters ------------ loglike: function diff --git a/ultranest/integrator.py b/ultranest/integrator.py index 99ba85a5..c9e4c291 100644 --- a/ultranest/integrator.py +++ b/ultranest/integrator.py @@ -27,7 +27,7 @@ from .hotstart import get_auxiliary_contbox_parameterization -__all__ = ['ReactiveNestedSampler', 'NestedSampler', 'read_file'] +__all__ = ['ReactiveNestedSampler', 'NestedSampler', 'read_file', 'warmstart_from_similar_file'] def _get_cumsum_range(pi, dp): @@ -915,7 +915,7 @@ def plot(self): plt.close() -def resume_from_hot_file( +def warmstart_from_similar_file( usample_filename, param_names, loglike, @@ -924,6 +924,46 @@ def resume_from_hot_file( derived_param_names=[], min_num_samples=50 ): + """Warmstart from a previous run. + + + + Parameters + ------------ + usample_filename: str + 'directory/chains/weighted_post_untransformed.txt' + contains posteriors in u-space (untransformed) of a previous run. + Columns are weight, logl, param1, param2, ... + min_num_samples: int + minimum number of samples in the usample_filename file required. + Too few samples will give a poor approximation. + + The remaining parameters have the same meaning as in :class:ReactiveNestedSampler. + + Returns: + --------- + aux_param_names: list + new parameter list + aux_loglikelihood: function + new loglikelihood function + aux_transform: function + new prior transform function + vectorized: bool + whether the new functions are vectorized + + Usage:: + + aux_paramnames, aux_log_likelihood, aux_prior_transform, vectorized = warmstart_from_similar_file( + 'model1/chains/weighted_post_untransformed.txt', parameters, log_likelihood_with_background, prior_transform) + + aux_sampler = ReactiveNestedSampler(aux_paramnames, aux_log_likelihood, transform=aux_prior_transform,vectorized=vectorized) + aux_sampler.run() + posterior_samples = aux_results['samples'][:,-1] + + See :py:func:`ultranest.hotstart.get_auxiliary_contbox_parameterization` + for more information. + + """ # load samples try: with open(usample_filename) as f: