analytical_hmc.py

from numpy import sin, cos, arctan, sqrt, exp, random, pi, linspace
import matplotlib.pyplot as plt

def draw_sample(xold, sigma):

    t = 3.0
    vold = random.normal()
    phi = arctan(-vold / xold * sigma)
    A = vold * sigma * sqrt(xold ** 2 / sigma ** 2 / vold ** 2 + 1)
    xnew = A * cos(t / sigma + phi)
    vnew = -A / sigma * sin(t / sigma + phi)

    E = lambda x: 0.5 * x ** 2 / sigma ** 2
    K = lambda v: 0.5 * v ** 2
    H = lambda x, v: E(x) + K(v)

    p_acc = min(1, exp(-(H(xnew, vnew) - H(xold, vold))))

    if random.random() < p_acc:
        return xnew, True
    else:
        return xold, False


sigma = 2.0
samples = [2.0]
accepted = 0
n_samples = 100000
for _ in range(n_samples):
    new_state, acc = draw_sample(samples[-1], sigma)
    samples.append(new_state)
    accepted += acc


fig, ax = plt.subplots()
ax.hist(samples, bins=40, density=True)
gaussian = lambda x: exp(-0.5 * x ** 2 / sigma ** 2) / sqrt(2 * pi * sigma ** 2)
xspace = linspace(-5, 5, 300)
ax.plot(xspace, list(map(gaussian, xspace)))
plt.show()

print("Acceptante rate:", accepted / n_samples)

imgs.sh

#!/bin/bash

img_list=$(ls -v output*.png)
b=$(<$2)

while read strA <&3 && read strB <&4; do
    rstring="..\/..\/img\/posts\/${strB}"
    echo $rstring
    sed -i "s/${strA}/${rstring}/g" $1
    mv $strA $strB
    # cp $strB ~/projects/tweag/www/app/assets/img/posts/
done 3<<<"$img_list" 4<<<"$b"

# cp $1 ~/projects/tweag/www/app/views/posts/

mcmc_introduction_gibbs.ipynb

mcmc_introduction_HMC.ipynb

mcmc_introduction_MH.ipynb

mcmc_introduction_MH.zip

mcmc_introduction_RE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to MCMC, part IV: Fighting multimodality with Replica Exchange"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is part 4 of a series of blog posts about MCMC techniques:\n",
    "- [The basics](https://www.tweag.io/blog/2019-10-25-mcmc-intro1/)\n",
    "- [Gibbs sampling](https://www.tweag.io/blog/2020-01-09-mcmc-intro2/)\n",
    "- [Hamiltonian Monte Carlo](link)\n",
    "\n",
    "In the previous three posts, we covered both basic and powerful techniques that already get you quite far in everyday problems and are implemented in probabilistic progamming packages such as [PyMC3](https://github.com/pymc-devs/pymc3) or [Stan](https://mc-stan.org/).\n",
    "In the (for now) final post of this series, we will leave behind the MCMC mainstream and discuss a technique to tackle highly multimodal sampling problems. \n",
    "\n",
    "As we saw in the Gaussian mixture example in the Gibbs sampling blog post, a Markov chain can have a hard time overcoming low-probability barriers in the limited time we are simulating it.\n",
    "Such a stuck Markov chain thus samples a distribution incorrectly, because it oversamples some modes and undersamples others.\n",
    "A cool way to overcome this problem is to not simulate only from the distribution of interest, but also flatter versions of it, in which low-probability regions can be crossed more easily.\n",
    "If we then occasionally exchange states between these flatter Markov chains and the Markov chain sampling the distribution of interest, the latter chain will eventually get unstuck, as incoming states from flatter distributions are more likely to be located in a different mode. \n",
    "This is the principal idea of Replica Exchange (RE), also known as \"Parallel Tempering\" (PT) or \"Metropolis Coupled Markov Chain Monte Carlo\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replica Exchange\n",
    "Just as several other MCMC algorithms, RE has its [origins](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.57.2607) in computational physics and just as before, we will help ourselves to some physics terminology. \n",
    "In RE, we need some concept of what it means to make a probability distribution \"flatter\".\n",
    "The most simple way, which is inspired by statistical physics, is to consider a family of distributions $p_\\beta(x) = p(x)^\\beta$ with $p_1(x)=p(x)$ being the distribution we're actually interested in.\n",
    "If we define $\\beta$ as proportional to the inverse of a temperature $T$, $\\beta\\propto\\frac{1}{T}$, a very small $\\beta$ would correspond to a very high temperature $T$.\n",
    "The distributions $p_\\beta(x)$ with $1>\\beta > 0$ thus describe the same physical system at higher (or lower inverse) temperature.\n",
    "In a high-temperature system, energy barriers can be more easily crossed, because particles move faster.\n",
    "Configurations can thus more easily be sampled exhaustively.\n",
    "Let's write a function which plots a given probability density for different inverse temperatures and see how a family of tempered distributions could look like in the case of a Gaussian mixture:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x504 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from scipy.integrate import quad\n",
    "\n",
    "###### begin copy and paste from previous blog posts ######\n",
    "proposal = lambda x, stepsize: np.random.uniform(low=x - 0.5 * stepsize, high=x + 0.5 * stepsize, size=x.shape)\n",
    "p_acc = lambda x_new, x_old, log_prob: min(1, np.exp(log_prob(x_new) - log_prob(x_old)))\n",
    "\n",
    "def sample_MH(x_old, log_prob, stepsize):\n",
    "    x_new = proposal(x_old, stepsize)\n",
    "    # here we determine whether we accept the new state or not:\n",
    "    # we draw a random number uniformly from [0,1] and compare\n",
    "    # it with the acceptance probability\n",
    "    accept = np.random.random() < p_acc(x_new, x_old, log_prob)\n",
    "    if accept:\n",
    "        return accept, x_new\n",
    "    else:\n",
    "        return accept, x_old\n",
    "    \n",
    "def build_MH_chain(init, stepsize, n_total, log_prob):\n",
    "\n",
    "    n_accepted = 0\n",
    "    chain = [init]\n",
    "\n",
    "    for _ in range(n_total):\n",
    "        accept, state = sample_MH(chain[-1], log_prob, stepsize)\n",
    "        chain.append(state)\n",
    "        n_accepted += accept\n",
    "    \n",
    "    acceptance_rate = n_accepted / float(n_total)\n",
    "    \n",
    "    return chain, acceptance_rate\n",
    "\n",
    "    \n",
    "def log_gaussian(x, mu, sigma):\n",
    "    # The np.sum() is for compatibility with sample_MH\n",
    "    return - 0.5 * np.sum((x - mu) ** 2) / sigma ** 2 \\\n",
    "           - np.log(np.sqrt(2 * np.pi * sigma ** 2))\n",
    "\n",
    "\n",
    "class GaussianMixture(object):\n",
    "    \n",
    "    def __init__(self, mu1, mu2, sigma1, sigma2, w1, w2):\n",
    "        self.mu1, self.mu2 = mu1, mu2\n",
    "        self.sigma1, self.sigma2 = sigma1, sigma2\n",
    "        self.w1, self.w2 = w1, w2\n",
    "        \n",
    "    def log_prob(self, x):\n",
    "        return np.logaddexp(np.log(self.w1) + log_gaussian(x, self.mu1, self.sigma1),\n",
    "                            np.log(self.w2) + log_gaussian(x, self.mu2, self.sigma2))\n",
    "    \n",
    "    def log_p_x_k(self, x, k):\n",
    "        # logarithm of p(x|k)\n",
    "        mu = (self.mu1, self.mu2)[k]\n",
    "        sigma = (self.sigma1, self.sigma2)[k]\n",
    "    \n",
    "        return log_gaussian(x, mu, sigma)\n",
    "    \n",
    "    def p_k_x(self, k, x):\n",
    "        # p(k|x) using Bayes' theorem\n",
    "        mu = (self.mu1, self.mu2)[k]\n",
    "        sigma = (self.sigma1, self.sigma2)[k]\n",
    "        weight = (self.w1, self.w2)[k]\n",
    "        log_normalization = self.log_prob(x)\n",
    "\n",
    "        return np.exp(log_gaussian(x, mu, sigma) + np.log(weight) - log_normalization)\n",
    "\n",
    "###### end copy and paste from previous blog posts ######\n",
    "\n",
    "def plot_tempered_distributions(log_prob, temperatures, axes, xlim=(-4, 4)):\n",
    "    xspace = np.linspace(*xlim, 1000)\n",
    "    for i, (temp, ax) in enumerate(zip(temperatures, axes)):\n",
    "        pdf = lambda x: np.exp(temp * log_prob(x))\n",
    "        Z = quad(pdf, -1000, 1000)[0]\n",
    "        ax.plot(xspace, np.array(list(map(pdf, xspace))) / Z)\n",
    "        ax.text(0.8, 0.3, r'$\\beta={}$'.format(temp), transform=ax.transAxes)\n",
    "        ax.text(0.05, 0.3, 'replica {}'.format(len(temperatures) - i - 1), \n",
    "                transform=ax.transAxes)\n",
    "        ax.set_yticks(())\n",
    "    plt.show()\n",
    "\n",
    "mix_params = dict(mu1=-1.5, mu2=2.0, sigma1=0.5, sigma2=0.2, w1=0.3, w2=0.7)\n",
    "mixture = GaussianMixture(**mix_params)    \n",
    "temperatures = [0.1, 0.4, 0.6, 0.8, 1.0]\n",
    "fig, axes = plt.subplots(len(temperatures), 1, sharex=True, sharey=True,\n",
    "                        figsize=(8, 7))\n",
    "plot_tempered_distributions(mixture.log_prob, temperatures, axes)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I hope you agree that the upper distributions look somewhat easier to sample.  \n",
    "A key component of RE are the exchanges.\n",
    "But how exactly are they performed?\n",
    "Naively, you would probably do the following: if, after $k$ steps of sampling, the Markov chain $i$ is in state state $x^i_k$ and the Markov chain $j$ is in state $x^j_k$, then an exchange of states between the two chains leads to the next state of chain $i$ being in state $x^i_{k+1}=x^j_k$, while chain $j$ will assume $x^j_{k+1}=x^i_k$ as its next state.  \n",
    "Of course you can't just swap states like that, because the exchanged states will not be drawn from the right distribution.\n",
    "So what do we do if we have a proposal state which is not from the correct distribution?\n",
    "The same thing we always do:\n",
    "we use a Metropolis criterion to conditionally accept / reject it, thus making sure that the Markov chain's equilibrium distribution is maintained.\n",
    "So the probability to accept the exchange is the probability $p_{j\\rightarrow i}$ to accept the new proposal state in chain $i$ times the probability $p_{i\\rightarrow j}$to accept the new proposal state in chain $j$.\n",
    "Here's the full expression for the exchange acceptance probability:\n",
    "$$\n",
    "p^\\mathrm{RE}_\\mathrm{acc} (x^i_{k+1}=x^j_k, x^j_{k+1}=x^i_k | x^i_k, x^j_k) = \\mathrm{min}\\left\\{1, \\underbrace{\\frac{p_{\\beta_i}(x^j_k)}{p_{\\beta_i}(x^i_k)}}_{p_{j\\rightarrow i}} \\times \\underbrace{\\frac{p_{\\beta_j}(x^i_k)}{p_{\\beta_j}(x^j_k)}}_{p_{i\\rightarrow j}}\\right\\}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to not always swap between the same replicas, because then states originating from the high-temperature replicas would never be able to eventually arrive at the low-temperature replicas.\n",
    "Instead, we make sure that all replicas are connected to each other.\n",
    "We best do this by swapping only replicas adjacent in the temperature ladder, because acceptance rate will decrease if the distributions are too different.\n",
    "Furthermore, if a replica is not participating in a swap, we just draw a normal sample.\n",
    "Okay, let's implement this (for brevity, the handling of the border cases is not shown, but the full code is available in the [notebook](https://github.com/tweag/blog-resources/blob/master/mcmc-intro/mcmc_introduction.ipynb)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def handle_left_border(leftmost_old_state, leftmost_temperature, \n",
    "                       leftmost_stepsize, log_prob, new_multistate):\n",
    "    accepted, state = sample_MH(leftmost_old_state, \n",
    "                                lambda x: leftmost_temperature * log_prob(x), \n",
    "                                leftmost_stepsize)\n",
    "    new_multistate = [state] + new_multistate\n",
    "    return new_multistate, accepted\n",
    "\n",
    "\n",
    "def handle_right_border(rightmost_old_state, rightmost_temperature, \n",
    "                        rightmost_stepsize, log_prob, new_multistate):\n",
    "    accepted, state = sample_MH(rightmost_old_state, \n",
    "                                lambda x: rightmost_temperature * log_prob(x),\n",
    "                                rightmost_stepsize)\n",
    "    new_multistate = new_multistate + [state]\n",
    "    return new_multistate, accepted\n",
    "    \n",
    "    \n",
    "def build_RE_chain(init, stepsizes, n_total, temperatures, swap_interval, log_prob):\n",
    "    \n",
    "    from itertools import cycle\n",
    "    \n",
    "    # a bunch of arrays in which we will store how many\n",
    "    # Metropolis-Hastings / swap moves were accepted\n",
    "    # and how many there were performed in total\n",
    "    accepted_MH_moves = np.zeros(len(temperatures))\n",
    "    total_MH_moves = np.zeros(len(temperatures))\n",
    "    accepted_swap_moves = np.zeros(len(temperatures) - 1)\n",
    "    total_swap_moves = np.zeros(len(temperatures) - 1)\n",
    "    \n",
    "    cycler = cycle((True, False))\n",
    "    chain = [init]\n",
    "    for k in range(n_total):\n",
    "        new_multistate = []\n",
    "        if k > 0 and k % swap_interval == 0:\n",
    "            # perform RE swap\n",
    "            # First, determine the swap partners\n",
    "            if next(cycler):\n",
    "                # swap (0,1), (2,3), ...\n",
    "                partners = [(j-1, j) for j in range(1, len(temperatures), 2)]\n",
    "            else:\n",
    "                # swap (1,2), (3,4), ...                \n",
    "                partners = [(j-1, j) for j in range(2, len(temperatures), 2)]\n",
    "            # Now, for each pair of replicas, attempt an exchange\n",
    "            for (i,j) in partners:\n",
    "                bi, bj = temperatures[i], temperatures[j]\n",
    "                lpi, lpj = log_prob(chain[-1][i]), log_prob(chain[-1][j])\n",
    "                log_p_acc = min(0, bi * lpj - bi * lpi + bj * lpi - bj * lpj)\n",
    "                if np.log(np.random.uniform()) < log_p_acc:\n",
    "                    new_multistate += [chain[-1][j], chain[-1][i]]\n",
    "                    accepted_swap_moves[i] += 1\n",
    "                else:\n",
    "                    new_multistate += [chain[-1][i], chain[-1][j]]\n",
    "                total_swap_moves[i] += 1\n",
    "            # We might have border cases: if left- / rightmost replicas don't participate\n",
    "            # in swaps, have them draw a sample\n",
    "            if partners[0][0] != 0:\n",
    "                new_multistate, accepted = handle_left_border(chain[-1][0], temperatures[0],\n",
    "                                                              stepsizes[0], log_prob,\n",
    "                                                              new_multistate)\n",
    "                accepted_MH_moves[0] += accepted\n",
    "                total_MH_moves[0] += 1\n",
    "            if partners[-1][1] != len(temperatures) - 1:\n",
    "                new_multistate, accepted = handle_right_border(chain[-1][-1], temperatures[-1],\n",
    "                                                               stepsizes[-1], log_prob,\n",
    "                                                               new_multistate)\n",
    "                accepted_MH_moves[-1] += accepted\n",
    "                total_MH_moves[-1] += 1\n",
    "        else:\n",
    "            # perform sampling in single chains\n",
    "            for j, temp in enumerate(temperatures):\n",
    "                accepted, state = sample_MH(chain[-1][j], lambda x: temp * log_prob(x), stepsizes[j])\n",
    "                accepted_MH_moves[j] += accepted\n",
    "                total_MH_moves[j] += 1\n",
    "                new_multistate.append(state)\n",
    "        chain.append(new_multistate)\n",
    "        \n",
    "    # calculate acceptance rates\n",
    "    MH_acceptance_rates = accepted_MH_moves / total_MH_moves\n",
    "    swap_acceptance_rates = accepted_swap_moves / total_swap_moves\n",
    "        \n",
    "    return MH_acceptance_rates, swap_acceptance_rates, np.array(chain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we can run this beast, we have to set stepsizes for all the single Metropolis-Hastings samplers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "stepsizes = [2.75, 2.5, 2.0, 1.75, 1.6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the step size decreases:\n",
    "the more pronounced the modes are, the lower a step size you need to maintain a decent Metropolis-Hastings acceptance rate.\n",
    "Let's first run the three Metropolis-Hastings samplers independently by setting the `swap_interval` argument of the above function to something bigger than `n_total`, meaning that no swap will be attempted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MH acceptance rates: 0: 0.787 1: 0.574 2: 0.481 3: 0.704 4: 0.697 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nix/store/afqyxbhx060flvyp1w2rrcihjj64y9yp-python3-3.7.6-env/lib/python3.7/site-packages/ipykernel_launcher.py:80: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    }
   ],
   "source": [
    "def print_MH_acceptance_rates(mh_acceptance_rates):\n",
    "    print(\"MH acceptance rates: \" + \"\".join([\"{}: {:.3f} \".format(i, x)\n",
    "                                             for i, x in enumerate(mh_acceptance_rates)]))\n",
    "    \n",
    "    \n",
    "mh_acc_rates, swap_acc_rates, chains = build_RE_chain(np.random.uniform(low=-3, high=3, \n",
    "                                                                        size=len(temperatures)),\n",
    "                                                      stepsizes, 10000, temperatures, 500000000, \n",
    "                                                      mixture.log_prob)\n",
    "print_MH_acceptance_rates(mh_acc_rates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's visualize the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x504 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_RE_samples(chains, axes, bins=np.linspace(-4, 4, 50)):\n",
    "    for i, (chain, ax) in enumerate(zip(chains, axes)):\n",
    "        ax.hist(chain, bins, density=True, label=\"MCMC samples\")\n",
    "        \n",
    "fig, axes = plt.subplots(len(temperatures), 1, sharex=True, sharey=True,\n",
    "                         figsize=(8, 7))\n",
    "plot_RE_samples(chains[100:].T, axes)\n",
    "plot_tempered_distributions(mixture.log_prob, temperatures, axes)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find, as expected, that the replicas with lower inverse temperature are sampled much more exhaustively, while the Metropolis-Hastings sampler struggles for $\\beta=1$ and perhaps already $\\beta = 0.9$.\n",
    "Now we couple the chains by replacing every fifth Metropolis-Hastings step by an exchange step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MH acceptance rates: 0: 0.794 1: 0.576 2: 0.553 3: 0.520 4: 0.492 \n",
      "Swap acceptance rates: 0<->1: 0.603, 1<->2: 0.819, 2<->3: 0.864, 3<->4: 0.866\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x504 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "init = np.random.uniform(low=-4, high=4, size=len(temperatures))\n",
    "mh_acc_rates, swap_acc_rates, chains = build_RE_chain(init, stepsizes,\n",
    "                                                      10000, temperatures, 5, \n",
    "                                                      mixture.log_prob)\n",
    "print_MH_acceptance_rates(mh_acc_rates)\n",
    "print(\"Swap acceptance rates: \" + \"\".join([\"{}<->{}: {:.3f}, \".format(i, i+1, x)\n",
    "                                           for i, x in enumerate(swap_acc_rates)])[:-2])\n",
    "fig, axes = plt.subplots(len(temperatures), 1, sharex=True, sharey=True,\n",
    "                        figsize=(8, 7))\n",
    "plot_tempered_distributions(mixture.log_prob, temperatures, axes)\n",
    "plot_RE_samples(chains[100:].T, axes)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et voilà! Thanks to coupling the replicas, we manage to sample correctly even at $\\beta=1$!  \n",
    "\n",
    "A nice way to think about what is happening in the course of a RE simulation is to look at what happens to the initial state of a replica.\n",
    "The initial state will be evolved through some \"local\" sampling algorithms for a few steps until an exchange is attempted.\n",
    "If the exchange is successful, the state moves up or down a step on the \"temperature ladder\" and is evolved on that step until at least the next attempted exchange.  \n",
    "We can visualize that by first detecting, for each pair of replicas, at which simulation time points a successful swap occured and then reconstructing the movement of a state from the list of swaps.\n",
    "This yields, for each initial state, a trajectory across the temperature ladder.\n",
    "The code for reconstructing the trajectories is skipped here, but can be found in the [notebook](https://github.com/tweag/blog-resources/blob/master/mcmc-intro/mcmc_introduction.ipynb).\n",
    "For clarity, we only plot the trajectories of the intial states of the target and the flattest replica:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfUAAAFzCAYAAAAnoZDUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9d7glV3Ulvk7VvR0kdStnqZVQQFgIFE1G5DgCgwEZY4wDP4Lj2B4zHhzG2DDMmDHGYDBjGKwf2DiRjGURZBMEkiyJqIiEUktCakndanV8r8KZP6pOVd3u1+q7V93a91S9s76vP+ndVOeee+rss9fee21jrUVAQEBAQEBA/xHNewABAQEBAQEBs0Ew6gEBAQEBAQNBMOoBAQEBAQEDQTDqAQEBAQEBA0Ew6gEBAQEBAQNBMOoBAQEBAQEDwWjeA2iLQw45xB5//PHzHkZAQEBAQIAarr322gettYfu+njvjfrxxx+Pa665Zt7DCAgICAgIUIMx5s6lHg/0e0BAQEBAwEAQjHpAQEBAQMBAEIx6QEBAQEDAQBCMekBAQEBAwEAQjHpAQEBAQMBAEIx6QEBAQEDAQBCMekBAQEBAwEAQjHpAQEBAQMBAEIx6QEBAQEDAQKBq1I0xLzDG3GyMudUY87Ylnj/NGHOFMWbBGPObmmMLCAgICAjoO9RkYo0xMYAPAHgugLsBXG2M+Zy19obGyzYC+BUAL9MaV0BAQEBAwFCgqf1+HoBbrbW3AYAx5pMALgRQGXVr7QYAG4wxL1YcV41bLwNu/+qMP9QAj30pcMw5ondZa/GJq+7C+k3bRe/78RMOxgWnHSZ6Tx+wM8lw8RV34KFti1O/x8DgwiMewmMf+hJg8+4G53DcU4BTnt/9dQBs2raIj195J7YuplO/ZxQZvPyJx+Axh+0nu1i6AFz1l8D2B0Vvu+OQC/B39x+J3FrZ9ZSwchTjteevw+FrV8neuH0jcPVHgMUt3Qysif2OAM57IxALt+r7rgOu+0fZul+5trjWqrWya/UAV932EP7t5g1zHcMrzjoGpxy+pvPraBr1owGsb/x9N4DzmQ8yxrwRwBsBYN26de1H5nDXlcA3/mx2n+fww8uAN10uesuNP9qCt3/mOvGlLv7mnbjhD58PY4z4vT7jKzdvwDsvuUn8vhfu9y4g/X4HI1oCV30Y+J17gaj7qNbfX7Me7/nSD8Tvu3XDVvzl62QHTNzyJeBLvyu+VjT6LD649Z3i92liZ5Lhd170WNmbvvMJ4N//qJsBLYXDTwdOfKbsPV/4Hc5BWX0gcO7Py9/nOX7jH76LuzftmOsYzl534OCM+lJWhjrCW2s/DODDAHDOOefMzg046QJgxT4z+zjs2FQcEnY+In7rlp0JAOCYA1fjtecfN9V7/ucXbsKOJEOWW4ziYRn1R3YUHukZR++PF51x5F5fv3lHgg999YdYnW0tHjj/TcCaI7ob4GV/CKQ7gDwFohXdXafEI+X6eNrJh+DJJx2y19ff+dA2fPLq9diyc3rPvsLOzcV/jzwTeNzLp3v95X+KVfk2AMDrn3Qcjth/tfy6HeI76zfhC9ffX91nIrj5OPEC4MRnzHZgTXz3k8ADN1H7BxbK95z7i8D+R+/99bd8Gbjz8vp9A4Nb97/y7JOxehzPZQwnKxh0QNeo3w3g2MbfxwC4V/H6e8dxTy7+zQoPry+Mep6J35rlxVnl2AP3wZufedJU7/nTL/0Ai1mONLcYzWfddoa0nI/HHbV2qvn40eYd+NBXf4gI5dyf9TPA4Y/rboBf+R9AurMw6ujeqLv5eNJJB081H1fe9hA+efX66n0i5OVB4IgzgKf++t5f/8iPgMv/FLEt5v7V567D6Uf5Ren+/dXr8YXr70eatZiPE5423XywuPfbhVHPiYOYe89ZrysOY3vDwpbCqDPX6gHcfvqLTzsBa1aN5zyabqGZ/X41gJONMScYY1YAeA2AzyleXx9xuXhyuTeQlItQ4nG711Ibt+dI8yI2OO18jEoKfGTLTSrq+EaO+N+agTNG4ymp/rFbGxmRW+C+07RzWK77GOnEtX1Cq3slE84Hi2pNEYY2E65797psmEY9Kdf9OB5+Fbeap26tTY0xvwTgCwBiAB+11l5vjHlT+fyHjDFHALgGwFoAuTHm1wCcbq3tJycUldObyTd6t/mOouk3xDhqsXF7jqQ0YqMpjZibt9h56lHH1IX7fKVN0f3G8ZTrIy7njTNizkBMuV2Uc+EOVNOOURNuTAl1yBHOB4sW+0d9EJv2NxtNvm9gcOvex7U4a2jS77DWXgLgkl0e+1Dj/+9DQcsPA9WNIt/oKyMmOFm6U+gQPfUslx1ynCc2smmRzRF37FXFLbwqAo7JmdYLHlVGjKGby41+2jmMnKdeHKh89I6qe4WZj0w4HyziFoa2GuOUW3zc4gDhOay1Ff0ucZL6Cv/utiGhxUafCTdtoF6w1EblOaSHHLdpxyg9sYHR7xk5H+5wJILUM40njbqPSZvVvdImx6BzT73FQdHl8UjpdyL/x3ekDYM+tKqgpRCMepdoQ7/njl6d/icataEUPUeayU7acUW/94AqJZDkUvq9xYFPTL8XrxuVRt1HyrOOqfeBfmeMeqDfHdya93EddoFg1LtE03sTCnAkVSKUJFHOeWPD89QzcaJc8bqxi6lLxTukqKhSHU+nSpSbcj7c6xLKiEnp9xiAQQSLCPnUyXyacLkZftPvLdgf6RgHTL+7Ne9jGKgLLI9vOS9EEWDKKRYqmkmNWPO1lPfhOeoY8nRL1hiDUWQaiXIDo99zYeKgO/C1KeGSzGFpTEbI/KTf++Spt6Lfp/XUdXNCNFGHqvxbh10gGPWuUZWKyDZ7KlGu3OCpZCjPwVQDjGJTUcBqXpUW/V6V6EzpqbvQTJsSLgnbEdVG3UcPqVWinJTaZhG3KDMTsystDhCeI6mSbP1bh11geXzLeYKMVbUraRueUU+IuNgoimr6vXOvqixp06pTr0p0pruFW5U7Mp5pFVdPvYxlxq0OOeV8dH1QbBPnzoQHD+VDqSak+Th9RzDqXSPmTsCpkF4FGgIjA6TfMyH9DgDjyCIyFhZGoU5dN3s4FYoTjdqUOxL0u42dUc+93Ewdq9WuGsBj8RnpGAfsqWeEkFefEYx61yCVmlKmpG3AdepSRTkAWBWV89C1R9W8hpKn4zxuuaKcLv2+Ksq8LCMatZmPin7v+KDIJq/lGQBb5PNM6xQM2KgvJzU5IBj17tGSfpdQl61UsjxHQlBoq6LCa7ZGQQhfuSRIWqZT0e9tst8F9LstDd7KyM+12Kr8U51+FxpaKfUODJt+X0ZqckAw6t2DFKCp6VU5/T7MkjZ5OGJlXM5D1zQpoO7ppLk0Ua4N/U5UEDhPPfZzLbYq//SdfmfGN+Ds9xBTD5gtSFGSlKlTb1N76zmcRyWi3+PiPbbrJDmgXaYyAemhL4oMIlPIJYgNGVGX7ebcf0/d5+x3ln5nwiW6iZ6aSEOdesBMQXpwlWIYIRM7RPo9FTZ0AYCVpqTfNYy6Mv3OhCNGVcmjcH0QMWQX8lgZ+Sk72qpOnckxYMCuKakCIKB+KNUEUznTZwSj3jXIWJW0tSZQb1RDpN+l2d5A7SXmRtOo63ZpU2nNK23jCcA6+t34ecBsxWpp0+9SQyttldt87RA9daGmQ98RjHrXIDd7pgzDUbFU7a3nkMaQAWBlmf0+RPqdyTFwXr1YVS6XJ4bl5ZyviP006mP2gAPoKcqxDaGI32vI2e/MvdJnLI9vOU+w9DujoDbgfup1tvf0S3aFo99VPXXdhi4yhT136GPpd0H2u6PfPfXUW4nxaGm/s3HujCi5q+L3wzPqSahTD5gpWtLvkuz3UZsMZ89ReepESVuuElPXzR5OCT1rujUvUSLlQh6+JsqN27Ba2q1XxfR7m+z34dLvIfs9YDYgN/tmD+Bp0UpgxHMwh5wVJf2uElNX7nKVMgp7lTiR1FOX6+fn5bpf4amnXoUi2hh1tS5tCvQ7e60egCkP7jOWx7ecJ0gKjVFQayUw4jkSQkDC0e+5qviMbqIcI04kPvS1oN9XeJr9HjeMuhW2RabEXRjQ2e8E/e5eO0TxmVCnHjBTkAlUTAlXq85TniMjEuVqoz5c+p2pjhAf+jJ5NnVWzrmvnrprzQsQtepadeqkxkUQn5lE7SAtD3O3PL7lPEHT73IjNhqwp84ccpYD/S5hcmhVuYp+l8fUV3gaUwdalIAS4QgKFSUuZDsC/T4BRsirzwhGvWvEHIXGGLEqu3mAnrq0fzhQU7+6nrqWUW9Rp057poKYuqPfjZ/0O1AfcsTVAGr0O7mmCGaFZgV6AOZe6TOCUe8a5M1SxZAJT32I4jMZE1NHcTNnqjH17o2YtbahKCevUxcryhFGLIOj3/016rHiIYcCTb8zMfXh1qknRDlsn7E8vuU8QfbZrmLITMx0gHXq7sYUZXtrJsopdrlyZzZjZIccuolJRedK6PdizseextSBZgmoYIx5Dtjy9VqtV8X0OxEeGDD9nlWVIsFTD5gFYo5CS4g65Fa1t56DodCcl+i8xk6hKD6TCHupO/CJYfLEK98T5QCyBLRZo951n/hAv88EtZDX8jB3y+NbzhNkqQgjmBAH+n0CIzNM+p3tD90++11CvztP3WP6nSnx06LeAWX6vXGAkJb4eQ4mqbTPCEa9a5DZ7xkhmDDkLm0JUcKl6qkr0u8ZweIALRQHiWzqrAf0OyXGoyU8AzTodw3t9wgw5b1l/f3NGGSEkFefEYx61yBjVUxrzSHXqTNdycZlolyq6qkr0O9kf2hacZCQRU3Lg9QY/nrqdQmoYD6qjnUaa4qMcxNd9YrXD5OCr+j3UKceMBOQN0o7RbkBGnWi09LYFJubo4I7hWL2cN3cRuZ50E1MKPq9+J3G8DfxKmaYrV7R70KGaqD670FRLmC2ID04TlFuuNnvTFxsVHqJqYZRV2y9WifKSWPqZCKlW7sCOrfy1PtAv0uYC60Obc1rsIlygmqFidcPzVMPdeoBMwWpCpUSZRhD7dJmraXiYs6gpCrZ73peDpNvAdSHgEwSQ7a2Vfb7yONEuRHTUz3XpN/ZkraW9LtCsqcmMiIfp89YHt9ynmDpd6JhB7VJ9QDNbG8jKCNynnqmscyrxj0K9DvRSx2oxTdEJW3VBm+KZKopkdritaM+xNRF9DtpMBm01n4P9DvAV4v0FcGodw2Sfk8qT53opz4w+p2NiY3KeG6iSr9r1Klz2e9cXTZHN7uQh9+JcgSz1Sv6XThGxTWsCUZius8IRr1rkNnvDN3sNvmhab/T2d5OJlaVfu/eU8+IpEGg2cCke880dfS7z0a9Ff2uvKYkteO0p67HNmmCDVf1FcvjW84TEZdAxZRhjJlNuwdg67JjMwdPXWFDZD2PEUO/k0lXiS3m3GejXifKMdnvGka9UTsuiXOztfQDbb/KlAf3GcGod43W2e+SkrZhJsolZAx5ZMvsd6sYU1egLmlFOaY1L+n1uTmPe1HSRtSpa9DvALd/sF3kBkq/hy5tAbMFqQqVESVc44EqyjHlfUAtE6viqSt6OdV8COnEUUwc+kj6PYGj3/1dizWz5Sn9DnDrKtDvE2A0LvqM5fEt5wmWfqe6tJFduDwHc8ABgNiW9LtVlIlVzH6X0u9UohyZdJVU2e/+GgiuS5si/Q5wteNkcuNQ6fc0JMoFzBQEfZblFtYWTaAioqHL4BLliOY2QE39Jir0u55wR0r2h6YU5ci6bJf9Hlt/Y+pU17q50e8CQ5uRnvpQ6ffQTz1gpiA8uJTw0oGGJzawRLmUzF6NrSb9rqf9XgkTCQ85Y0X6fREupu6xUW9VDdAH+p0VnxmYpx66tAXMFIQHl7btwjUwT711nbqGp04qBzJgmtsAbAMTkn7PS0/dZ/o9JqoBNLXfAc57zkmZWMWDqSZYJ6mvWB7fcp4gTr9sw47hKspxRiyqYuqKnrqG+AyZ+NOugYlsDhfLOXe/gY+gFOVYXXUWTPJaa/rd39+MQULup31FMOpdow39Ls1uZrtweY6EzH531O+iplFX0X7nDjljJpHSMQ9S8RlX0uZ1TJ0JR7j5CPR7X5ARfTT6jGDUuwZDvxNqckC9aQ8tUY7NXnUGZVGTflfp0tZOUY4Tn5EZiIUeJMqNKUW5PtHvrFEfGP0e+qkHzBTE6ZfO9q66cA3LqGek2EpUzrmKUZ9DP3VxjgGV/c6VcCV5Mec+0+9UNcDc6HdGfEbIUA00+z0oygXMFsSNwouLDDP7nWluAwBRmaS1mGsYdb0OV2yOQasGJkKjvpj3IKbeKlFOmX6XMECBfp9AUJQLmC2ImBhbgjFmtL17gJRkLqKS+lVJlKtEQvQ8dXHOBUU3l/S5lH4v2ZHI45K2McNskTkGNBhRo6D9PoGgKBcwWxD0Gd0vm5G97AFqrXOhp15uTgsqnroi/V6uD7n2u14DE1dGGHlsINz9kkiYLc3Wq0BL7Xcp/a5XwaEJNlzVVwSj3jWIBCpW67z21IdFv9eeqdRTLzYnnZi6Hv3O9lNvlSgnNOo7exBTHzO6DmSJHw2mVDLQ7xNgdR36imDUu0YL+l3cWnPwdepCT72k3xdU6He9JKOqRIdUHKQU1ISeaS/q1Fs1dNGm30PrVRYpmZPTVyyPbzlPxHIPji3BGDVihNYOx7BXnrqQPjOlQVnINOrUYwAGgAU6TlTkFeX0ZGJdyMN4bCDqRDkJ/a6t/U4wQBlZdjfQ7He2RLivCEa9a1R9tiUlbVwJlzGmLtMZkLfOxpCdQVnMlW5mpTrfhNykRoyiHEm/L/SAfq9L/HzOfnf7B1GnLg0RMOVzPUBdIrw8zN3y+JbzBEFptVFAojYqz5GQJX41/a60zJU8nboVLddPnaKbhXXZrqTNKGjhs6C08LUbulDZ71zFQr1X+fubMWBbN/cVwah3DYJ+T3L+ZFl34hpOshx7yDHlnO/MtZKadGKSrDgRlShH0u87bXEt47HXR90rc6PfJdrvgX5vgm2Q1VcEo9412nRpI2JA8SA99Xb0+4Ia/U403yDQWlGOKeGS0u+Z/zF16l7Rlomlst/JEMFAZWLbOEl9xPL4lvNEdaNMT2mxDTuA2psV1d56Djp7VbNOHVDzdNj+8lRrXjKTesGxIx7H1MeMAmPFXCixPzFRZkaGTIZY0pbnFtYCxoQubQGzAkO/kzFkoN64hyRAk5GJYc5L3KmR/Q6o0e9sg5t2DUxkBmJH5uh3fw0EdchRF59h6Hey7G6ArVeTZdZLHQhGvXtQXdq4mCkwbPpdPB9VTH3WI9oDlLKHWYU9roEJlxg2UdLmaXllrSjncZ26Kv2uJ6CkhXSZ9VIHglHvHu7GstnUmxvbWhNo0O8DUpVjG9yY0iAldqTDXCh5OgntqbdoYCL0TJPcVj3VfaVzx4xsLpljQINg+mg2gSmf8xzLLUkOCEa9exgjjlW1KmljypY8B9vgxs13glinGkCJfs/IBhXtFNRkRizLLVLoJA6y4BrckPFqFkycu2o6Ixwjo17nOdx9v1zU5IBg1HUgpNBSMtsbaAqMDMiot6TfM8Q64Qgt8RmSUowVs9/TrGHUPfX8uP7y86LfJUY90O8OdagqeOoBs4TwZknI1prAMHuqU60TrZ301DWMulL71dr7UGjNS2a/J3neA09dr788DVX6fXhd2qpQVTDqATNFLCtrY7O9i/cQG5XnoIxYOdcpIgBmmPQ72U+96wYmrozIe6NO1alri88I6Xdri/yd5nunBVM+5znYe6XPWD7fdJ6IZPXLCdmVDGiULQ2KfiduzNKzSVFsVCqHHMarIsB6H2OqgYnz+qY3EG79urn31fOjFOW0td+l2gfNHAgjdAoG2KWNbVPcZwSjrgFhrHU2inLDod+pGHLm4umKPeaVsofZMh2q2Q+RKOfGl8HvBiFU+SdZ4kdD6qm3CQ8MkH5vUx7cVwSjrgEhrUVne6PpfQzHU88o+r2Y66z0FlWqAZQaYvCKckRrXoJ+d+NLjTPqfmZTc2I8nmu/t0nkGyD9nrYoD+4rVL+pMeYFxpibjTG3GmPe9iivO9cYkxljXqk5vs4QyeqXa8UwRlFueIlyCZMoV25MzrCoVAMo0e9sopwxRt6ZjEi6cus385x+rxLlRNnvytrvsXAO25TcDZB+T1uUB/cVakbdGBMD+ACAFwI4HcBFxpjT9/C6dwP4gtbYOoeUfm9RhhEzGc6egyppKzfBvKSAdRLldIxYG5UsMeVM9OZ269eFPnyl36vyT1H2u7L2e6DfW6FNeXBfoRQYAgCcB+BWa+1tAGCM+SSACwHcsMvrfhnAPwE4V3Fs3cJ5Od//R2DtUY3HV+DG/Z+Oax+YfPl192wGwMWB3In0KzdvwANbFqrHI2NwwWmH4sj9V4s/UxNX/PAh/PCBrROP3fnQdgCPQjfvfAS46fNAsqN+bMdGAEBmiiX+z9+9F9fcsan1+I49aB8845RDl37SbYq3fgnY1vhRTQSc/Fxg/2NE17LW4rIbN+C+R3ZOPP7QtkUAHJMzjiMspDk+cdWdWDWuDdO+K2O8aL/bsPLhWybfsPH24r978Ey3LqS49Lr7sDOpKfbNO8p8BjMCLIDrPgWs/4/6TfEK4LQXA/scJB7/LOHur20LKT5+5Z0Tzx20zxjPH38b8db7Jt/kfldt+v2Bm4CrP7L31+98ePJ9ErjvtOXe3a91wLpiDXuMB7cu4Ms33D/BQt3x4DYAewlV3flNYMONsosd/mPAuvOZYXYOTaN+NID1jb/vBjAxK8aYowG8HMCzMCSjvmK/4r9f/5PdnroWL8Tbd75uybftu1L+87j3/O1/rMfkdAPPPPVQfOwN54k/UwsPbFnAa//qSuzJcdp3xR68oyveD3z13Us+tRAVh5gP/PsPZzFEAMC//cYzcOKh++3+xMrysW9dDODiyedOejbwuk+JrvOd9Q/jFy6+Zo/P77On+XgU7LsyxtaFFH/0L5Ob2EF4BBeueguAPTAaK/Zd8uG/+vpteO+Xb1nyuYVoHyADcPn/3v3JH30HePF7BCOfPVaNY0QG2L6Y4e2fuW7iucebH+JFK393z2/ew3zMHG5N3XNt8W9aMONz+9TDdwH/8p93f/4tVwGHnSb/XCW885Ib8alv3bPkc3vcO7ZvBD72kroMcFrEK4Df+iGwaq1wlN1D06gv5Xbuun2/F8BvW2sz8yjlGMaYNwJ4IwCsW7duZgPsDM97B/DdTwK2sWFuvA24/atYmz0MY4CLzpv8HvuvHuNFZxwpvtSbn3kS9ls5wmIjTrhx6yIuvf4+PLR1kf4KGnh4+yJyC6xdNcJLzjxq4rkj1q7CeSfswbNz3tO6JwGHNjYdY7Dz0Ofgp3+0bo8HBQm+eP39eHDrAjZuW8SJSznrT/n1YmNMa4YE2x8CbvzcpOc+JdzvdfQBq/GMUycveOrha3DMgfuIP/NdP3EGvnzjhonHrr9nM7becw8i5MDK/YEf+4nJN605Ejj+qY86xnOOOxCnHLGmetwAMEf+d+DBSybX/abbgdu+Qs3HrLHvyhH+5yvPxLfummRwrrztIRz80CPFH2uP2d1DPfQ04MDjdQb5mOcAT/8v8vk6/UL5tQ57LPDcdxR7UxM3/yuw9T5g+4Pyz1SEW4vPPPVQHHVAzUjGxuDV5x679Jt2bCoM+sq1wI+9YroLfe/vgGQ7sLBl2Rv1uwE0Z/YYAPfu8ppzAHyyNOiHAHiRMSa11n6m+SJr7YcBfBgAzjnnHP+Dx8eeV/xr4rpPAbd/FSNkWDmK8M6XnzGTS5106H74g//0uInHrr93My69/j7vm7y4PICjDlgtmw8XAzzzNcDZPzvx1CkA/mg2w8OtG7biwa0Le85XOOQxwAt3YQzuu64w6kTykcsDeNxRa2e2Pp512uF41mmHTzz2wa/8EJ+55/vFH2uPAl76XvEYX37W0Xjt+cft8uwZAJ4z+dANnyuMuiftPV959jF45dmTYZH/+qnv4aGHyvEd+XjRfMwc49XAs/6bzrWMAZ7yK7s/vvGHhVH3PNbu1uLPPeUEPH1PIbJd4e7L/Q6f/ne+9TJg813+5oooXutqACcbY04AcA+A1wD4qeYLrLUnuP83xnwMwOd3NeiDQRm/GiPrvNdvX8rcqppSsnFL1xnJY0aCVyoe0kAbuWAJxrHBCCX9KMyarsY47RpWqhBog1EU1fOhVY/uM3qSFU8JzTCSukpy0CzUVqy1NjXG/BKKrPYYwEettdcbY95UPv8hrbF4gfJGiZF1rnbUrE/2GZTGO6BWO0xJ8DJdtkpkLfQKJBhFDaMuPBiJx9gDAzGKDUYut0ArIc5nxP7/ZkCzu6W89FV0ePN8DaseQ621lwC4ZJfHljTm1tqf1RjT3FAuohGyqgytK4wiRVW1FqCV9DJ52RUDSiu8hVFPlMpx4pj3TMVj7EHP7uKQo6wc5zN6UupGla9RRl2nGyOL5SOz4xtKCmeMrHNhhFFP9OCrenRP6fd6HnXo90o4o+vwTGQwNo5+l81hKg0R9MDrG8URRoZjLgYJz42YgzgUBLSk3/2cj2DU5wVHvxsF+p2Rw5wDUoY+A/TodyY3oQVV10YuWIJRHCEmPfU6ZDIc+n0cNen34KnXBzE/5X4dqHAV4xAoyUGzCEZ9XlBMlKtjwZ7T7zlJN2c60p1jRoI34puatJELlmAcG4xpoy4co+deDlB66tBhf3oBYZfJeSGhekTIuxD6nuwZjPq8UG72I6Sdx0z7Qr8nbPMFQsqUASXBW9HvhKfeQg5WgriZKEfS79PH1P1vGhJH/CFnkGhxMNVEvRYl9HuLmLqnh5xg1OeF8vQ7Qk71TZdg3BNPPWObL+ScQZLCjUtURdAH+j1qQ78L8yD6QL/Hpp6PQL/3Ig8CaNDvVKKchH73+2AajPq8EDuj3n2iHNU3eg6gs72V6HcqUa5FklFFv3euY9CCfmcT5Tz1coBd69QD/S7tMjkvJEy4qhX97ud8BKM+L1Qlbd3T782+0VP30Z4DxAbCoaLfu/WqRgz97qhLmwNCpiRp0a1Pgjb0u3iMPaByRy0OOYNET7Lfqe6WTFe7QL8HLInKqOede2LGmJq/0ocAACAASURBVGqh+yxAQ9FnQLse0gJQIj7G0JRzRvZNl2LcooSrGuO0a9jzzGGgDEeQJX6DROw33exQJ5ZK6Hdi3Qf6PWBJOPpdoaQNaAineGzUkyo+K1yWmVadeumpS3MTyGzZSoyn45yLCUU54cEolUpz9oF+D576JHpCv9c5KAz9LqlTD/R7wFJQpN+B2qj7rCpHK8qp0e9kbgJJ1yXsfAgxamq/k4py09ep+0/lTsrmBqPeh98MIPcPRo0y0O8BSyJq1Kl37IkBDeEUj5PlElZRLiOSXQhQiXIATddVmeVdG/UowpisyxZ7R9WG6KeXA7g69UC/V+iBtgBA3i+txGf8nI9g1OeF8kaJkXe+aQOTyXK+gmrIAHBxMQJ0tzuSrqPoRAKj2CAmG5iIvSPPqUvAKcoFT71CD8oQ89zC3ZaU9jsjE+vpfASjPi9ETvs9VYmpV2VtHteqU9mrgBr9HrN5CSRdl0qpbRKFp+6MmEzAR16n7j+VGwejPgnPE8OARj5OZGCMVva7n/MRjPq8ENV16mIFNQKVVGwP6PcxW6feeetVMi+BNGRqiXKxoWVRU6kKYNPr87S8chxHdIObQaIHyY10m2LGIeg7/W6M+QVjzOeNMW8wxqwyxvyOMeZ3jTFnaAxwsKiy33OMFI5WfaLfxUYs1/GqHP0uLgskG2KkrMKeEOMowsiQ9Lt0jFEEmPL39bSsbdRUlAviM/3w1JkObQCnRjkA+v03AbwNwPkArgZwCoD7Afy5Meb1HY5t2DAGuSmozpVR94a2VpXzl35PWK1zpiyFgPMCROIzAE+/V5SipqcupN8zogzRc09nIhwRZGK9b2ACtGjbzKhRet7gZpoVu2itvc4Y82sAHgRwjrV2wRjz1wC+DuCvOx3hgGFNDNgMK6LuPRbnZYoNkiIo8QiAi4sRGLEHI9KI0YccISZLuDhFOVHcPxoB2ULxu41Xi66ngTYlfoOE5zFkoGbPRM1cAK4ZlOfMxTQz8GljzGcBvBDAW6y1C+XjCYBDOhvZMkBuisWx0nTvPY+YZiTKqHtzk/3UuxafiVj6ndsE6AY3QhQlXBz9TqkAek5fjqJAv0+gB9nvCXuvUNnvfs/HXo+h1trfN8Y8D8B/AnC2MeaPANwCYCWATcaYxwK42VrrL6/rKTIzwhjAiqj7qavahnqd/U5QaHkGwBZxWgWaGqg3kKlBejoJQ20TmKTfp/dMrbUND0niqfu9KY7jJv0ejHp9CPOTbgba0O8turT1mH6HtfaLAL4IAKaoFzgVwBMBPAHAn5V/H9fRGAcLF1NfAQX6vQed2sSZ1IAa9Q40Kwh06HdaYU+IEdk/vKl4Jyoj8nxTLErauByDQaIH9DvP8rUoafP0UCreCW3R5uum8t/fznxEywiOfh8rxNQrNTSvPXWiLEWJegeac6hLv2vUqTPiM3QZkef05Tg2dTVAoN+9Z1aANhLTRDMoz9dvqFOfI7LSqK/QiKn3oE6dElth+iGTGLeViZXS72yDGyFGkcHIFGOzZnrPNJF2aHPw3dOJgkzsBHpAv9OhqgHS78GozxE59Oj3PnjqCVOnnsljwSxcXoJcUc5v+j2KTLUGHXs0Ddz4Yqmn7vmmOEm/h+x3338voE3b5jb0u5/zEYz6HJGVXtFYoU69D556VglI+Em/03kJrbXfFbr4lWxRJtjc6Dp6z+nLcbMaIBj1xqHUT7EggEyyBVpmv/s5H1PfjabATxtjfq/8e50x5rzuhjZ81PR795tbH/qpuxtT1pBBR3gGaHS6k7IdLtmK1H7X6OK3opRFzez09Ls73IjLiDz3dCbq1AP93gvxGVpRjtJ+91t8RjIDfwHgSQAuKv/eAuADMx/RMkJW0u8jRfrd537q1Y0pot8J8QgScaX9ztLvnKfetfgMgErrPGPod+n4PM+mLqoBAv1egTyUaoIqrQQaTJ/EqJfz4ekhR7Jiz7fWnmWM+TYAWGs3GWNWdDSuZQFn1McKiXLjHvRT5+rUFel3Ni+BbIhRN7hR8NTLg2XKJMpJmQTPPb+JfurBqPci+z1pKxPL0O+eHnIkd2NijIkBWAAwxhwKwF+3rwdIK/q9e0/dnWC9VpRjPD8mJkaCzkuoTvZkSZtmTB3TG3U6OclzIzGKDGKywc0g4XkOBNAMBbFqlEyXtp7H1AG8D8CnARxmjPljAJcDeGcno1omcBtorCE+U6mh+XsOqzt++Um/03XqLbXfu85+B1CJz0iMuvOO5PS733RuoN93QQ+y3+lQFWXUPc8JmeZFpYrc1wBcC+DZAAyAl1lrb+xwbINH6kraFDz1PmS/c3XqiuIzbEOXiq6TxtR16tQBYGQywAKpICJHe0eee35xo8FNbkahRMhzIwbU9wrdDIppverpIWdamVhrjPmMtfZsFEpyATNAqpgoF/ci+52QelSk36u8BFb7XUq/Z4r0u4upC0wYXXLnOf1ujKlK2lKMsOwThzwv4QJIiWmAcwoGRL9faYw5t7ORLEM4r2ikkJpAq6EpImWMGNMPmURFv7P91KX0O6vYRmBcGXWJp06Oz3NPB0AlPpOaZe+ne1/CBbQ4YDKKlL4negpeewGANxlj7gCwDQUFb621j+9iYMsBziuq1Ks6xIj1MhWRMBQa0w+ZRM12KNHvSv3UgaanLqhTZ+OYnsvEAvUhJxHU7Q8WfaDfmdAdwClSep5jIDHqL+xsFMsUqVWsU+9Bl7a61lRCv+uJhIxpmVi5EbPWNhIHuzfqcZnXkQT6HUA9H5m859XwUGm/+0k3A6TENEDS734fSiUr9vV7ePwPZzGQ5YjE0e+aiXI+Z78z2d69oN/ldF1TTEPU1pTEyJaeuiXodzZRzlNPB3mOGBa5NUht93PvPfpAv1ehIJZ+Z2Ri+2/UtzX+fxWAlwAI2e8t4Oj32GrQ76QamiISxkgo0u/uYCRW5SNiyJpqckDNFkk89YRWlPNbkcuNK0VUeYDLGj2g3ymWD2jQ74L9Yyj0u7X2Pc2/jTF/AuBzMx/RMkJS0e8arVed+Iy/njol9agpPhOTAj6RnL6sqHclo+60ElJBDDljwwOeZw+7NZViVFUgLGs0PVNrAQXmSIqE7UMwQPq9TWrnPgBOnNVAliOcUY8VE+X64alL6Pc51KnnFtYK5pGg31O2PzQJl6wpi6m37NLmqafjxpUi9lqsSQ3GAE4+2NODWMrKxC5n+t0Y832UErEAYgCHAnhHF4NaLkiso9/1FOW8jqkzyS5MP2QSxhjEkUGWF0lsUx8+CPpdU00OqNdgIoip02P0nc6tPPXI68RSVUQjIMuK30xS/qWElKbfW/RT9/RQKvl1XtL4/xTA/dYqBIMHjEUnPqMwjXEPst9bJcopbTQjZ9Qzi/G0TDVhxOj+0CQcW+QOmtOA9o483xRrT33kdVdDVcRjIFso5ma8et6j2Q2VopyKTKzfdeqSY81brLV3lv/usdamxph3dzayZQBHv0ca2u9sOZYiajrXT5lYoKkqJ9jsiRgyrZBFwnnqCxKjzpYR+a5QlrtQROx1AyRVeB5HroWryJI2RibW07mQzMBzl3gs1K63QE2/62W/+6ool+cWbv+kEuWUGm9QjAcRQ6ZrwBlYSyXK0YIf3tPvxbgyG3kdrlKF70ad7RjYin73cy72+k2MMW8G8BYAJxpjvtd4ag2Ab3Y1sOWARUVP3RkjX0t0koaXLqrLZhoytADV7Y4o4aINJoNyo86sQZpPfz1Kqx/oAf3uPPWR14mlqvA8uZEKBVkLuHymAdHv03yTvwHwrwDeBeBtjce3WGs3djKqZQJn1DU8dUcb+1qiQ/cOV/bUnQET0bIM/c60oWXRKOGSHFZoxTvPs4fr+Qj0ewXPVQApRbnm3iFxJDxfv3vdCa21mwFsBnCRMeZAACejEJ+BMQbW2q91O8ThIinVqiKFxTFidcuVUNWZ0l2WBka/K+q+u3FJY8gp3U/dbyq3ot8Rh0Q5h4pt8vM3y1qpUQr3Dtfkx+ZAngNKeS/TQlLS9gsAfhXAMQC+A+DHAVwB4FndDG34WMhjwCglynlep05nUs+Lfpds9gRdlyj2Um96ppL1kbDJSb7LjmZ1opzP1SKq8Jx+T6gkW1Ji2pjiPXlS/ItWyt7fMSR3468COBfAndbaCwA8EcADnYxqmWCxTJSLFEvafKUTaZlHbfo9Zuh3uZeTaSrKNYy6JJGSHqPn2cMT8+Hp/aIOz+n3NCPCVVUzKGLv8JiCl+ygO621OwHAGLPSWnsTgFO7GdbywEJeJsoplPaMGA9TEQkbn2UUoVrAeQIixoNovZqwzAWDhoKaxIjRbILnBqLWfo+9DVepI/a7YoHKyWnTDMpjtklyRLnbGHMAgM8A+JIxZhOAe7sZ1vBhrW146t0vjLHn/dR5+l3bUydyEyiZWMU69aYRExxWKLEgoAfZ7+V82EC/V/C8jCthqkXaqFF6nGMw1bcxRY3Rr1hrHwbwB8aYfwewP4BLuxzckJHltqoJNgqeetzQLfcRdHmUsvjMiBHxIRLD6GoABnldoy45rNBj9Ji6BFDPR6Dfa3jOrlD7RyU8Myz6fapvY621xpjPADi7/PurnY5qGSDNLVLotaCsFOU8pd9pr6+i33U89THTUz2Wezm156HgqbP0O9t0pifiM4kwx2DQiP2uzabEmto0g/KYfpfcjVcaY87tbCTLDEmW10ZdYWGMGGOkCNpAKNPvdUlbx/Q7q5DFgDRi7el3/7wcANX9mCH2VqxJHZHeXsUgZQ7BM6Hf/ZsPybe5AMCbjDF3ANgGwKBw4h/fxcCGjmzCU1dIlPO8Tj1jjdjctN+7pd9VZWKdopywpI0+eHhMXQKY1H4PnnoBQkBJE7X2OyExzSTZety/QGLUg877DJFkFoki/T7yPVGO7Uo2p+x30eGIaL2aVr3lNeh3TkGt6ow1OPo9lLTtBu/pd7cWFcRngMHQ73cBeBqA11tr70TRW/3wTka1DJDmOTJN+t3z1qu0olx1Y07fiKQNXB29qKSNSDJSVZRr0u8SmVh2jH2i3z29X9ThO/3O6Fy00bjw+GAq2UH/AsCTAFxU/r0FwAdmPqJlgjRr0u96Xdp8rVOnDYQ6/U4cjogSroTxPFiQRizJyDF67vVVhxwbEuUqeJ79nrSRiaXod38PppIjyvnW2rOMMd8GAGvtJmPMio7GNXikua36qasYdaYRiSJ4+r1FXIzAiOmnTsSQM7bEj4GLIVsZ/U6P0XMDEej3JeB5HkTGhIJaeer+zofkbkyMMTEK2h3GmEMBhGMsiTTTpd8pzXJFUDKPgDr9ToUxiES5RJV+b2q/T78+XGZ4LD2IeU7lNnMMfE0sVYfngkEU09cq+30Y9Pv7AHwawGHGmD8GcDmAd3YyqmUA7UQ5/8VnyI5f6uIzjKJcm0Q5ZZlYkaJcOUapp+6518cq7A0aHhsxgAxXZW2y3/095Ex9RLHWfsIYcy2AZ6MoZ3uZtfbGzkY2cBQlbe5G0evS5q9RZ7Xf50W/E9rvVEmbbpc2yfeiy+48pi4BTPSX9/V+UYfHJVxAo/UqRb+3EJ/xcD5EvEPZxOWmjsayrJDkee2pq2a/+0kn0lrnbZoyEOAS5RqJYdYWrRv3giocod2lTZT93jJRzkMvB8AurVf9vF/U4XEJF9BoCMXQ761kYv2bD0k/9VUA3gLgqSji6pcD+KDr3BYgQ5pZZC76oUi/5xbIc4tIw1gIQDVkABpxMa2SNqafeoRSq6k42U+xidThCGWZWEJ8RjxGj5thAKjWVIYoKMo5eKygBtQHTFH4ro0apcc5BpK78WIAjwPw5wDeD+CxAP7/Lga1HJDmuSr9boxpxIP926jo5iBVT2RdRTlxFYGQgp+Hopy0oQsvE9sP+j2xo4rWXfbwPA+CCle1ot/lya9akBxRTrXWntn4+9+NMd+d9YCWC9KsUdKmdNobxaZoJJPnWCE6z3WPhI0hK9Pv9MEoGgPZYunprNrry1UT5Sa03xUU5byn32vmIgnZ7wUq+t0/IwY0q2e06Xf/5kNyN37bGPPj7g9jzPkAvjH7IS0PTCjKKVFaI0YNTQlpa/pdqZ86Q78DYrquLmnTk4mVNjBprSjnKZVb5xhEIfvdwfPfjKqeaSUTOwz6/XwA3zTG3FE2dbkCwDOMMd83xnxvmg8wxrzAGHOzMeZWY8zb9vCaZxpjvmOMud4YM9gWr+lESZvOac9RuT4K0NBCJm16IhMY0fS7LNSSsdUADBqJcpmEfmfHGOmFnSg0st99vFfmgthfuhlorEWRTGy5/pYx/f6CNhcqhWs+AOC5AO4GcLUx5nPW2hsarzkAhRztC6y1dxljDmtzTZ8x0U9didIaedxTPWHoM6BdT2QCtdwuQb8DU3s6lcKeiqKco99HVJ26OGTSJ/rdw3tlLvA4+z3LLawFIgNZAnCbZlBDyH4vm7i0wXkAbrXW3gYAxphPArgQwA2N1/wUgE9Za+8qr7mh5TW9wNaFFN+6cxNyW2+Y379nc8OoLwC3fHnyTasPAI4+e6ryp2nhqOPLb30QB+1bK/yuGsc4Z/8tGG28VfaBB58IHHSieBwPbV3A9+/ZPPHYLRu2AHgU+sxa4EffAbY9NPl4sq34rzL9fseD2/CVmyeX5+lHrsVha/cQL3fju+0rwL6Ns+p4Fe5ZeyZueWDHxMvv3rRj4nozw7aHgHu/PfnYAzcDKLK9H9mR7Pa99oTtSeHp8P3UF3df96v2B445Z6br/lGx+W5gwy5Vug/fBaAw6vdvWdhtPo4/eF8cf8i+KsOz1uL6ex/Bg1sXRO974rEHYv99ZnjQdb/Zxtt3+80WD3ksrtm4Eovp9AeglaMY5x5/oPhAmOcW316/CVt21o7QVOWw2zcC93xr8rENpcwKUznj5uP+63dfw8ecDaw+UP6ZM4KkpO0cAP8NwHHl+6T91I8GsL7x990oKP0mTgEwNsZ8BcAaAH9mrb142jH6il//u+/gSzfcv9vjEUbIESHKU+ATr9j9ja/+OPDYl85sHKvGxaL/z38/md+4Eov43r6/hFG2VfaB8QrgN38gXsAX/Z8r8YP7l77WytEebrA7vg789aPMxWilaAwsVo2L8V16/X249Pr7Jp47bM1KXPU7z4ZZyiCNS2P/mTfv9tQ/4CK8d+fS323leMae+l+/FNhw/ZJPLWCMezfvxM/+36tFH7lyRLReNTFgs6XX/U9+DHjcy2WfySBdBD74ZGDn5iWfXrBjfHf9w7vNxzg2uOp3njNxMO4KV9+xCa/6yyvE7zv7uAPxT29+8uwG4tbvzf9S/GsgGR+E1255H6ww+fY3nnsKfvnZJ4ve80/fuhu/9Y9LR3sfdR1efCFw3x6ixKO9J67u8T3XfLT418Qx5wK/8OXd36MEiXvzCQC/BeD74DTflzp678r1jQCcjUK1bjWAK4wxV1prfzDxQca8EcAbAWDdunXEUHThvK6z1h2A/VbVp+cVscGPDn0bjn7oqsk3PPgDYPN64OH1mCV+/bmn4FPfumdi0u99eAc2b7gbK7OthZE+/mnTfdhdVwDJdmDrA2Kjfk85H095zMETiWD7rYzxsicetfSbSu8Ja44EDjt98rljzyuYDQU8/3FH4Oo7NmHzjkna7Ws/eAAbtiwgze3SIYRn/lfgu39bMA4Om+8GHrwZh6QbMI4NnnTSIRNvOXjfFXjGKYfO9gtsLtfUCc+YYDfsin2xcnwRnv6wbB6feOwBOGAfoXEzBnjeO4BbL5t8/KFbit95xut+j1jYUhj0aFTMRwPZ6oNwQPpCPH375IZ/zR0bsX0xwwNbFlSM+t2btgMoDoynHbl2r69fSDJcdftG3Pvwjr2+VoRTXwzc8Q1gx6bJx3/4b9g32YgVSHHCEQfvmalq4L7NO/CD+7fiHmKMbi897uB9cNzBk2zJc09/lE7gbt0f/7Rin3NYsS/w+NeIx4EnvBbYeBuQNL5DugDceXlxX88REqP+gLX2cy2udTeAYxt/HwPg3iVe86C1dhuAbcaYrwE4E8CEUbfWfhjAhwHgnHPO8T6TxSUfvesnHo9Tj1izy7Pn7v6GL/w34Ir3zzwJ48InHI0Ln3D0xGOfuOpO/Pmny8jKPocAr/vUdB/2gfOBB26ixuiSWj7y+nMrz3evcNd5zHOAC98vvuascPjaVfjzi5642+OnvP1fsZjmyHKLJb/SGa8s/jVx7ceAf/5VxMhx4D4rcPHPndfJmCfg5vGivy02tBIGwJvLfyp40luLf0186feBb7xXL/nIXWf1Qbut+xjAHyzxlhe892u46b4tao1e3L3ytJMPxXtedeZeXg1seGQnznvnZbPXolhzOPDKj+z++B8fBSTbECPHWy94DF565h4O5Q38/TXr8V/+8XvUGF3i4ivPOkbm5bukuNd8ogjxtMVhpxWf1cTWDcCfnDz35DmJUf99Y8xfAbgMQBXgsdZOaQVwNYCTjTEnALgHwGtQxNCb+CyA9xtjRgBWoKDn/1QwRi9RxXymTQJTTMIYRxFGxgm4CJaDMPGriUooQqv3sQLGkcEiilK3qQ8q5RyOTSav9WahXNcvgnZGMZEoVfVQUCp1k9ZfV70JtBL84hGQACOkU4+xllqWj9HpBog7A2qse0/K3CRG/Q0ATgMwRk2/WwBTGXVrbWqM+SUAX0BxEP6otfZ6Y8ybyuc/ZK290RhzKYDvldf4K2vtdYIxeokkF9ZgV4uj+80tjgzGcKUdEqPOZe5ba6vTtqxNYgtJRwVUXfCIlqwjpDotVq1Vr+sXQTsrnmjbGzNd+lpAWn9NrcM2KNfRGNnUmgrudYwEb90TQVr6qrDuPSlzk3zDM621Z7S5mLX2EgCX7PLYh3b5+38B+F9truMbxB2EFGU0R7FBDKJek1RUanrpSyaU7QnKLValoLrgxc6o5zpysLY0RCYq9eg9g7qnLl/3VEOfFqg99el+r2p8WvX15dzFgjXsmq4wEryUnLS1Ot0cPVGZk9zZVxpjTt/7ywJ2hbiDUCX0oEC/x1HtqUsWPEm/i0MRDhX97qGHifr7yPqsF3M4Qib3PBj4TL0D+rW/BP1eaT0oGc1UyPLV49Oi38sQEtKp13Ddvpig3xltBHd4M3G3pZKe1PJLdsinAni9MeZ2FDF1aUnbsoW4g5BibCaODEaVpy6o14w43fqEFVXxnH6vhX08pt99pt4B1bBTcR35fNTiQzpGs5ILnjamXskYW1hrZWwYg3IfGJls6jXcHKMUVBMhrXXv9kSbTd1iuQuoKcotZ4g7CFVecPcymuO4adQZ+l02xoz11D2n30cM7Rk7Tz1XlYP1le1Q795GHBSdMdGSj82E8qdRZBCZssWyBTpfVk22aepkPn4OqSRbDeodKIx4NCqul6dzS+qVuEt3AXgagNeX6nIWwKMUBgY4iDsIKdKQoyiqjboC/U576r7T71WCkoR+rz11sdQqA2VJXTEUw07FdeSbvfudtJoi1VK80xuxeowKbEJcG/Vp13DdWEo+PqozYJvGLVJ4QMFLdpK/APAkABeVf29BoeUesBeIOwiR1DaDUWTqkjZR9jsXIqB7cHtOHVMd8FzmsIC6bAXP57AX9Lty9ntCeKZ0e2AGjn5HNn3cv0UyH9UZUDN050E3O8m3PN9ae5Yx5tsAYK3dZIzpXlJpABB3EFKk30dxw1OXLHqyaxOVvQq066ikAIpSjOvMYV363c857AX9znbpI5FJQ3dohAg02ISo6anLYuqUUa88dQ/pd0DcjbELSDz1pOy0ZgHAGHMoOLnYZQWqg5Am/d6MqVP0u2wDdpSbWGzFc/GZivKkst9TnW5smjQkgx5kv49bJHkxqLK9BZ7pmFmLLJr0+5RreNxCIGeq5i27QrPqo2f0+/sAfBrAYcaYPwZwOYB3dTKqAaG+KQVTrZj9PooMxiDoKZZ+Z4RngAZ1THRUUkAdU5fQ78V3GQuoy1bwvIJAM+xUXEc+HzGTO9ECTLhKVYCmEUKadoxtxufCESJFuWrdK+wdfaLfrbWfMMZci6LZigHwMmvtjZ2NbCBIGbpZcWFMJMpR9LswUY7wPIrr+J3kRcVaYzl12Qqesx369LvcgxsxIkMtUNWpC5itsWaiXJXsOf0adtQ5wyS4w5RI10Fz3cd6DtmeIGm9+m5r7W8DuGmJxwL2gIxJDCPLxRgUJW355HWnAbkBVyU6Yvrd73gwpQkeyTOHW8F3T11bkYso8WujW85AXDmDdiVjYjQOptPe0461bFXSRnnqivR7T2Lqz13isRfOaiBDRUKctPXFZ9rQ79KYelv63U+DRGmCE5nDreC7Ue8T/a7mqbv7Zfr9Q1WfvuGpa+jTpwzTpxm66wP9box5M4C3ADjRGNPsMr8GwDe6GthQQJVwKS6Mcdzo0kaJz0hL2ojsVcB7g0Rpgjsvx0yfZNQKgX6fBEG/Uxr/LZAQ98uYKa9k0TDq01LibcIDYiEvQJfl025KtASm2SH/BsC/okiKe1vj8S3W2o2djGpAoMQSFOn30QT9TnjqbEmbWHzGb/qd0gQn1LhawfO8hD7Q75TIUAsw98u86PepS9raKMpRMrGa9Pv8O7XtdTVbazcD2IxadCZAAKqBiWJZRJEoRyz66kQqpN/pOnW/m5FQmuDaiXJVCZefbId6P2qi1ElbUS4h9g9VRTmiTn08A0U5WUxdM1Fu/p3aPOy/OCyI1eQA5ex3tp86N0YqJgZ4T79TmuATJW2aMrF+zqF6PLIH2u/SLm3N1+ooyrmStum1FuIZKMpxdeqKMfWe1KkHEBCryQG0WhuDiX7qIvq9ZT91WnzGT4M0apH9HqsnyvnJdmiGnYrrMNrvfDkWgzaKchp16raKqefiLm2copy8GkBVjdID+n3qlWIK/LQx5vfKv9cZY87rbmjDQDv6vfuFMZ6QiZXQ7+203/lEOT8NElV7SzTDaIVAv0+CUNgbMy12BOhNxgAAIABJREFUW6BKlCMU5TSy3/Ny7lZG01+rnaIcwXzOhX7vh6ceGroQoMRWFGnIuDX9LvXU3U05rH7qMUW/l9Sllqfuu0ws2fmPBlEmSf3OLcA0MNFUlMtRUNorzPTsivsquQVy4TwmjM7FXOj3HnjqKBq6vBXATqBo6AIgNHTZCxj6TDPZYhQZxOUNaUVGnaTfnacuNWK+0+9Ul7YYFgaRsRhFCkbC86Y4mmGn4jryngdjJiGyBZhw1bhFzFoK56mPBZ66MYYeY10N4Gv2e78S5UJDFwJJmzp1hdOeMQYrTfEz5hKjztLvTPYq0Bv6XUopZkZOX9LQpCEZzK31KiETq9VPnehKVpVXKhw8crd+jexadQmo7H1UL425dGnrB/2+VEOXd3YyqgGBMmLKWcDj0lN3VNpUIMdYK8oNjX7nRElyU2fAdw5NGpLB3Oj36edDXVGOod+r/I7ux5gZOf0O1E6OtDSQylHSDDt5QL+zDV0A4EJr7U2P9p4AsgRDWZVoZXlDZmaEqc+yZDIfrSjnuRoapSiH2tORbooUPGc71NW4CEGjmjbWISmZVsVjRYGcDNz6HZHMVqs6dRWj3qNEOWPMTwK4x1r7AQAHAXinMeaszkY2EFAlGMplEWNHvxsJ/d6ypE3sqfud5MXSiY5+X6FCv/utyld5zNolbRL6XTn7nYkha3aSc3vGWEq/x1xTF2r/IHInaGjnhSwByc76u9baLcaYp6Jo7vLXAD7YzbCGA6oEQ92oF4s+NZKmM24D5vqpy2PqRIa+IkZs4g/mQb/7OYd9oN+pFrstkBBMn2ademv6XXC/ZLmFtYAxwv10LvR7Dzx1oNp1XgzgQ9bazyJkv+8VSZvsd6WFsaI8ZWfTR2Na0+/iEi7P6XdWE5zdFCl4znbo0+/yNTWvRDmZTKzewaM6lCrQ7wnTSx2YE/3eD0/9HmPMXwJ4FYBLjDErhe9flshc9qrIU9ddGK5Lmyr9LhVb8V77ndMEdwcpKX1JQZOGZOA2XZsB1s8Sv5FiEhrQLIllst81PHVu/Y6JxFI3F/K2zXPo0ua7UTfGGBTtV78A4AXW2odRxNV/q8OxDQJUtrejA5U2N0f9pgrZ71SXJaChW+5n5jZLy7KeDgXf6XdjAOPCOgqbIuHBaXdpa0W/e+ypMwI5VOY7oNvzwO1PnrdehbXWGmM+ba09u/HYjwD8qLORDQSULKoxxQLM02JxjLqNcrgbMmOMunDxJm3r1D31Mtl2kplmSZvv9DtQ/L5pVqyrrn9rQtCIarHbAlW4iurSpuCpkzkhTCe5hGljDeiyfH3KfgdwpTHm3M5GMlBkrBFTpODHpYZQKompk803skpRzuMbk8CYUZRDPecjFfrd74MRAN0kUSL7nRUZYsE0hBqTB0wGqeHWLzPG9vS7wmFWuynREpB8ywsAvMkYcweAbQAMCif+8V0MbChg6DMApceyQ+XEV3nqRuKpcydSKvvdWu/FZ+i624q+VDBimed16sB8jDqTKKfWerVNTL37g0fKeupEiIBpbgOAUg6kESkney4ByQ75ws5GMWAw/ZABNGIzCvrv5Q2ZWAX6ncl+d6deEwEafccJsEpjjr4caSgu94V+B3Q2RSLHQLWtqbVknbpeMl9arV+pUZczW3VM3WM1SrLUd6ZDELz2LgBPA/B6a+2dKDTgD+9kVAMCne2tSL+7GzITZb87j0pIvzPz4Tn1DjTbSUrpd82YuiINyWIu9LvAqCuWi6UNurnIVZ4O7gCgQb/zMXX5GFPigANgTtnv86PfQ+vVjkH3D1fsy+uMemolGfrc+KgGN57XqAN8xnFCejoUekG/KyYaMfS7YrkYWynCJKGxqDx1cZ26fIx0MyhV8Zl+0e/nW2vPMsZ8GyharxpjgvjMXkApygGqpRHuhkwUst857Wa/y9kAXlEuLUMeMfws4VJH1f1PI8egBf2u4AUnZOhOM0TgQnZy+r1FSZvPzaB6Rr+H1qsEau13ln7v3oMbMXXqpMYxp93sv4fJenCpakw9ZL9PgNF+V8x+z8gYMnvAZODWb0wnyhH0u8/lsH0RnykRWq8SoONAivR7bBlPnVSUY7q09YF+d8lJws1el37vgaeuSr/L69Td4VwjCS0heqkDDbU2hYNH5alb2fqtclAE4arWEtOq9Hv/Wq8aAC+z1t7Y2cgGgoSm3/UaA4xK6jfNFeh3RmHP83I2oPbUxV2nyjwGHfrd/3ms6XeN7Hf5fMSKSWhML/Xm61VCBKVfOBKuX0ZRLqGz3+fQ0GWO9PvU39IY8+sA/qFsvRowJepEOSn9rrc4HHWWSIgbkklIGAqtB8aILSNarDwdxRiyx4yHat8DoqqiFhlSSEIjY8gsa8QgIXNCmDGmJHNRHd40W6/2pEvbWgBfMMZ83RjzVmNMKGebAnQcSLE0oqLfraRLG1vSRnRa6oExYinPpIpJKsbUPT4czUd8hihp08h+Z+l3slc5A3b9jglmqy7xYxPlNGViexBTt9b+d2vt4wC8FcBRAL5qjPlyZyMbCOg4kCL97k7ZCYie72LxGYJS7IExYmnZin7X8NR7MI+64jOe0++kLKp7vYb2uwvZSddvTDBbFesprlN3jIxC9YzmoXRPQyDeswHAfQAeAnDYbIczPFDZ3oAu/V566guSmDpJv1OJcj0oxRqTlOeiZklbDxgP1ZgkQ79XiXIK1HZ1r8j2jrGiQM4CuEPpuIqpE4lyXtPv869Tn3q1GGPebIz5CoDLABwC4BeD7vve0Z5+736zj6uSNgn93hifoD0spSineVOSYDXBK6MuzB6m0IPSQDasQ4EodSrU3Yol37W3zvRSB/ikTQa1zgInPsMpyvlMv8/fU5e4PscB+DVr7Xe6GswQkZKnbc3SCHfKXsglinJRocVu82IDnjIuSSnK9cAYsYIfizYGDBCp0O/yEi51eE6/A0U8eDHLkeY54g4pXbYZlGai3EJp1CPhobQeo8Sos22bFRkqD+rUJSVtb+tyIEMFFUMGVGlIZ1ASiUwsUIwxWyzGOKWh4BTl/KffWU3wxBrAKHnqpBFTxVzod9l8xJEBsuIAt7LDqWTzcTSlbJOco99HBP1Od7zM5hBT74NMrDFmJYBXADi++T5r7R/OfljDQcaWYZCKbQwiRnwGKDznbFE0RopCy/z3MNmN1NHvkWZDF48ZD9/pd6A8wCXdG02afldUlEtYTz2Sh6uYjnUA6rW0TLLfJbvkZwFsBnAtgIVuhjM88IlySvR7niNCjtwaLObEwSOB6FRKNbjRvClJjImN1FqLxTwGYiBSVVDzdx7n03pVNh+MGhoDlxkuTpSLdMYHADsroy5MlCOYLTpRTpV+75H4DIBjrLUv6GwkAwXVPxzQoyHLz08RyT0PIimEanDTA/o9ZrJ5c1tpZxuNk31Fv/vbGEdNJjbPULSxMEV+iABaim1sMyhGrY1FYotrSY16TDBbCSvkpSoTq9iQaE9DELz2m8aYMzobyUBBZXsDevR7+fkpRvJNiqCaqAY3PaDfGU3wrGHUfW1goo5IaT5aNPkYRzqJaCzLx7BGLNhEOWaMGVm3XzN9itrvPaHfnwrgDcaY21DQ7waADWVtj45ar1jqqSvRkJnz1GN5AwiCKqUa3PTAGI0IUZIky5WNep/o947ng6TeAa4ciwEVqkKjvFIh+30xa3jq1gJmurFSiXK9yH7vF/3+ApSGvKOxDBIp2RNZrd6x8tQjwlOXG6Q6HDGshi5NpTFrLcwUm1uaNTx11Riyv/OoR7/zczFSUmxze4fUM9UaHwCkeaGKODJ5cZ9OaThjgtmqFeUC/f5o2Ou3NMZcbq19KoDrMWnQnYFf29HYBgG2KYNaveME/S482RNUE5XR2wMlNGMMRpFBmlskmcWK0RRGXZ1+V6QhWajR7+VcECEdtnxRCrYZlBuflpRtihgjyIy6C2Fkojp1ln5XdAr6QL+XBh3W2jXdD2d4qGPInmq/l5+fIJYn1jD0OxOO6IGnDhTfKc3t1Jtpmud1GWHIfi+glf3ehn5XqgNnWb6RYvZ7sYZHWIWkmNPx6qneNyLkdimJaaBV/oQYpHz2LMFovwcIwGawame/ZzaS03WR3CBVcbGB0e9A/Z2m3ajSzCKzjn5X1H73eR61PJ029LtSIhqbj6NJvyeZRebMiOA3YxQYUzbpWJV+V7yf9zSEuV15mYAuw1BLGHId2lrQ71OOsYg3F7k0okNOD+h3QN6WM8kUPXVrAdsH+l2XoaLodyLJi0HK5J+guQ41er431rDgN2NCGHR5MNG4h4ZWTsijDWFuV14mYFWh9DwWF1OP5Z6HMO6fMr3Um5/vszGCnPZULWlrzuGUGcpzgVopJy9oxDbvkYJtBjVWGp+7RtUISuSpy0MYlKJcnhf9KQAdfQYPtN+DUe8YbAYrQ21TcPQ7U9ImDBG4G1ie6NID2hhySrGgLpXouj5Q70A/6HclcReq/BN64jhAGUKq6HeBp06MsQ5HkKE7jcOsB9rvwah3jIQtw1Cn34lEOeECppLkgF60XgXk9LtqopwmBdkGfaDflXqq17KoQvp9l/LKLpHmeaX/LtmrmE5yVIMb7XUfxagKwzT6Fyw1hLlcdRlhedDv0y3ein6X5hf0QHwGkGuCq5a0tSjhUoVaKSdPvzPlWAyqyhmhp+7KK5uf0RVY+n1MCPhQ6pyame8Oc6bgg1HvGAnbT11LmajSfo9b1KlP6anTXZb8l4kF5JRimlkkUPZMPT8YaVd9MJu9dp26ONsbctaIxYSAEkO/S7TfmfLgebQb1lID3dPl53LVZQRaMEGZhkxtzJe0TTlGOnu1J/HgOJJRimmWI7PyciAKPclLUFPkarGmqtLFjg1mwubjQF5eyaKQOi7XMJH9ztSpe98MSutguqfLz+WqywTWWr4HcCSjtmmUn58ilitQCWkmurlND1qvAnJKUZd+dzSk50ZdWUmxTZ1614ptWUZ4piWqMSr0fK/p9+n3KnfokMwh1eBmLvS7fD5miWDUO0STbp5GC3wCWspEeVNRrluZWLq5TR+U0NBM/pEkymkxMv3IS9Cj3/nNvvbU/ezS1nxP58l8uaWSPaX3CkAqys2D5Qv0+3BBl3ABYmqbRlaXtMnpd2H2O9vcproxPe4DDrkoCavGRaF39LtWjkGLkrbOFeXIrmTQK7tLsryhiiiJqcs7yVGhzHloXAT6fbigs70B9ez3hKLfZVmvdHObnmS/1+Iz081jljcS5TzuH64KYUUFjRnQ710rtmVtPHWtEMGEpy4vaRPR74w651zp95D9PjjQddnAHLq0xXKqTnjwoJvb9MQgSTXBJ/qpe+yZqkK79SqxprQU2+hwFeoxdh0iSDIuL2RMhAcopm8eVR9C+eyZX17zYsaYFxhjbjbG3GqMedsSz+9vjPlnY8x3jTHXG2PeoDm+WSNh6WZAnYbMVMRnyGzenhgkKf1elAPJ1bgo9ERqVy/sxM9HrKYox+8fWqpyaZ43VBGn/81iouSOOuTkcwjdLRf63RgTA/gAgBcCOB3ARcaY03d52VsB3GCtPRPAMwG8xxizQmuMswZNNwPq9bqJJRLlhMl8lMxj8/M9N0iV0pggUS61yiVcnrMdegxVi9arRDkWg1Z16sLyShaF1oI8UW4cEYlyTIfHeahRxkoO2R6guUueB+BWa+1tAGCM+SSACwHc0HiNBbDGFKni+wHYCGB+yvhC3PPwDuxM6ljgfZt3AmhJvy9sAR68ZfK5fQ8FVh8g/8w8AzbeNvnYIz8CUNDvC2mOHz6wdeLp/VePcch+K5f+PGdkt9y/2xjtAcfhrs3JhKewftN2AHuh3xe2AFvum3xs5+biv54bJPe97nl4x27zuBTu27xQU5fpzt1/51UHAPsdKh+ItcCm2yfj0g/fWfzX84NRZWRnvu5vR7G9lHjk3uK/RImfo443PLKw2+987IH7YMVIboS3LqS4/5GdE49t3pGU1+Pp9zsf2o5V49pLHUcRjj1otbwaB8CGLTuxZefkdryY5UhN+fmb797lNzPAQScCSxhhd1BZSLOp7hUA2L6Yle/dw9iXWveb7ij+Ow/6fdPtwIp968fXHAGsXNP55TXv8KMBrG/8fTeA83d5zfsBfA7AvQDWAHi1tbbbo+aMcPEVd+D3Pnv9ks+1SpS799vA+8/Z5QP3AX71u8B+h8k+85M/Bfzg0iWfSjDCQ9sW8ez3fHVyGAb4zFufgscfs8Rm6ozslR8o/jWwfr8z8YwHf3vJa+3xpL2wBfjTHwN2Prz08z1JlHvH52/AOz4/3XsOcEZ9x8bdf2cTAT//ZeCYs2UD+eLbgSvev/Rznh+MqvHd973d52O0qlj3a46Qfebf/wxw0x5+kBae+se+eQc+9s07Jp574roD8Om3PEX0edsXUzzt3f+GTduX9uzaKMq95RPf2u25X3vOyfi155wi+rxv3vogXvuRq7CUlHziDg1ffHvxr4kzXgW84v/scXxbdqa77Tl7wx730y//AfCN9y79nKY+g1vD//Czk4+/5m+A017c+eU1jfpSx6tdl8jzAXwHwLMAnATgS8aYr1trH5n4IGPeCOCNALBu3boOhirHTfdtAQAcst8KrF3V2CgM8FPnEWM88kzgpGfXHpbDw+uBZDuw6U65Ub+/PHQccNzE5m5Hq7B19Utw4oP7Trx8w5YFbF1IceuGrUsb9dNeAtzyRWBxW/1YngGbbsfB224FAByxdhX2WVF7CnFk8JPnHLP0+B65tzDo0Rg48LjJ59YcCRx73vTfdQ54+VlH4+b7togoz5WjNXjg4Ffi0Ie/M/nElvuBxS3AgzfLjfqGkvxacxSwYp/68WgEPPGnZZ+ljSPOAB7znNrDcth8d8FmbLxdbtTvv6747wHrgLgRzRutBn7sJ8RDfN7pR+CyGzdg20LttebW4o6HtuPmch8QDe+RBWzanmAUGaw7aJ+J5w5dsxLnHn+g+DMvOncdHtmRTBjhrQspNmxZoMb4g/u3wFpgzaoRDt2Fudt6+E8AWzYB2UL9YLoAbF5fr8VdsHbVGK8+51hcfcdG0ThOOmw/nHjIvks/6fa3NUdOesgmBp74M6LrtMJZrwd2bKpbvjqs2MO4ZwxNo343gGMbfx+DwiNv4g0A/octWgvdaoy5HcBpAP6j+SJr7YcBfBgAzjnnnO77C04BF4/+zeeditcwRnxXjFcBr/vU7o9/5PnA+iu5WLuL8bzhX4H9j64eNgB+ufzXxG/+w3fxj9fevedklqOeAPx/X5t8bGEr8K6jEZdRk//96jPx5JMOkY3vkJOBt1wx3Xs8wgWnHoYLThUetAAAT9/9oc++Ffj2x7m4nHvPyz8InPhMYjxzxGgl8NP/tPvj//fFwJ2Xk+u+NL6v//zuh0UCpx+1Fv/8y0+deGxnkuG0372USp5ze8dxB++Dy37jma3HBwCvOvdYvOrcYyceu/S6+/Cmj19Lydu6MNpPnn0sfu+lu6ZCPRPAz08+dP8NwAef9Kjr992vfLx4HI8KtzYufH9xMJwXnvja4t+coJn9fjWAk40xJ5TJb69BQbU3cReAZwOAMeZwAKcC2CUI7CdSVgJVijaJRMLSsLGwRKv52bHNys8gex8vd7TRKeiJrK4IbWp/FUoipR36mqhLPbvdO8ZVbXibMU4Zi59Hp7IhrnsCaruntTY1xvwSgC8AiAF81Fp7vTHmTeXzHwLwDgAfM8Z8H4UD+dvW2ge1xtgGaQudZhHalLoJs8hrMRXBJlDeUDHKpBZG/cn3uK8GWh3eepLpLkGb2l+FntpxZGAMkFsgzy0iwbpvpWchwKhFfX0qVbebR1lXXyo8OoaqS2StvQTAJbs89qHG/98L4HmaY5oV0hYdlUSIWngswtrcmCg7KTJdDSJYRMiF5Sf9KF1TQZvDW09kdUVoYySqdd/tfIwigySzSPIcKwXXqruxdeuptylzSyrJ6ynHqNVtr4melL52jaAoNyO0qkmXYA70u5iuKz9/hEwoFNEPOVgVtDm8DZGG9Jx+B7jOY83XM6VrEjijzkjHisc4F/o9hO+AYNRnBloCVYqZ0O/TbW5SMZUKUW3URfNR0cbL+6YE0K5L36Dp9+7XPQum81jxer5xiwT0/YyGOua0cX8tud8m5iE04yGCUZ8RElYCVQrWg8vzusRiSmqQ7vRUjnGEVEYptpDuHBza0JdDDGO0CjvpzIdUJthBi+Wru8sRiXLVGKeNqTvp2EC/ayMY9RmB6iDEICY9liY1NaWaFJUoB1Se9hiZMFFuDs0XfEUbT2eImxu97jNUchhdx9TJRLRK/rRzT53XrBcnyrVhmliE8B2AYNRnhrpNYteeOhmrIgymtOtYhSoDPifbJA7IGLFoFUMuY+pDoiFphqqx0RPSqBKMySYqWp56m+5y4pJdrdbRTWRh/wCCUZ8ZEqXTduVtSE/ABAXJ0onuGmOksnDEEGljFoF+nwRr1BXnou48JqTflRyCmL2fwdDvjd9rKW3ZLjBEhopAMOozgnr2u3Szr7w3gVFnE2vKa4yMNFEu0GcVZkK/D2geafpdL2mw6hHuaaLcOOI9dXEb6SgqehcAet562D8ABKM+M9T01HDo97qkjc9+FynsBfGZGjOh3wfksdD0uyvv634uRuT9kikpyrWJqVNj1Kbgg/gMgGDUZ4YqkaRrT12Rfo/ZbNkq+12YKDdE0RQWMxGfGaJR737ds4grT53Lfu+6cmYW2e+iMbZZwwwqT3157x/BqM8Iap562+x3gffG0okV/S7Ofg/0WYVW2u9Dpt9JhkqDficTSx213bXGRRuZWHdQEY2xDdvEIOwfAIJRnxnc6XfcuafuNvtM9j5iwbN0om3Q76KTfaDfa7CKXNYOcx7psJOe9kGt2CbzhOvKGf/pd9EYA/0+FwSjPiNoNWWg6z+JBV8nysk2KVtuoKviHEZSRjRE2pgFS126w56JOy/hUkXM0u96B5wRnSins3eMyfAAACQME8myigysBaxe/oTPCEZ9RkikJR8sKqWmFuIzU4JVlLOmuMZKI2UTglGvQCeGDXQO6UOO3nywnnCdj6NT0sZov1M5Q5qd2tx9MrTDLIFg1GeETKqNzKJ19jth1MX0e2nUI+HmMUTRFBYs/T5E6h1QDTuxGJE91cXCLiSaMX8rrB2ncoYqoy78zRgE6r1CMOozgj79LhXhkG/2Y3KTyiujLqT5Av1eg21gMtQ5pMNOeipjLLNVSUx37KkbYxoVLRybIEuUU6Tfh5gcSiIY9RlBLM7AgqYh5fR7TNPvRYhghREa9aFSxwzY0sWhtp+kw06K9DtZMpYq9VMvrsFR8O4QIBqjKv3u4unLu5wNCEZ9ZtDKYNWMtdba70JP3RSn5RVST32o1DGDuCXdPLQ57AH9zmqrq5XDomYD2Fp6kdPSprOeFIF+rxCM+gxgrdVLlJsH/S701HOXKBcJN+DQerVGa/p9YJtb66oPDfGZdolyXdepA424v3SMVS29wGSw2gIMAv1eIRj1GcB56ZEBIm/pd15RLhF6Hnlr+j3cmDR1OVRVLcWwEwvnaUu94CQjqG0So+qeVlC906Tfh5pLQiAY9RlAK3sVwAw2e4Gn7hpACDepnC1pU/SqvIebA6mXM1QasrVMrF5DF7afuo6nzsXUKdU7lm1iMMR+BySCUZ8B3E3cdfYqgBb0u9xgshtAXnqJY3FMPYhHVGitoDYwo96DHIOYlIlVy8dpXENKv2cZ4bhoysQGlq9CMOozgPNku27IAIDvs91CfEZKJ2YorrGCFp8JNybPyAy0KU7rsFP38zGuYuoc/d55Pg5ahAiYnu/zSJQLDkEw6rOAuym7bp0IgO+zTWm/c3RiHVNn6fdg1Gv63V9ZVFXQ9PscxGdYRTkN+p0taWNU71Tpdz09At8RjPoMkCmWpNCUFkO/k9m8WRlTHxupotxAk7wY9KCESxU9oN9ZBUbNnJxx1c9BYYyq9PtA1z2BYNRngESrlzrQOP2yderdK8rVRj0YJBpsCZdiq1FVsF7fXLTfucxyjZwcVnuiGiOTKBfq1FURjPoMoCkewcda5UlobN1tVi6rMULmNg02hpwNPKZOZ79rKMqVXjCZ/a6RkxO3zNCnSto06fcQUw9GfRbItCRigRlkv0s8dTKbF4F+bw22GUZ1eBvYwYilchWbBLH91KvqGQ36nRXIqSp8CPEZ1ez3YNSDUZ8BdBPl9MRn6sQf4SZVGfVQjkUj0O+TUAw7seAT5fSYPiZEkOUW1hLiWqriMwNNECUQjPoMQKktsaC131uUtEk9dePo95D9TiPQ75NoTb8rlLRV5WJCYRfFktgRQb/TOUNs+S2DQL9XCEZ9Bki1eqkDqtrvdPlL6amPxDKxwVOvEMRnJkH3l/effs8U6XcmUY6u7gn0+1wQjPoMoKoo15p+n35za7ZptHZ6w56iVJSTeupDFU5hEEWAiQBYWVx9sF3aWNElPfo9jrlEOUrYhUSVzCdgE6gObUCg3+eEYNRnAE36rD39Pr3BNMY0VOUEm4AtrjESZ7+HG3MCzAFuqMpaPch+ZxXlUsWSWIZ9S1gmMmS/zwXBqM8AqWaiXEzW65IGk6HrUuOMepCJbQVGPXCoNCS77qvEQY069f4kyklkYmlPfS70e9g7glGfAVQV5ehYK7fomc5TtafOxtQHZpBYMGVcijFkVdAMlV6JH68op9elbUwcPKhe6sCcxGfC3hGM+gyQMLrILBx9rtRnu+o8JdkEQHrqFZsQbkwAXBx58PQ7qc+gqShH1qlr9FOPCfqdru5xe41m69WhrXsCwajPAKli68SahtRRaxsRPdUX2Zh6oNAmEej3Gn2g34kkNKAFvU2gKruThNNysuFMoN/ngmDUZwBdmVjdUidGVc556rE4ph7o9wkwm+Jgs9/9L/GjS0BZepsA00+dUpMDAv0+JwSjPgNQbQlZ0NqNZXViAAASTklEQVTvnMFk9N8TWywrsVEP4jOTYOjLbKAHIzcXNgME5ZWa88H2KtcUr4qJuD9Pv4fs93kgGPUZoM5e1ZCJdZtbDkhid+RJtmrVKLhW4mLqtnvVu0GD8XSGSkMawxkJRdlcJgkNqA8BOoly8rI7enwx6YAwGKroEoFg1GeAuiGDgqduDLnZc4ueqmu1gX6fCVrR7wOcw1brvvv5YJLQmq/XcAqqsjvBGOnxVb+XcB9gEFi+CsGozwBVIolGohzANfsgY63uRpZQii5RLraBfm+FVuIzA5xDZt0rChoxSWjF6xUT5ZhwWts69UC/qyIY9Rkg0WzoAqgqjY1axNQjSfa7tUW8FAg3pgNTxjXkza3KMWDCEXrZ73LxGb2cnLqfukL2u6ZM7JDXvRDBqM8AmaJ4BACu1za5uY2I7PeE8dTdTWniIsQQELLfd4Vi2IkBk4SW5xbu5Spd2ohOcnTJLqstwCCwfBWCUZ8BEs1EOYCk3zmlsTFTp54XRj2SJMqFm3J3RAR9OVTxGYCk3/VKnepEOYkXXOfjGIXDrHM8JJ3kahlsln4PrVc1EYz6DKApHgFAlX5nvI8FW7wnlhj1oWZttwGjHjjkzY0p8VOcD4bVctS2Vuguprq0kWNUpd8HfJgVIhj1GSDTTpSjYq2c0aTodzhPXUK/u3h6aLtaISayh5cF/U7Mh6r2O+GpK+0dY6ZBE539rkm/D3jdCxGM+gyQaCrKAaqlTgylGOj3GSHQ75PwnH5nurRpdmgDasdDpP3ucobo7HdN+j3sH8GozwCqinIASb+3U5ST0HULefEekVEP9PvuoOj3ARt1SnxGj34fE/dKTW3rbMUjYox1dQ/rqWvS74HpC0Z9BlBPlGvV6IPVfp/eU18oPXUjYRKG7GGyYOp8h0xDMkZCsW4/Juj3RFO4Co1wGtFPXTxGhmliEZi+CsGozwCZ8o3J9dnm6HeGrnPiM1RMfYhKaCw8jyGrw/McA3eozwRecKZNv1OKcmyXNsWYepWTM8B1L0Qw6jOAdgYr12eboyEZus7R7yJPPdDvu4PxTIdMQ7bRfleYD0ZRLlFOsqXEpLIe1KkPOewkRDDqM4Bb9FoZrJr0O0PXLeSlopwNCV6tELfInRgiDUnR73MQn2ES5ZQcAi5Dn8wZmgv9HvaPYNRngEw9+70N/c5pv4vq1EujbiiaNNyUFTxXUFOH5wp7lVBTbmGnbA9bS7BqlbTJ72e6pI35vVgE+r1CMOozgGt2op4op0C/1w0g5J66sen0va+HbIxYUEZswAlDzLpXDOtEkYFzZqfNQaGT0EjUzJucTZAnys2Bfh/iuhciGPUZYG6KcgqlTnEkP9knOZCWTV2mvqED/b47WikHDjimTtHvOvMxEt4v+opyLkdGkv3eUlFOk34P+0cw6rNAqtg6EQDnwZElH2NCUS7Lc6RwNdZTjnHISmgsKOXAAdOQimEnFlIFxlQ5H6cN/T72mn4PRt0hGPUZoFJcUqPf24hwdJ8ol2YWCYRjDDfl7gj0+yQ8p9+BZnb5dPdLqpyPMyJ6OdBOi6r4DNewaogIRn0GSOfVT31qLzgDYAEYQOgRMA0gkjxHBin9PuBGJCwUG/f0AlIjYa16gxuXVzPt/ZKw1DaJEdF1kR4jU3rLYsjrXohg1GeAlBVnYCH14FqoLblEOYn4TJbZqqlLoN9boBX9PsDNTUq/u7kwkfgwy2IkvF8yltomwSTK0WMM9PtcEIz6DFBnh3pKv7fILK88D6H0ZRro9/ZgGpgsC/pduqb05mJceerT3S+JcpItI/ucsKp3jJ4Gi0C/VwhGfQZw+s369Hv3BpNRoEqzJv0+5RgD/b47KOXAAR+OpMzFHOYiFsastVk+ppqFbljlKg5sDggOERSGvO6FCEZ9Bsiq1oRK0ynVwK5UxgijHsvp9zS3SKyj36ccY6Dfd0cr8ZkBbm5SOncOgkb1/TKdEauEqzyWiaXHaIxerXqQma4QjPoMoN0TWU5DzoB+F2a/8/R7uCkrxET28JAPR4phJxZjYWIpTW2TqEva5J3kqDFqUfBBkbJCMOozQKLeT13YZ1ubfs9zpGL6fcCiKSwC/T4JadhpnvT7lPcLTW2T4PTpWzSd0RKgCeG7CsGozwC0NjKLWFiv26LZQdWlbcqTvbUWSWZr8RmpVzVED5OFYuOeXkC67ueQNCjt1JYo7x3V+EQlbS08da32q0Ne90IEoz4D6MvESmOLvMqYo+umjam7l1X0uzSmHm7KGuIYcl4kJQHDZDzoda8ZU5fdL1nm8nF0+6mLSlQrca029HvXRj04BQ5qRt0Y81FjzAZjzHV7eN4YY95njLnVGPM9Y8xZWmNrC/U6dcXsdyld5zyAHMIQQWiduDsiku2IRkWS0tAgDTvNgX4fCbXV06pyRjdRLiEU5agxatDvzcOsCX6q5g76MQDvB3DxHp5/IYCTy3/nA/hg+V81pFmObNquYhPv081grQxfulD82xuSHZPvE8CdzhfSHAvp3r3uHYvFa1JTbsDJ9unG6F4TYmI1qoTIxSl/5+2T7xsanBc29brfPvk+BbiD/c4km+p+WUhbeMEEmjK204wPABbTFmyC23Om3QcYZIvFf6PxMA+zQqjtoNbarxljjn+Ul1wI4GJbNCK+0hhzgDHmSGvtj1QGCOB9l92C9/3brfT7tW7MatO+4v3FP+n7BHAHlS/feD9OffulU78vM+XS+vgrZBccqkFi4IzRDy4F/ugw+fuGBrc2rvpQ8W/q92l66sX98nMfu0b2PrU69eI6uYXofgbIuL/7zT5wnvy9Ugx13Qvhk1t0NID1jb/vLh/bzagbY94I4I0AsG7dupkNIIoMVpAJK2cfdyDWrlJaVMc9Gdj3UGDn5unfYyLgtBeJL/X4Y/bHMQeuxoZHZKfsDUdeADx4qyyWtmI/4ISnC0c4YBz5BOCA44AtwnPtY1/azXjmjeOeBOx7GLDz4enfYyLgtBd3N6Zd8JzHHob/uH2jKGb9/9q7+2CrqjKO49+fiEIKvgSpg2RqJjLkXAzJl0SaLPGltJpGtMmXasxRRh0HjfxDrcZQS6XSwemFiQpBJl/yrdIhGDVQAUVeBA2TDDWxSVHTMZWnP9Y63X2u517vRe7Z3H1+n5k795y11z577WfWvc/Za5+z1ge278fh+w7pxVa1k8Qxo3Zn3uoNPdpv2C4D2X/3QT0/4AHHw4M3kNae6GUHfKH3j9EHKDZjuHmzD5au1O+MiFENtt0FTI2IB/LzecBFEbG0q9ccM2ZMLFnSs3fFZmZmfZmkpRExpmP51vSpgvXA8MLzPYHnSmqLmZlZn7M1JfXbgVPzp+APATY28366mZlZX9e0e+qSZgPjgSGS1gOXAv0BIuIG4G7gWGAt8DpwRrPaZmZmVgXN/PT7ye+xPYBzmtQcMzOzytmaht/NzMzsfXBSNzMzqwgndTMzs4pwUjczM6sIJ3UzM7OKcFI3MzOrCCd1MzOzinBSNzMzqwgndTMzs4po6iptvUHSi8Dft+BLDgH+tQVfr69zPOo5HvUcj3qORz3Ho96WjMdeETG0Y2GfT+pbmqQljZaza1WORz3Ho57jUc/xqOd41GtGPDz8bmZmVhFO6mZmZhXhpP5uPyu7AVsZx6Oe41HP8ajneNRzPOr1ejx8T93MzKwifKVuZmZWEU7qBZImSHpC0lpJU8puTxkkrZO0QtIySUty2a6S7pX01/x7l7Lb2VskzZC0QdLKQlmn5y/pO7m/PCHp6HJa3Xs6icdlkp7NfWSZpGML2yobD0nDJc2XtFrSKknn5fKW7B9dxKNV+8cASQ9LeizH47u5vLn9IyL8k25B9AOeAvYBtgMeA0aW3a4S4rAOGNKh7CpgSn48Bbiy7Hb24vmPAw4CVr7X+QMjcz/ZHtg7959+ZZ9DE+JxGTC5Qd1KxwPYAzgoPx4EPJnPuSX7RxfxaNX+IWDH/Lg/8BBwSLP7h6/U240F1kbE3yLiv8Ac4ISS27S1OAGYmR/PBE4ssS29KiLuA/7dobiz8z8BmBMRb0bE08BaUj+qjE7i0ZlKxyMino+IR/LjV4HVwDBatH90EY/OVD0eERGv5af980/Q5P7hpN5uGPCPwvP1dN1BqyqAeyQtlXRmLtstIp6H9IcMfKi01pWjs/Nv5T4zSdLyPDxfG05smXhI+ggwmnQ11vL9o0M8oEX7h6R+kpYBG4B7I6Lp/cNJvZ0alLXiVwMOj4iDgGOAcySNK7tBW7FW7TPTgX2BNuB54Opc3hLxkLQjcDNwfkS80lXVBmWtEI+W7R8R8U5EtAF7AmMljeqieq/Ew0m93XpgeOH5nsBzJbWlNBHxXP69AbiVNBz0gqQ9APLvDeW1sBSdnX9L9pmIeCH/89oE/Jz2IcPKx0NSf1ICmxURt+Tilu0fjeLRyv2jJiJeBhYAE2hy/3BSb7cY2E/S3pK2AyYCt5fcpqaStIOkQbXHwOeAlaQ4nJarnQb8vpwWlqaz878dmChpe0l7A/sBD5fQvqaq/YPKvkjqI1DxeEgS8EtgdURcU9jUkv2js3i0cP8YKmnn/HggcBSwhib3j23f7wtURUS8LWkS8CfSJ+FnRMSqkpvVbLsBt6a/VbYFboyIP0paDMyV9A3gGeArJbaxV0maDYwHhkhaD1wKXEGD84+IVZLmAo8DbwPnRMQ7pTS8l3QSj/GS2khDheuAb0FLxONw4GvAinzfFOBiWrd/dBaPk1u0f+wBzJTUj3TBPDci7pS0iCb2D88oZ2ZmVhEefjczM6sIJ3UzM7OKcFI3MzOrCCd1MzOzinBSNzMzqwgndbMSSZoqabykE9XDlQHz92IfkvSopCM6bFsg6Zn8XeJa2W2SXis8/5iku/MqUaslzZW0W25P5K/g1OqOzmWTC2WTJa2RtDKvTHXq5kVhy5B0uqTrymyDWdmc1M3K9UnSfNlHAvf3cN/PAGsiYnRENNr3ZdJ3icmTYvx/UhBJA4C7gOkR8dGIOIA0vefQXGUFcFLhtSaSVpSq7X8W8FlgbESMIq3m1mjaSzNrIid1sxJI+qGk5cDBwCLgm8B0SZc0qLuXpHl5gYx5kj6cJ/e4CjhWac3qgQ0OM4eUjAG+BNxS2HYKsCgi7qgVRMT8iKjN/vUMMCBfuYs03eUfCvtfDJxdm/s8IjZGxEw6kHSupMdz2+fksrGSFuYRhoWS9s/lp+fRhDskPS1pkqQLcr0HJe2a6y2QNC3vu1LSu1a2yqMYN0tanH9qb26OVPs634/WZlA0qwondbMSRMSFpET+K1JiXx4RB0bE9xpUvw74dUQcCMwCfhIRy4BLgJsioi0i3miw3zxgXJ7haiJwU2HbKGDpezTzd6TZrw4DHgHeBMiJcFBEPNWNU50CjM5tPyuXrQHGRcTofA4/6NCuU0jzhV8OvJ7rLQKKw/s7RMRhwNnAjAbH/TFwbUQcDHwZ+EUun0yauasNOAJoFDezPsvTxJqVZzSwDBhBmiqyM4eSrrQBfkO6Qu+Od4AHSMPoAyNiXeEWe3fMJb0RGAHMJiV3SMPs3Z2KcjkwS9JtwG25bCfSdJr75dfpX6g/P6/N/aqkjUBtJGEFcGCh3mxI671LGlybc7vgKGBk4XwH5zcjfwGukTQLuCUi1nfzPMz6BF+pmzWZpLY8V/blwIWke9sTuhhG76gnczvPAX5KStBFq4BPdHmQiH8Cb5Hunc8rlL8C/EfSPt04/nHA9flYSyVtC3yflLxHAZ8HBhTqv1l4vKnwfBP1FyEdY9Dx+TbAoXkUoy0ihkXEqxFxBWmEZCDwoKQR3TgHsz7DSd2sySJiWR7+fRIYCfwZOLqLYfSFtN8b/yrp6ru77gemkq9sC24EDpN0XK1A0gRJH+9Q7xLg2w0WmpgKXC9pcN53sKQzixUkbQMMj4j5wEXAzsCOpCv1Z3O103twLkUn5WN8CtgYERs7bL8HmFRoS1v+vW9ErIiIK4ElpFEIs8rw8LtZCSQNBV6KiE2SRkREV8Pv5wIzJF0IvAic0d3jRFqx6UcNyt+QdDwwTdI00hX5cuA84IOFegs7eenppAS9WNJbef+rO9TpB/xW0k6kIftrI+JlSVeRht8vIL2h2RwvSVoIDAa+3mD7uaQ3HctJ/+fuI93TP1/Sp0m3Jh6n/sN/Zn2eV2kzsz5F0gJgckQsKbstZlsbD7+bmZlVhK/UzczMKsJX6mZmZhXhpG5mZlYRTupmZmYV4aRuZmZWEU7qZmZmFeGkbmZmVhH/A1hPCO1xbYIYAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Detect swaps. This method works only under the assumption that\n",
    "# when performing local MCMC moves, starting from two different \n",
    "# initial states, you cannot end up with the same state\n",
    "swaps = {}\n",
    "# for each pair of chains...\n",
    "for i in range(len(chains) - 1):\n",
    "    # shift one chain by one state to the left.\n",
    "    # Where states from both chains match up, a successful exchange\n",
    "    # was performed\n",
    "    matches = np.where(chains[i, :-1] == chains[i+1, 1:])[0]\n",
    "    if len(matches) > 0:\n",
    "        swaps[i] = matches\n",
    "\n",
    "\n",
    "# Reconstruct trajectories of single states through the temperature\n",
    "# ladder\n",
    "def reconstruct_trajectory(start_index, chains):\n",
    "    res = []\n",
    "    current_ens = start_index\n",
    "    for i in range(len(chains)):\n",
    "        res.append(current_ens)\n",
    "        if i in swaps:\n",
    "            if current_ens in swaps[i]:\n",
    "                current_ens += 1\n",
    "            elif current_ens in swaps[i] + 1:\n",
    "                current_ens -= 1\n",
    "\n",
    "    return np.array(res)\n",
    "\n",
    "\n",
    "def plot_state_trajectories(trajectories, ax, max_samples=300):\n",
    "    for trajectory in trajectories:\n",
    "        ax.plot(-trajectory[:max_samples] - 1, lw=2)\n",
    "    ax.set_xlabel(\"# of MCMC samples\")\n",
    "    ax.set_ylabel(r\"inverse temperature $\\beta$\")\n",
    "    # make order of temperatures appear as above - whatever it takes...\n",
    "    ax.set_yticks(range(-len(temperatures), 0))\n",
    "    ax.set_yticklabels(temperatures[::-1])\n",
    "    \n",
    "\n",
    "# which states to follow\n",
    "start_state_indices = (4, 0)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "trajectories = np.array([reconstruct_trajectory(i, chains) \n",
    "                         for i in start_state_indices])\n",
    "plot_state_trajectories(trajectories, ax)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By following the initial state of the $\\beta=0.1$ chain and checking when it arrives at $\\beta=1.0$, you can estimate how long it takes for a state to traverse the temperature ladder and potentially help the simulation at $\\beta=1.0$ escape from its local minimum."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drawbacks\n",
    "If what you read so far leaves you amazed about the power of RE, you have all the reason to!\n",
    "But unfortunately, nothing is free in life...\n",
    "In the above example, the price we pay for the improved sampling of the distribution at $\\beta=1$ is given by the computing time expended to simulate the two replicas at $\\beta > 1$.\n",
    "The samples we drew in those replicas are not immediately useful to us.  \n",
    "Another issue is finding an appropriate sequence of temperatures.\n",
    "If your distribution has many modes and is higher-dimensional, you will need much more than one interpolating replica.\n",
    "Temperatures of neighboring replicas need to be similar enough as to ensure reasonable exchange rates, but not too similar in order not have too many replicas.  \n",
    "Furthermore, the more replicas you have, the longer it takes for a state to diffuse from a high-temperature replica to a low-temperature one&mdash;states essentially perform a random walk in temperature space.  \n",
    "Finally, RE is not a mainstream technique yet&mdash;its use has mostly been limited to computational physics and biomolecular simulation, where computing clusters are readily available to power this algorithm.\n",
    "This means that there are, to the best of my knowledge, no RE implementations in probabilistic programming packages.\n",
    "The good news is that [TensorFlow Probability](https://www.tensorflow.org/probability) seems to have a RE implementation and seeing that [PyMC4](https://github.com/pymc-devs/pymc4), the successor to the popular PyMC3 probabilistic programming package, will have TensorFlow Probability as a backend, we can hope for a GPU-ready RE implementation in PyMC4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "I hope I was able to convince you that Replica Exchange is a powerful and relatively easy-to-implement technique to improve sampling of multimodal distributions.\n",
    "Now go ahead, [download the notebook](https://github.com/tweag/blog-resources/blob/master/mcmc-intro/mcmc_introduction.ipynb) and play around with the code!\n",
    "Things you might be curious to try out are varying the number of replicas, the temperature schedule or the number of swap attempts. How are those changes reflected in the state trajectories across the temperature ladder?  \n",
    "If you want to take a deeper dive into RE, topics you might be interested in are [histogram](https://doi.org/10.1002/jcc.540130812) [reweighting](https://doi.org/10.1103/PhysRevLett.109.100601) [methods](http://proceedings.mlr.press/v22/habeck12.html), which allow you to recycle the formerly useless samples from the $\\beta<1$ replicas to calculate useful quantities such as the probability distribution's normalization constant, or research on optimizing the temperature ladder (see [this paper](https://doi.org/10.1101/228262) for a recent example).  \n",
    "\n",
    "This concludes Tweag's introductory MCMC blog post series.\n",
    "I hope you now have a basic understanding of both basic and advanced MCMC algorithms and specific sampling problems they address.\n",
    "The techniques you learned are becoming more and more popular, enabling wide-spread use of Bayesian data analysis methods by means of user-friendly probabilistic programming packages.\n",
    "You are now well-equipped with the necessary background knowledge to use these packages and ready to tackle your own complex data analysis problems with powerful sampling techniques!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

replace_inlinemath.py

#!/usr/bin/env python3

import sys
from itertools import cycle
import re

with open(sys.argv[1]) as ipf:
    lines = ipf.readlines()
# ## replace \{ with \\{ and \} with \\}
lines = [l.replace('\\{', r'\\{') for l in lines]
lines = [l.replace('\\}', r'\\}') for l in lines]

## replace \\ with \\\\
lines = [l.replace(r' \\', r' \\\\') for l in lines]

## replace ^* with ^\*
lines = [l.replace(r'^*', r'^\*') for l in lines]

## alternatingly replace $ with \\( and \\)
## if it's not part of $$
lines2 = []
for line in lines:
    if '$$' in line:
        lines2.append(line)
        continue
    else:
        cycler = cycle((True, False))
        matches = re.finditer('\$', line)
        offset = 0
        for match in matches:
            replacement = '\\\(' if next(cycler) else '\\\)'
            line = line[:match.start()+offset] + replacement + line[match.start()+1+offset:]
            offset += 2
        lines2.append(line)

with open(sys.argv[2]) as ipf:
    header = ipf.readlines()

with open(sys.argv[3], 'w') as opf:
    for line in header + lines2[2:]:
        opf.write(line)

Reads nicely @simeoncarstens !

Here are a few thoughts that I had while reading the beginning (will continue another day). Some of them are resolved by reading it several times, but maybe it is a good hint for where a reader might hang a bit:

A sufficient (but not neccessary), convenient condition for a Markov chain to have a distribution $p(x)$ as its invariant distribution is called detailed balance: $p(x)T(y|x) = p(y)T(x|y)$.

what is y in the equation?

A distribution $\pi$ of the state space of a Markov Chain

Calling the stationary distribution eigenvector \pi confuses me because I associate it so much with a number. But maybe it is the standard. In that case never mind ...

So all that is fun, but back to sampling arbitrary probability distributions. If we could design our transition kernel in such a way that the next state is already drawn from $\pi$, we would be done, as our Markov Chain would... well... immediately sample from $\pi$. Unfortunately, to do this, we need to be able to sample from $\pi$, which we can't. Otherwise you wouldn't be reading this, right?

I feel this is a nice paragraph but it could be easier to understand without prior knowledge: You don't really introduce what "design our transition kernel" means. Also, how can I "draw from \pi" I thought I only draw a new state based on the row in T of the previous step?

n $q(x_{i+1}^*|x_i)$, from

the ^* is difficult to see and read. Probably better if it has different support. Otherwise, can you use a different symbol?

probability $p_\mathrm{acc}(x_{i+1}=x_{i+1}^|x_{i+1}^, x_i)$

For this transition kernel to obey detailed balance, we need to choose $p_\mathrm{acc}$ correctly. One possibility is the Metropolis acceptance criterion:

how can we know when it is set correctly? Is this difficult to grasp intuitively?

I don't think the method you use for the mixture of Gaussians can be called Gibbs sampling. As you say, in Gibbs sampling you'd have to draw from p(k|x), but it does not equal p(k) because k and x are not independent. You'd have to use the Bayes theorem to calculate p(k|x).

Your method is to draw hierarchically: first draw k from the marginal distribution, then draw x from the conditional distribution, whereas in Gibbs sampling you draw from both conditional distributions, each time using the value from the previous step.

Your method works, but it works for a different reason than the reason Gibbs sampling works. I don't think it has a name.

Edit: moreover, I think your method works well precisely because you are not using GIbbs sampling. If you did, you'd have the same problem of being stuck in one of the mixture components, because p(k|x) would very likely give you the same k as the one that generated that x.

Finished reading — very nice! I corrected a few typos here: https://gist.github.com/feuerbach/5ccaeee166b45be13a8e375f980f405a.

Maybe one day I'll make a similar post except everything is done in Stan :)

Thanks for your feedback, @MMesch and @feuerbach! Highly appreciated!
For now I mostly worked on the MH part and put it into a separate notebook, where I addressed some of @MMesch's points.

@MMesch: I fear the \pi is indeed somewhat standard - as p often denotes other probabilities such as p_acc.

@feuerbach: This is very interesting - and you're right. The background to this example is that, a few years ago, I did something like that to sample from a different kind of mixture model and back then we used to call it Gibbs sampling. Looking this up, it seems like a very common method to sample from Gaussian (and other) mixture models (where you can easily marginalize out x to obtain p(k)). It seems to be called "Collapsed Gibbs sampling". I will rewrite this part to feature an actual Gibbs sampler. I just need to think of a nice, concise example where you can sample from the conditional distributions without resorting to MCMC. And as for being stuck in one of the mixture components: highly correlated samples often are a problem when using Gibbs sampling and I should discuss this.

I am also thinking of discussing how to assess convergence for MCMC methods, but this is a very difficult topic. It would make the series much more complete, but is also a really ugly rock to look under...

@feuerbach: Just FYI, I implemented the actual Gibbs sampler for this problem and it turns out that

you'd have the same problem of being stuck in one of the mixture components, because p(k|x) would very likely give you the same k as the one that generated that x.

is a slight understatement. If the sampler starts in the mode on the right, there's (on average) a ~1/1e6 chance for it to jump to the mode on the left. That was fun and very instructive and might even serve in a next version of that blog post / notebook as a negative example.